diff --git a/sly/lexer/GenericLexer.cs b/sly/lexer/GenericLexer.cs
index cb866797..82e604c7 100644
--- a/sly/lexer/GenericLexer.cs
+++ b/sly/lexer/GenericLexer.cs
@@ -55,7 +55,6 @@ public Config()
                 IgnoreEOL = true;
                 IgnoreWS = true;
                 WhiteSpace = new[] { ' ', '\t' };
-                
             }
 
             public IdentifierType IdType { get; set; }
@@ -65,25 +64,27 @@ public Config()
             public bool IgnoreWS { get; set; }
 
             public char[] WhiteSpace { get; set; }
-            
+
             public bool KeyWordIgnoreCase { get; set; }
-            
+
             public bool IndentationAware { get; set; }
-            
+
             public string Indentation { get; set; }
-            
+
             public IEnumerable<char[]> IdentifierStartPattern { get; set; }
-            
+
             public IEnumerable<char[]> IdentifierRestPattern { get; set; }
 
-            public BuildExtension<IN> ExtensionBuilder { get; set; }
+            public Action<IN, LexemeAttribute, GenericLexer<IN>> ExtensionBuilder { get; set; }
+
+            public IEqualityComparer<string> KeyWordComparer =>
+                KeyWordIgnoreCase ? StringComparer.OrdinalIgnoreCase : null;
 
-            public IEqualityComparer<string> KeyWordComparer => KeyWordIgnoreCase ? StringComparer.OrdinalIgnoreCase : null;
             public IList<string> Modes { get; set; }
         }
-        
+
         public LexerPostProcess<IN> LexerPostProcess { get; set; }
-        
+
         public string I18n { get; set; }
 
         public const string in_string = "in_string";
@@ -104,25 +105,27 @@ public Config()
         public const string escape_string = "escape_string";
         public const string escape_char = "escape_char";
         public const string in_up_to = "in_upto";
-        
+
 
         public const string single_line_comment_start = "single_line_comment_start";
 
         public const string multi_line_comment_start = "multi_line_comment_start";
 
-        protected readonly Dictionary<GenericToken, Dictionary<string, (IN tokenId, bool isPop, bool isPush, string mode)>> derivedTokens;
+        protected readonly
+            Dictionary<GenericToken, Dictionary<string, (IN tokenId, bool isPop, bool isPush, string mode)>>
+            derivedTokens;
+
         protected IN doubleDerivedToken;
         protected char EscapeStringDelimiterChar;
 
-        protected readonly BuildExtension<IN> ExtensionBuilder;
-        public FSMLexerBuilder<GenericToken> FSMBuilder;
+        protected readonly Action<IN, LexemeAttribute, GenericLexer<IN>> ExtensionBuilder;
+        public FSMLexerBuilder<GenericToken> FSMBuilder { get; private set; }
         protected IN identifierDerivedToken;
         protected IN intDerivedToken;
 
-        
 
         protected FSMLexer<GenericToken> TempLexerFsm;
-        
+
         internal IDictionary<string, FSMLexer<GenericToken>> SubLexersFsm { get; set; }
 
         protected int StringCounter;
@@ -130,21 +133,24 @@ public Config()
         protected int upToCounter;
 
 
-        protected Dictionary<IN, Func<Token<IN>, Token<IN>>> CallBacks = new Dictionary<IN, Func<Token<IN>, Token<IN>>>();
+        protected Dictionary<IN, Func<Token<IN>, Token<IN>>> CallBacks =
+            new Dictionary<IN, Func<Token<IN>, Token<IN>>>();
 
         protected char StringDelimiterChar;
 
         private readonly IEqualityComparer<string> KeyWordComparer;
 
         public GenericLexer(IdentifierType idType = IdentifierType.Alpha,
-                            BuildExtension<IN> extensionBuilder = null,
-                            params GenericToken[] staticTokens)
+            Action<IN, LexemeAttribute, GenericLexer<IN>> extensionBuilder = null,
+            params GenericToken[] staticTokens)
             : this(new Config { IdType = idType, ExtensionBuilder = extensionBuilder }, staticTokens)
-        { }
+        {
+        }
 
         public GenericLexer(Config config, GenericToken[] staticTokens)
         {
-            derivedTokens = new Dictionary<GenericToken, Dictionary<string, (IN tokenId, bool isPop, bool isPush, string mode)>>();
+            derivedTokens =
+                new Dictionary<GenericToken, Dictionary<string, (IN tokenId, bool isPop, bool isPush, string mode)>>();
             ExtensionBuilder = config.ExtensionBuilder;
             KeyWordComparer = config.KeyWordComparer;
             SubLexersFsm = new Dictionary<string, FSMLexer<GenericToken>>();
@@ -162,7 +168,9 @@ public void AddCallBack(IN token, Func<Token<IN>, Token<IN>> callback)
             CallBacks[token] = callback;
         }
 
-        public void AddDefinition(TokenDefinition<IN> tokenDefinition) { }
+        public void AddDefinition(TokenDefinition<IN> tokenDefinition)
+        {
+        }
 
 
         public LexerResult<IN> Tokenize(string source)
@@ -170,7 +178,7 @@ public LexerResult<IN> Tokenize(string source)
             var memorySource = new ReadOnlyMemory<char>(source.ToCharArray());
             return Tokenize(memorySource);
         }
-        
+
         public LexerResult<IN> Tokenize(ReadOnlyMemory<char> memorySource)
         {
             Stack<FSMLexer<GenericToken>> lexersStack = new Stack<FSMLexer<GenericToken>>();
@@ -178,10 +186,10 @@ public LexerResult<IN> Tokenize(ReadOnlyMemory<char> memorySource)
             FSMLexer<GenericToken> LexerFsm = SubLexersFsm[ModeAttribute.DefaultLexerMode];
             lexersStack.Push(LexerFsm);
             LexerPosition position = new LexerPosition();
-            
+
             var tokens = new List<Token<IN>>();
             string src = memorySource.ToString();
-            
+
             var r = LexerFsm.Run(memorySource, new LexerPosition());
             LexerFsm = SetLexerMode(r, lexersStack);
 
@@ -189,15 +197,15 @@ public LexerResult<IN> Tokenize(ReadOnlyMemory<char> memorySource)
                 new Token<IN>(default(IN), x.SpanValue, x.Position, x.IsComment,
                     x.CommentType, x.Channel)).ToList();
             tokens.AddRange(ignored);
-            
-            
+
+
             switch (r.IsSuccess)
             {
                 case false when !r.IsEOS:
                 {
                     var result = r.Result;
                     var error = new LexicalError(result.Position.Line, result.Position.Column, result.CharValue, I18n);
-                    return new LexerResult<IN>(error,tokens);
+                    return new LexerResult<IN>(error, tokens);
                 }
                 case true when r.Result.IsComment:
                     position = r.NewPosition;
@@ -216,7 +224,7 @@ public LexerResult<IN> Tokenize(ReadOnlyMemory<char> memorySource)
                 {
                     transcoded = callback(transcoded);
                 }
-                
+
                 if (transcoded.IsLineEnding)
                 {
                     ComputePositionWhenIgnoringEOL(r, tokens, LexerFsm);
@@ -227,17 +235,18 @@ public LexerResult<IN> Tokenize(ReadOnlyMemory<char> memorySource)
                     for (int i = 1; i < r.UnIndentCount; i++)
                     {
                         tokens.Add(transcoded);
-                    }   
+                    }
                 }
+
                 tokens.Add(transcoded);
-                r = LexerFsm.Run(memorySource,position);
+                r = LexerFsm.Run(memorySource, position);
                 LexerFsm = SetLexerMode(r, lexersStack);
-                
-                 ignored = r.IgnoredTokens.Select(x =>
-                                new Token<IN>(default(IN), x.SpanValue, x.Position, x.IsComment,
-                                    x.CommentType, x.Channel, x.IsWhiteSpace, x.DecimalSeparator)).ToList();
-                            tokens.AddRange(ignored);
-                
+
+                ignored = r.IgnoredTokens.Select(x =>
+                    new Token<IN>(default(IN), x.SpanValue, x.Position, x.IsComment,
+                        x.CommentType, x.Channel, x.IsWhiteSpace, x.DecimalSeparator)).ToList();
+                tokens.AddRange(ignored);
+
                 switch (r.IsSuccess)
                 {
                     case false when !r.IsEOS:
@@ -245,14 +254,15 @@ public LexerResult<IN> Tokenize(ReadOnlyMemory<char> memorySource)
                         if (r.IsIndentationError)
                         {
                             var result = r.Result;
-                            var error = new IndentationError(result.Position.Line, result.Position.Column,I18n);
-                            return new LexerResult<IN>(error,tokens);
+                            var error = new IndentationError(result.Position.Line, result.Position.Column, I18n);
+                            return new LexerResult<IN>(error, tokens);
                         }
                         else
                         {
                             var result = r.Result;
-                            var error = new LexicalError(result.Position.Line, result.Position.Column, result.CharValue,I18n);
-                            return new LexerResult<IN>(error,tokens);
+                            var error = new LexicalError(result.Position.Line, result.Position.Column, result.CharValue,
+                                I18n);
+                            return new LexerResult<IN>(error, tokens);
                         }
                     }
                     case true when r.Result.IsComment:
@@ -276,6 +286,7 @@ public LexerResult<IN> Tokenize(ReadOnlyMemory<char> memorySource)
                 eos.Position = new LexerPosition(prev.Position.Index + 1, prev.Position.Line,
                     prev.Position.Column + prev.Value.Length);
             }
+
             tokens.Add(eos);
             return new LexerResult<IN>(tokens);
         }
@@ -283,7 +294,7 @@ public LexerResult<IN> Tokenize(ReadOnlyMemory<char> memorySource)
         private FSMLexer<GenericToken> SetLexerMode(FSMMatch<GenericToken> r, Stack<FSMLexer<GenericToken>> lexersStack)
         {
             FSMLexer<GenericToken> LexerFsm = lexersStack.Peek();
-            
+
             if (!r.IsEOS)
             {
                 if (r.IsPop)
@@ -308,9 +319,10 @@ private FSMLexer<GenericToken> SetLexerMode(FSMMatch<GenericToken> r, Stack<FSML
             return LexerFsm;
         }
 
-        private void ComputePositionWhenIgnoringEOL(FSMMatch<GenericToken> r, List<Token<IN>> tokens,FSMLexer<GenericToken> LexerFsm)
+        private void ComputePositionWhenIgnoringEOL(FSMMatch<GenericToken> r, List<Token<IN>> tokens,
+            FSMLexer<GenericToken> LexerFsm)
         {
-            if (!LexerFsm.IgnoreEOL)            
+            if (!LexerFsm.IgnoreEOL)
             {
                 var newPosition = r.Result.Position.Clone();
 
@@ -321,10 +333,10 @@ private void ComputePositionWhenIgnoringEOL(FSMMatch<GenericToken> r, List<Token
                     int column = 0;
                     int index = newPosition.Index;
                     // r.Result.Position.Line = line+1;
-                    r.NewPosition.Line = line+1;
+                    r.NewPosition.Line = line + 1;
                     r.NewPosition.Column = column;
                 }
-            }                        
+            }
         }
 
 
@@ -339,19 +351,20 @@ private void InitializeStaticLexer(Config config, GenericToken[] staticTokens)
                 .WhiteSpace(config.WhiteSpace)
                 .IgnoreEOL(config.IgnoreEOL)
                 .Indentation(config.IndentationAware, config.Indentation);
-            
-            
+
 
             // start machine definition
             FSMBuilder.Mark(start);
 
-            if (staticTokens.Contains<GenericToken>(GenericToken.Identifier) || staticTokens.Contains<GenericToken>(GenericToken.KeyWord))
+            if (staticTokens.Contains<GenericToken>(GenericToken.Identifier) ||
+                staticTokens.Contains<GenericToken>(GenericToken.KeyWord))
             {
                 InitializeIdentifier(config);
             }
 
             // numeric
-            if (staticTokens.Contains<GenericToken>(GenericToken.Int) || staticTokens.Contains<GenericToken>(GenericToken.Double))
+            if (staticTokens.Contains<GenericToken>(GenericToken.Int) ||
+                staticTokens.Contains<GenericToken>(GenericToken.Double))
             {
                 FSMBuilder = FSMBuilder.GoTo(start)
                     .RangeTransition('0', '9')
@@ -393,7 +406,8 @@ public void InitializeIdentifier(Config config)
                         }
                         else
                         {
-                            FSMBuilder.RangeTransition(pattern[0], pattern[1]).Mark(in_identifier).End(GenericToken.Identifier);
+                            FSMBuilder.RangeTransition(pattern[0], pattern[1]).Mark(in_identifier)
+                                .End(GenericToken.Identifier);
                             marked = true;
                         }
                     }
@@ -429,7 +443,7 @@ public void InitializeIdentifier(Config config)
                         .GoTo(in_identifier)
                         .RangeTransitionTo('0', '9', in_identifier);
                 }
-            
+
                 if (config.IdType == IdentifierType.AlphaNumericDash)
                 {
                     FSMBuilder
@@ -448,37 +462,37 @@ public void AddLexeme(GenericToken generic, IN token)
                 switch (match.Result.TokenID)
                 {
                     case GenericToken.Identifier:
+                    {
+                        if (derivedTokens.ContainsKey(GenericToken.Identifier))
                         {
-                            if (derivedTokens.ContainsKey(GenericToken.Identifier))
-                            {
-                                var possibleTokens = derivedTokens[GenericToken.Identifier];
-                                if (possibleTokens.ContainsKey(match.Result.Value))
-                                    match.Properties[DerivedToken] = possibleTokens[match.Result.Value].tokenId;
-                                else
-                                    match.Properties[DerivedToken] = identifierDerivedToken;
-                            }
+                            var possibleTokens = derivedTokens[GenericToken.Identifier];
+                            if (possibleTokens.ContainsKey(match.Result.Value))
+                                match.Properties[DerivedToken] = possibleTokens[match.Result.Value].tokenId;
                             else
-                            {
                                 match.Properties[DerivedToken] = identifierDerivedToken;
-                            }
-
-                            break;
                         }
-                    case GenericToken.Int:
+                        else
                         {
-                            match.Properties[DerivedToken] = intDerivedToken;
-                            break;
+                            match.Properties[DerivedToken] = identifierDerivedToken;
                         }
+
+                        break;
+                    }
+                    case GenericToken.Int:
+                    {
+                        match.Properties[DerivedToken] = intDerivedToken;
+                        break;
+                    }
                     case GenericToken.Double:
-                        {
-                            match.Properties[DerivedToken] = doubleDerivedToken;
-                            break;
-                        }
+                    {
+                        match.Properties[DerivedToken] = doubleDerivedToken;
+                        break;
+                    }
                     default:
-                        {
-                            match.Properties[DerivedToken] = token;
-                            break;
-                        }
+                    {
+                        match.Properties[DerivedToken] = token;
+                        break;
+                    }
                 }
 
                 return match;
@@ -487,23 +501,24 @@ public void AddLexeme(GenericToken generic, IN token)
             switch (generic)
             {
                 case GenericToken.Int:
-                    {
-                        intDerivedToken = token;
-                        FSMBuilder.GoTo(in_int);
-                        FSMBuilder.CallBack(callback);
-                        break;
-                    }
+                {
+                    intDerivedToken = token;
+                    FSMBuilder.GoTo(in_int);
+                    FSMBuilder.CallBack(callback);
+                    break;
+                }
                 case GenericToken.Identifier:
-                    {
-                        identifierDerivedToken = token;
-                        FSMBuilder.GoTo(in_identifier);
-                        FSMBuilder.CallBack(callback);
-                        break;
-                    }
+                {
+                    identifierDerivedToken = token;
+                    FSMBuilder.GoTo(in_identifier);
+                    FSMBuilder.CallBack(callback);
+                    break;
+                }
             }
         }
 
-        public void AddLexeme(GenericToken genericToken,BuildResult<ILexer<IN>> result, IN token, bool isPop, bool isPush, string mode, string specialValue)
+        public void AddLexeme(GenericToken genericToken, BuildResult<ILexer<IN>> result, IN token, bool isPop,
+            bool isPush, string mode, string specialValue)
         {
             if (genericToken == GenericToken.SugarToken)
             {
@@ -514,7 +529,8 @@ public void AddLexeme(GenericToken genericToken,BuildResult<ILexer<IN>> result,
             {
                 if (genericToken == GenericToken.Identifier)
                 {
-                    tokensForGeneric = new Dictionary<string, (IN tokenId, bool isPop, bool isPush, string mode)>(KeyWordComparer);
+                    tokensForGeneric =
+                        new Dictionary<string, (IN tokenId, bool isPop, bool isPush, string mode)>(KeyWordComparer);
                 }
                 else
                 {
@@ -524,7 +540,7 @@ public void AddLexeme(GenericToken genericToken,BuildResult<ILexer<IN>> result,
                 derivedTokens[genericToken] = tokensForGeneric;
             }
 
-            tokensForGeneric[specialValue] = (token,isPop,isPush,mode);
+            tokensForGeneric[specialValue] = (token, isPop, isPush, mode);
         }
 
         public void AddDouble(IN token, string separator, BuildResult<ILexer<IN>> result)
@@ -532,7 +548,7 @@ public void AddDouble(IN token, string separator, BuildResult<ILexer<IN>> result
             NodeCallback<GenericToken> callback = match =>
             {
                 IN derivedToken = token;
-               
+
 
                 match.Properties[DerivedToken] = derivedToken;
 
@@ -550,19 +566,20 @@ public void AddDouble(IN token, string separator, BuildResult<ILexer<IN>> result
                 .RangeTransitionTo('0', '9', in_double)
                 .End(GenericToken.Double)
                 .CallBack(callback);
-            
+
             FSMBuilder.Fsm.DecimalSeparator = separatorChar;
-            
         }
 
-        public void AddKeyWord(IN token, string keyword, bool isPop, bool isPush, string mode, BuildResult<ILexer<IN>> result )
+        public void AddKeyWord(IN token, string keyword, bool isPop, bool isPush, string mode,
+            BuildResult<ILexer<IN>> result)
         {
             NodeCallback<GenericToken> callback = match =>
             {
                 IN derivedToken = default;
                 if (derivedTokens.TryGetValue(GenericToken.Identifier, out var derived))
                 {
-                    if (derived.TryGetValue(match.Result.Value, out (IN tokenId, bool isPop, bool isPush, string mode) derived2))
+                    if (derived.TryGetValue(match.Result.Value,
+                            out (IN tokenId, bool isPop, bool isPush, string mode) derived2))
                     {
                         derivedToken = derived2.tokenId;
                         match.IsPush = derived2.isPush;
@@ -584,7 +601,7 @@ public void AddKeyWord(IN token, string keyword, bool isPop, bool isPush, string
                 return match;
             };
 
-            AddLexeme(GenericToken.Identifier, result, token,isPop,isPush,mode, keyword);
+            AddLexeme(GenericToken.Identifier, result, token, isPop, isPush, mode, keyword);
             var node = FSMBuilder.GetNode(in_identifier);
             if (!FSMBuilder.Fsm.HasCallback(node.Id))
             {
@@ -593,7 +610,8 @@ public void AddKeyWord(IN token, string keyword, bool isPop, bool isPush, string
         }
 
 
-        public ReadOnlyMemory<char> diffCharEscaper(char escapeStringDelimiterChar, char stringDelimiterChar, ReadOnlyMemory<char> stringValue)
+        public ReadOnlyMemory<char> diffCharEscaper(char escapeStringDelimiterChar, char stringDelimiterChar,
+            ReadOnlyMemory<char> stringValue)
         {
             var value = stringValue;
             var i = 1;
@@ -620,15 +638,19 @@ public ReadOnlyMemory<char> diffCharEscaper(char escapeStringDelimiterChar, char
                         {
                             r += escapeStringDelimiterChar;
                         }
+
                         escaping = false;
                     }
+
                     if (substitutionHappened)
                     {
                         r += current;
                     }
                 }
+
                 i++;
             }
+
             if (substitutionHappened)
             {
                 r += value.At<char>(value.Length - 1);
@@ -638,7 +660,8 @@ public ReadOnlyMemory<char> diffCharEscaper(char escapeStringDelimiterChar, char
             return value;
         }
 
-        public ReadOnlyMemory<char> sameCharEscaper(char escapeStringDelimiterChar, char stringDelimiterChar, ReadOnlyMemory<char> stringValue)
+        public ReadOnlyMemory<char> sameCharEscaper(char escapeStringDelimiterChar, char stringDelimiterChar,
+            ReadOnlyMemory<char> stringValue)
         {
             var value = stringValue;
             int i = 1;
@@ -669,8 +692,10 @@ public ReadOnlyMemory<char> sameCharEscaper(char escapeStringDelimiterChar, char
                         r += current;
                     }
                 }
+
                 i++;
             }
+
             if (substitutionHappened)
             {
                 r += value.At<char>(value.Length - 1);
@@ -680,25 +705,29 @@ public ReadOnlyMemory<char> sameCharEscaper(char escapeStringDelimiterChar, char
             return value;
         }
 
-        public void AddStringLexem(IN token,  BuildResult<ILexer<IN>> result , string stringDelimiter,
+        public void AddStringLexem(IN token, BuildResult<ILexer<IN>> result, string stringDelimiter,
             string escapeDelimiterChar = "\\")
         {
             if (string.IsNullOrEmpty(stringDelimiter) || stringDelimiter.Length > 1)
                 result.AddError(new LexerInitializationError(ErrorLevel.FATAL,
-                    I18N.Instance.GetText(I18n,I18NMessage.StringDelimiterMustBe1Char,stringDelimiter,token.ToString()),
+                    I18N.Instance.GetText(I18n, I18NMessage.StringDelimiterMustBe1Char, stringDelimiter,
+                        token.ToString()),
                     ErrorCodes.LEXER_STRING_DELIMITER_MUST_BE_1_CHAR));
             if (stringDelimiter.Length == 1 && char.IsLetterOrDigit(stringDelimiter[0]))
                 result.AddError(new InitializationError(ErrorLevel.FATAL,
-                    I18N.Instance.GetText(I18n,I18NMessage.StringDelimiterCannotBeLetterOrDigit,stringDelimiter,token.ToString()),
+                    I18N.Instance.GetText(I18n, I18NMessage.StringDelimiterCannotBeLetterOrDigit, stringDelimiter,
+                        token.ToString()),
                     ErrorCodes.LEXER_STRING_DELIMITER_CANNOT_BE_LETTER_OR_DIGIT));
 
             if (string.IsNullOrEmpty(escapeDelimiterChar) || escapeDelimiterChar.Length > 1)
                 result.AddError(new InitializationError(ErrorLevel.FATAL,
-                    I18N.Instance.GetText(I18n,I18NMessage.StringEscapeCharMustBe1Char,escapeDelimiterChar,token.ToString()),
+                    I18N.Instance.GetText(I18n, I18NMessage.StringEscapeCharMustBe1Char, escapeDelimiterChar,
+                        token.ToString()),
                     ErrorCodes.LEXER_STRING_ESCAPE_CHAR_MUST_BE_1_CHAR));
             if (escapeDelimiterChar.Length == 1 && char.IsLetterOrDigit(escapeDelimiterChar[0]))
                 result.AddError(new InitializationError(ErrorLevel.FATAL,
-                    I18N.Instance.GetText(I18n,I18NMessage.StringEscapeCharCannotBeLetterOrDigit,escapeDelimiterChar,token.ToString()),
+                    I18N.Instance.GetText(I18n, I18NMessage.StringEscapeCharCannotBeLetterOrDigit, escapeDelimiterChar,
+                        token.ToString()),
                     ErrorCodes.LEXER_STRING_ESCAPE_CHAR_CANNOT_BE_LETTER_OR_DIGIT));
 
             StringDelimiterChar = (char)0;
@@ -706,7 +735,7 @@ public void AddStringLexem(IN token,  BuildResult<ILexer<IN>> result , string st
 
             EscapeStringDelimiterChar = (char)0;
             var escapeStringDelimiterChar = (char)0;
-            
+
             if (stringDelimiter.Length == 1)
             {
                 StringCounter++;
@@ -730,11 +759,13 @@ public void AddStringLexem(IN token,  BuildResult<ILexer<IN>> result , string st
                 match.IsString = true;
                 if (stringDelimiterChar != escapeStringDelimiterChar)
                 {
-                    match.Result.SpanValue = diffCharEscaper(escapeStringDelimiterChar,stringDelimiterChar, match.Result.SpanValue);
+                    match.Result.SpanValue = diffCharEscaper(escapeStringDelimiterChar, stringDelimiterChar,
+                        match.Result.SpanValue);
                 }
                 else
-                {                   
-                    match.Result.SpanValue = sameCharEscaper(escapeStringDelimiterChar,stringDelimiterChar, match.Result.SpanValue);
+                {
+                    match.Result.SpanValue = sameCharEscaper(escapeStringDelimiterChar, stringDelimiterChar,
+                        match.Result.SpanValue);
                 }
 
                 return match;
@@ -742,7 +773,6 @@ public void AddStringLexem(IN token,  BuildResult<ILexer<IN>> result , string st
 
             if (stringDelimiterChar != escapeStringDelimiterChar)
             {
-
                 FSMBuilder.GoTo(start);
                 FSMBuilder.Transition(stringDelimiterChar)
                     .Mark(in_string + StringCounter)
@@ -765,39 +795,40 @@ public void AddStringLexem(IN token,  BuildResult<ILexer<IN>> result , string st
                 var escaped = "escaped_same";
 
                 FSMBuilder.GoTo(start)
-                    
                     .Transition(stringDelimiterChar)
                     .Mark(in_string + StringCounter)
-                    
                     .ExceptTransitionTo(exceptDelimiter, in_string + StringCounter)
-                    
                     .Transition(stringDelimiterChar)
                     .Mark(escaped + StringCounter)
                     .End(GenericToken.String)
                     .CallBack(callback)
-                    .TransitionTo(stringDelimiterChar,in_string + StringCounter)
+                    .TransitionTo(stringDelimiterChar, in_string + StringCounter)
                     .Transition(stringDelimiterChar);
             }
         }
-        
-        public void AddCharLexem(IN token, BuildResult<ILexer<IN>> result ,string charDelimiter, string escapeDelimiterChar = "\\")
+
+        public void AddCharLexem(IN token, BuildResult<ILexer<IN>> result, string charDelimiter,
+            string escapeDelimiterChar = "\\")
         {
             if (string.IsNullOrEmpty(charDelimiter) || charDelimiter.Length > 1)
-               result.AddError(new InitializationError(ErrorLevel.FATAL,
-                   I18N.Instance.GetText(I18n,I18NMessage.CharDelimiterMustBe1Char,charDelimiter,token.ToString()),
+                result.AddError(new InitializationError(ErrorLevel.FATAL,
+                    I18N.Instance.GetText(I18n, I18NMessage.CharDelimiterMustBe1Char, charDelimiter, token.ToString()),
                     ErrorCodes.LEXER_CHAR_DELIMITER_MUST_BE_1_CHAR));
             if (charDelimiter.Length == 1 && char.IsLetterOrDigit(charDelimiter[0]))
                 result.AddError(new InitializationError(ErrorLevel.FATAL,
-                    I18N.Instance.GetText(I18n, I18NMessage.CharDelimiterCannotBeLetter,charDelimiter,token.ToString()), 
+                    I18N.Instance.GetText(I18n, I18NMessage.CharDelimiterCannotBeLetter, charDelimiter,
+                        token.ToString()),
                     ErrorCodes.LEXER_CHAR_DELIMITER_CANNOT_BE_LETTER));
 
             if (string.IsNullOrEmpty(escapeDelimiterChar) || escapeDelimiterChar.Length > 1)
                 result.AddError(new InitializationError(ErrorLevel.FATAL,
-                    I18N.Instance.GetText(I18n,I18NMessage.CharEscapeCharMustBe1Char,escapeDelimiterChar,token.ToString()),
+                    I18N.Instance.GetText(I18n, I18NMessage.CharEscapeCharMustBe1Char, escapeDelimiterChar,
+                        token.ToString()),
                     ErrorCodes.LEXER_CHAR_ESCAPE_CHAR_MUST_BE_1_CHAR));
             if (escapeDelimiterChar.Length == 1 && char.IsLetterOrDigit(escapeDelimiterChar[0]))
                 result.AddError(new InitializationError(ErrorLevel.FATAL,
-                    I18N.Instance.GetText(I18n,I18NMessage.CharEscapeCharCannotBeLetterOrDigit,escapeDelimiterChar,token.ToString()),
+                    I18N.Instance.GetText(I18n, I18NMessage.CharEscapeCharCannotBeLetterOrDigit, escapeDelimiterChar,
+                        token.ToString()),
                     ErrorCodes.LEXER_CHAR_ESCAPE_CHAR_CANNOT_BE_LETTER_OR_DIGIT));
 
             CharCounter++;
@@ -818,38 +849,39 @@ public void AddCharLexem(IN token, BuildResult<ILexer<IN>> result ,string charDe
 
             FSMBuilder.GoTo(start);
             FSMBuilder.Transition(charDelimiterChar)
-                .Mark(start_char+"_"+CharCounter)
+                .Mark(start_char + "_" + CharCounter)
                 .ExceptTransition(new[] { charDelimiterChar, escapeChar })
-                .Mark(in_char+"_"+CharCounter)
+                .Mark(in_char + "_" + CharCounter)
                 .Transition(charDelimiterChar)
-                .Mark(end_char+"_"+CharCounter)
+                .Mark(end_char + "_" + CharCounter)
                 .End(GenericToken.Char)
                 .CallBack(callback)
-                .GoTo(start_char+"_"+CharCounter)
+                .GoTo(start_char + "_" + CharCounter)
                 .Transition(escapeChar)
-                .Mark(escapeChar_char+"_"+CharCounter)
+                .Mark(escapeChar_char + "_" + CharCounter)
                 .ExceptTransitionTo(new[] { 'u' }, in_char + "_" + CharCounter)
                 .CallBack(callback);
             FSMBuilder.Fsm.StringDelimiter = charDelimiterChar;
-            
+
             // unicode transitions ?
             FSMBuilder = FSMBuilder.GoTo(escapeChar_char + "_" + CharCounter)
-            .Transition('u')
-            .Mark(unicode_char+"_"+CharCounter)
-            .RepetitionTransitionTo(in_char + "_" + CharCounter,4,"[0-9,a-z,A-Z]");
-
+                .Transition('u')
+                .Mark(unicode_char + "_" + CharCounter)
+                .RepetitionTransitionTo(in_char + "_" + CharCounter, 4, "[0-9,a-z,A-Z]");
         }
 
-        public void AddSugarLexem(IN token, BuildResult<ILexer<IN>> buildResult, string specialValue, bool isLineEnding = false, int? channel = null)
+        public void AddSugarLexem(IN token, BuildResult<ILexer<IN>> buildResult, string specialValue,
+            bool isLineEnding = false, int? channel = null)
         {
             if (char.IsLetter(specialValue[0]))
             {
                 buildResult.AddError(new InitializationError(ErrorLevel.FATAL,
-                    I18N.Instance.GetText(I18n,I18NMessage.SugarTokenCannotStartWithLetter,specialValue,token.ToString()),
+                    I18N.Instance.GetText(I18n, I18NMessage.SugarTokenCannotStartWithLetter, specialValue,
+                        token.ToString()),
                     ErrorCodes.LEXER_SUGAR_TOKEN_CANNOT_START_WITH_LETTER));
                 return;
             }
-                
+
             NodeCallback<GenericToken> callback = match =>
             {
                 match.Properties[DerivedToken] = token;
@@ -859,22 +891,18 @@ public void AddSugarLexem(IN token, BuildResult<ILexer<IN>> buildResult, string
 
             Func<int, TransitionPrecondition> precond = (int i) =>
             {
-                return (ReadOnlyMemory<char> value) =>
-                {
-                    return value.Length == i+1;
-                };
+                return (ReadOnlyMemory<char> value) => { return value.Length == i + 1; };
             };
-            
+
             FSMBuilder.GoTo(start);
-            for (var i = 0; i < specialValue.Length; i++) FSMBuilder.SafeTransition(specialValue[i],precond(i));
+            for (var i = 0; i < specialValue.Length; i++) FSMBuilder.SafeTransition(specialValue[i], precond(i));
             FSMBuilder.End(GenericToken.SugarToken, isLineEnding)
                 .CallBack(callback);
         }
-        
-        public void AddUpTo(IN token, BuildResult<ILexer<IN>> buildResult, string[] exceptions, bool isLineEnding = false)
+
+        public void AddUpTo(IN token, BuildResult<ILexer<IN>> buildResult, string[] exceptions,
+            bool isLineEnding = false)
         {
-            
-                
             NodeCallback<GenericToken> callback = match =>
             {
                 match.Properties[DerivedToken] = token;
@@ -894,16 +922,16 @@ public void AddUpTo(IN token, BuildResult<ILexer<IN>> buildResult, string[] exce
 
                 return $"{in_up_to}_{exception}_{exceptionIndex}_{upToCounter}";
             };
-            
+
             FSMBuilder.ExceptTransition(upToChars0)
-                .Mark(GetEndLabel(-1,-1))
+                .Mark(GetEndLabel(-1, -1))
                 .End(GenericToken.UpTo)
                 .CallBack(callback);
-            FSMBuilder.ExceptTransitionTo(upToChars0,GetEndLabel(-1,-1));
+            FSMBuilder.ExceptTransitionTo(upToChars0, GetEndLabel(-1, -1));
             for (int i = 0; i < exceptions.Length; i++)
             {
                 string exception = exceptions[i];
-                for (int j = 0; j < exception.Length-1; j ++)
+                for (int j = 0; j < exception.Length - 1; j++)
                 {
                     char exceptionChar = exception[j];
                     var end = GetEndLabel(i, j);
@@ -915,11 +943,11 @@ public void AddUpTo(IN token, BuildResult<ILexer<IN>> buildResult, string[] exce
                         FSMBuilder.Mark(end);
                         // FSMBuilder.End(GenericToken.AllExcept)
                         //     .CallBack(callback);
-                            
+
                         startNode = start;
                     }
 
-                    
+
                     FSMBuilder.GoTo(startNode);
 
                     if (j < exception.Length - 1)
@@ -932,7 +960,7 @@ public void AddUpTo(IN token, BuildResult<ILexer<IN>> buildResult, string[] exce
                         {
                             if (transition.Check is TransitionAnyExcept except)
                             {
-                                except.AddException(exception[j+1]);
+                                except.AddException(exception[j + 1]);
                             }
                         }
                         else
@@ -942,13 +970,14 @@ public void AddUpTo(IN token, BuildResult<ILexer<IN>> buildResult, string[] exce
                     }
                 }
             }
-            
+
             upToCounter++;
         }
 
-        public LexerPosition ConsumeComment(Token<GenericToken> comment, ReadOnlyMemory<char> source, LexerPosition lexerPosition)
+        public LexerPosition ConsumeComment(Token<GenericToken> comment, ReadOnlyMemory<char> source,
+            LexerPosition lexerPosition)
         {
-           ReadOnlyMemory<char> commentValue;
+            ReadOnlyMemory<char> commentValue;
 
             if (comment.IsSingleLineComment)
             {
@@ -998,7 +1027,7 @@ public Token<IN> Transcode(FSMMatch<GenericToken> match)
             tok.Position = inTok.Position;
             tok.Discarded = inTok.Discarded;
             tok.StringDelimiter = match.StringDelimiterChar;
-            tok.TokenID = match.Properties.ContainsKey(DerivedToken) ? (IN) match.Properties[DerivedToken] : default(IN);
+            tok.TokenID = match.Properties.ContainsKey(DerivedToken) ? (IN)match.Properties[DerivedToken] : default(IN);
             tok.IsLineEnding = match.IsLineEnding;
             tok.IsEOS = match.IsEOS;
             tok.IsIndent = match.IsIndent;
@@ -1015,11 +1044,10 @@ public override string ToString()
         {
             return TempLexerFsm.ToString();
         }
-        
+
         public string ToGraphViz()
         {
             return TempLexerFsm.ToGraphViz();
         }
-        
     }
 }
\ No newline at end of file
diff --git a/sly/lexer/LexerBuilder.cs b/sly/lexer/LexerBuilder.cs
index 47176dfd..c279e872 100644
--- a/sly/lexer/LexerBuilder.cs
+++ b/sly/lexer/LexerBuilder.cs
@@ -8,22 +8,21 @@
 
 namespace sly.lexer
 {
-
     public static class DicExt
     {
-        public static void AddToKey<K, K2, V>(this IDictionary<K, IDictionary<K2,V>> dic, K key, K2 k2, V value)
+        public static void AddToKey<K, K2, V>(this IDictionary<K, IDictionary<K2, V>> dic, K key, K2 k2, V value)
         {
-            IDictionary<K2,V> values ;
+            IDictionary<K2, V> values;
             if (!dic.TryGetValue(key, out values))
             {
                 values = new Dictionary<K2, V>();
             }
+
             values[k2] = value;
             dic[key] = values;
         }
-        
     }
-    
+
     public static class EnumHelper
     {
         /// <summary>
@@ -37,14 +36,15 @@ public static T[] GetAttributesOfType<T>(this Enum enumVal) where T : Attribute
         {
             var type = enumVal.GetType();
             var memInfo = type.GetMember(enumVal.ToString());
-            var attributes = (T[]) memInfo[0].GetCustomAttributes(typeof(T), false);
+            var attributes = (T[])memInfo[0].GetCustomAttributes(typeof(T), false);
             return attributes;
         }
     }
 
     public static class LexerBuilder
     {
-        public static Dictionary<IN, List<LexemeAttribute>> GetLexemes<IN>(BuildResult<ILexer<IN>> result, string lang) where IN: struct
+        public static Dictionary<IN, List<LexemeAttribute>> GetLexemes<IN>(BuildResult<ILexer<IN>> result, string lang)
+            where IN : struct
         {
             var attributes = new Dictionary<IN, List<LexemeAttribute>>();
 
@@ -52,27 +52,24 @@ public static Dictionary<IN, List<LexemeAttribute>> GetLexemes<IN>(BuildResult<I
             var grouped = values.Cast<IN>().GroupBy<IN, IN>(x => x).ToList<IGrouping<IN, IN>>();
             foreach (var group in grouped)
             {
-                
                 var v = group.Key;
                 if (group.Count<IN>() > 1)
                 {
-                 
                     Enum enumValue = Enum.Parse(typeof(IN), v.ToString()) as Enum;
                     int intValue = Convert.ToInt32(enumValue); // x is the integer value of enum
-                    
+
                     result.AddError(new LexerInitializationError(ErrorLevel.FATAL,
-                        I18N.Instance.GetText(lang,I18NMessage.SameValueUsedManyTime,intValue.ToString(),group.Count<IN>().ToString(),typeof(IN).FullName),
+                        I18N.Instance.GetText(lang, I18NMessage.SameValueUsedManyTime, intValue.ToString(),
+                            group.Count<IN>().ToString(), typeof(IN).FullName),
                         ErrorCodes.LEXER_SAME_VALUE_USED_MANY_TIME));
-                    
                 }
             }
 
             if (!result.IsError)
             {
-
                 foreach (Enum value in values)
                 {
-                    var tokenID = (IN) (object) value;
+                    var tokenID = (IN)(object)value;
                     var enumAttributes = value.GetAttributesOfType<LexemeAttribute>();
                     var singleCommentAttributes = value.GetAttributesOfType<SingleLineCommentAttribute>();
                     var multiCommentAttributes = value.GetAttributesOfType<MultiLineCommentAttribute>();
@@ -81,7 +78,8 @@ public static Dictionary<IN, List<LexemeAttribute>> GetLexemes<IN>(BuildResult<I
                         multiCommentAttributes.Length == 0 && commentAttributes.Length == 0)
                     {
                         result?.AddError(new LexerInitializationError(ErrorLevel.WARN,
-                            $"token {tokenID} in lexer definition {typeof(IN).FullName} does not have Lexeme",ErrorCodes.NOT_AN_ERROR));
+                            $"token {tokenID} in lexer definition {typeof(IN).FullName} does not have Lexeme",
+                            ErrorCodes.NOT_AN_ERROR));
                     }
                     else
                     {
@@ -93,31 +91,35 @@ public static Dictionary<IN, List<LexemeAttribute>> GetLexemes<IN>(BuildResult<I
             return attributes;
         }
 
-        public static BuildResult<ILexer<IN>> BuildLexer<IN>(BuildExtension<IN> extensionBuilder = null, LexerPostProcess<IN> lexerPostProcess = null) where IN : struct
+        public static BuildResult<ILexer<IN>> BuildLexer<IN>(
+            Action<IN, LexemeAttribute, GenericLexer<IN>> extensionBuilder = null,
+            LexerPostProcess<IN> lexerPostProcess = null) where IN : struct
         {
-            return BuildLexer<IN>(new BuildResult < ILexer < IN >>() , extensionBuilder, lexerPostProcess:lexerPostProcess);
+            return BuildLexer<IN>(new BuildResult<ILexer<IN>>(), extensionBuilder, lexerPostProcess: lexerPostProcess);
         }
 
         public static BuildResult<ILexer<IN>> BuildLexer<IN>(BuildResult<ILexer<IN>> result,
-            BuildExtension<IN> extensionBuilder = null,
-            string lang = null, LexerPostProcess<IN> lexerPostProcess = null, IList<string> explicitTokens = null) where IN : struct
+            Action<IN, LexemeAttribute, GenericLexer<IN>> extensionBuilder = null,
+            string lang = null, LexerPostProcess<IN> lexerPostProcess = null, IList<string> explicitTokens = null)
+            where IN : struct
         {
-            var attributes = GetLexemes<IN>(result,lang);
+            var attributes = GetLexemes<IN>(result, lang);
             if (!result.IsError)
             {
-                result = Build<IN>(attributes, result, extensionBuilder,lang, explicitTokens);
+                result = Build<IN>(attributes, result, extensionBuilder, lang, explicitTokens);
                 if (!result.IsError)
                 {
                     result.Result.LexerPostProcess = lexerPostProcess;
                 }
             }
-            
+
             return result;
         }
 
 
         private static BuildResult<ILexer<IN>> Build<IN>(Dictionary<IN, List<LexemeAttribute>> attributes,
-            BuildResult<ILexer<IN>> result, BuildExtension<IN> extensionBuilder = null, string lang = null,
+            BuildResult<ILexer<IN>> result, Action<IN, LexemeAttribute, GenericLexer<IN>> extensionBuilder = null,
+            string lang = null,
             IList<string> explicitTokens = null) where IN : struct
         {
             var hasRegexLexemes = IsRegexLexer<IN>(attributes);
@@ -126,7 +128,7 @@ private static BuildResult<ILexer<IN>> Build<IN>(Dictionary<IN, List<LexemeAttri
             if (hasGenericLexemes && hasRegexLexemes)
             {
                 result.AddError(new LexerInitializationError(ErrorLevel.ERROR,
-                    I18N.Instance.GetText(lang,I18NMessage.CannotMixGenericAndRegex),
+                    I18N.Instance.GetText(lang, I18NMessage.CannotMixGenericAndRegex),
                     ErrorCodes.LEXER_CANNOT_MIX_GENERIC_AND_REGEX));
             }
             else
@@ -136,7 +138,7 @@ private static BuildResult<ILexer<IN>> Build<IN>(Dictionary<IN, List<LexemeAttri
                     if (explicitTokens != null && explicitTokens.Any())
                     {
                         result.AddError(new LexerInitializationError(ErrorLevel.ERROR,
-                            I18N.Instance.GetText(lang,I18NMessage.CannotUseExplicitTokensWithRegexLexer),
+                            I18N.Instance.GetText(lang, I18NMessage.CannotUseExplicitTokensWithRegexLexer),
                             ErrorCodes.LEXER_CANNOT_USE_IMPLICIT_TOKENS_WITH_REGEX_LEXER));
                     }
                     else
@@ -183,7 +185,8 @@ private static BuildResult<ILexer<IN>> BuildRegexLexer<IN>(Dictionary<IN, List<L
                         foreach (var lexeme in lexemes)
                         {
                             var channel = lexeme.Channel.HasValue ? lexeme.Channel.Value : 0;
-                            lexer.AddDefinition(new TokenDefinition<IN>(tokenID, lexeme.Pattern, channel,lexeme.IsSkippable,
+                            lexer.AddDefinition(new TokenDefinition<IN>(tokenID, lexeme.Pattern, channel,
+                                lexeme.IsSkippable,
                                 lexeme.IsLineEnding));
                         }
                     }
@@ -196,7 +199,8 @@ private static BuildResult<ILexer<IN>> BuildRegexLexer<IN>(Dictionary<IN, List<L
                 else if (!tokenID.Equals(default(IN)))
                 {
                     result.AddError(new LexerInitializationError(ErrorLevel.WARN,
-                        $"token {tokenID} in lexer definition {typeof(IN).FullName} does not have Lexeme",ErrorCodes.NOT_AN_ERROR));
+                        $"token {tokenID} in lexer definition {typeof(IN).FullName} does not have Lexeme",
+                        ErrorCodes.NOT_AN_ERROR));
                 }
             }
 
@@ -207,7 +211,8 @@ private static BuildResult<ILexer<IN>> BuildRegexLexer<IN>(Dictionary<IN, List<L
         private static Dictionary<string, IDictionary<IN, List<LexemeAttribute>>> GetSubLexers<IN>(
             IDictionary<IN, List<LexemeAttribute>> attributes) where IN : struct
         {
-            Dictionary<string, IDictionary<IN, List<LexemeAttribute>>> subLexers = new Dictionary<string, IDictionary<IN, List<LexemeAttribute>>>();
+            Dictionary<string, IDictionary<IN, List<LexemeAttribute>>> subLexers =
+                new Dictionary<string, IDictionary<IN, List<LexemeAttribute>>>();
             foreach (var attribute in attributes)
             {
                 if (attribute.Key is Enum enumValue)
@@ -222,16 +227,16 @@ private static Dictionary<string, IDictionary<IN, List<LexemeAttribute>>> GetSub
                             {
                                 foreach (var mode in modes)
                                 {
-                                    subLexers.AddToKey(mode,attribute.Key,attribute.Value);        
+                                    subLexers.AddToKey(mode, attribute.Key, attribute.Value);
                                 }
                             }
                         }
                     }
                     else
                     {
-                        subLexers.AddToKey(ModeAttribute.DefaultLexerMode,attribute.Key,attribute.Value);
+                        subLexers.AddToKey(ModeAttribute.DefaultLexerMode, attribute.Key, attribute.Value);
                     }
-                    
+
                     var push = enumValue.GetAttributesOfType<PushAttribute>();
                     if (push != null && push.Length >= 1)
                     {
@@ -239,15 +244,13 @@ private static Dictionary<string, IDictionary<IN, List<LexemeAttribute>>> GetSub
                         {
                             x.IsPush = true;
                             x.Pushtarget = push.First().TargetMode;
-                        }); 
+                        });
                     }
+
                     var pop = enumValue.GetAttributesOfType<PopAttribute>();
                     if (pop != null && pop.Length >= 1)
                     {
-                        attribute.Value.ForEach(x =>
-                        {
-                            x.IsPop = true;
-                        }); 
+                        attribute.Value.ForEach(x => { x.IsPop = true; });
                     }
                 }
             }
@@ -261,12 +264,10 @@ private static Dictionary<string, IDictionary<IN, List<LexemeAttribute>>> GetSub
             return subLexers;
         }
 
-        private static (GenericLexer<IN>.Config, GenericToken[]) GetConfigAndGenericTokens<IN>(IDictionary<IN, List<LexemeAttribute>> attributes)
+        private static (GenericLexer<IN>.Config, GenericToken[]) GetConfigAndGenericTokens<IN>(
+            IDictionary<IN, List<LexemeAttribute>> attributes)
             where IN : struct
         {
-
-            
-            
             var config = new GenericLexer<IN>.Config();
             var lexerAttribute = typeof(IN).GetCustomAttribute<LexerAttribute>();
             if (lexerAttribute != null)
@@ -278,6 +279,7 @@ private static (GenericLexer<IN>.Config, GenericToken[]) GetConfigAndGenericToke
                 config.Indentation = lexerAttribute.Indentation;
                 config.IndentationAware = lexerAttribute.IndentationAWare;
             }
+
             var modesAttribute = typeof(IN).GetCustomAttribute<ModesAttribute>();
             if (modesAttribute != null)
             {
@@ -298,10 +300,10 @@ private static (GenericLexer<IN>.Config, GenericToken[]) GetConfigAndGenericToke
                     }
                 }
             }
-            
+
             return (config, statics.Distinct<GenericToken>().ToArray<GenericToken>());
         }
-        
+
         private static IEnumerable<char[]> ParseIdentifierPattern(string pattern)
         {
             var index = 0;
@@ -317,6 +319,7 @@ private static IEnumerable<char[]> ParseIdentifierPattern(string pattern)
                     {
                         yield return new[] { pattern[index + 2], pattern[index] };
                     }
+
                     index += 3;
                 }
                 else
@@ -326,7 +329,8 @@ private static IEnumerable<char[]> ParseIdentifierPattern(string pattern)
             }
         }
 
-        private static NodeCallback<GenericToken> GetCallbackSingle<IN>(IN token, bool doNotIgnore, int channel) where IN : struct
+        private static NodeCallback<GenericToken> GetCallbackSingle<IN>(IN token, bool doNotIgnore, int channel)
+            where IN : struct
         {
             NodeCallback<GenericToken> callback = match =>
             {
@@ -340,7 +344,8 @@ private static NodeCallback<GenericToken> GetCallbackSingle<IN>(IN token, bool d
             return callback;
         }
 
-        private static NodeCallback<GenericToken> GetCallbackMulti<IN>(IN token, bool doNotIgnore, int channel) where IN : struct
+        private static NodeCallback<GenericToken> GetCallbackMulti<IN>(IN token, bool doNotIgnore, int channel)
+            where IN : struct
         {
             NodeCallback<GenericToken> callbackMulti = match =>
             {
@@ -353,11 +358,11 @@ private static NodeCallback<GenericToken> GetCallbackMulti<IN>(IN token, bool do
             };
             return callbackMulti;
         }
-        
-        
-        
-        private static BuildResult<ILexer<IN>> BuildGenericSubLexers<IN>(Dictionary<IN, List<LexemeAttribute>> attributes,
-            BuildExtension<IN> extensionBuilder, BuildResult<ILexer<IN>> result, string lang,
+
+
+        private static BuildResult<ILexer<IN>> BuildGenericSubLexers<IN>(
+            Dictionary<IN, List<LexemeAttribute>> attributes,
+            Action<IN, LexemeAttribute, GenericLexer<IN>> extensionBuilder, BuildResult<ILexer<IN>> result, string lang,
             IList<string> explicitTokens = null) where IN : struct
         {
             GenericLexer<IN> genLexer = null;
@@ -372,27 +377,24 @@ private static BuildResult<ILexer<IN>> BuildGenericSubLexers<IN>(Dictionary<IN,
                 }
 
                 currentGenericLexer.FSMBuilder.Fsm.Mode = subLexer.Key;
-                
-                genLexer.SubLexersFsm[subLexer.Key] = currentGenericLexer.FSMBuilder.Fsm;
 
+                genLexer.SubLexersFsm[subLexer.Key] = currentGenericLexer.FSMBuilder.Fsm;
             }
 
             result.Result = genLexer;
-            
+
             return result;
         }
 
 
         private static BuildResult<ILexer<IN>> BuildGenericLexer<IN>(IDictionary<IN, List<LexemeAttribute>> attributes,
-            BuildExtension<IN> extensionBuilder, BuildResult<ILexer<IN>> result, string lang,
+            Action<IN, LexemeAttribute, GenericLexer<IN>> extensionBuilder, BuildResult<ILexer<IN>> result, string lang,
             IList<string> explicitTokens = null) where IN : struct
         {
-            
             result = CheckStringAndCharTokens<IN>(attributes, result, lang);
             var (config, tokens) = GetConfigAndGenericTokens<IN>(attributes);
 
-            
-            
+
             config.ExtensionBuilder = extensionBuilder;
             var lexer = new GenericLexer<IN>(config, tokens);
             var Extensions = new Dictionary<IN, LexemeAttribute>();
@@ -406,7 +408,7 @@ private static BuildResult<ILexer<IN>> BuildGenericLexer<IN>(IDictionary<IN, Lis
                 {
                     lexer.AddLexeme(lexeme.GenericToken, tokenID);
                 }
-                
+
                 foreach (var lexeme in lexemes.Where(x => x.GenericToken != GenericToken.Identifier))
                 {
                     try
@@ -423,7 +425,8 @@ private static BuildResult<ILexer<IN>> BuildGenericLexer<IN>(IDictionary<IN, Lis
                             {
                                 separator = lexeme.GenericTokenParameters[0];
                             }
-                            lexer.AddDouble(tokenID,separator ,result);
+
+                            lexer.AddDouble(tokenID, separator, result);
                             lexer.AddLexeme(lexeme.GenericToken, tokenID);
                         }
 
@@ -431,7 +434,8 @@ private static BuildResult<ILexer<IN>> BuildGenericLexer<IN>(IDictionary<IN, Lis
                         {
                             foreach (var param in lexeme.GenericTokenParameters)
                             {
-                                lexer.AddKeyWord(tokenID, param,lexeme.IsPop,lexeme.IsPush,lexeme.Pushtarget, result);
+                                lexer.AddKeyWord(tokenID, param, lexeme.IsPop, lexeme.IsPush, lexeme.Pushtarget,
+                                    result);
                             }
                         }
 
@@ -439,13 +443,13 @@ private static BuildResult<ILexer<IN>> BuildGenericLexer<IN>(IDictionary<IN, Lis
                         {
                             foreach (var param in lexeme.GenericTokenParameters)
                             {
-                                lexer.AddSugarLexem(tokenID,result, param, lexeme.IsLineEnding, lexeme.Channel);
+                                lexer.AddSugarLexem(tokenID, result, param, lexeme.IsLineEnding, lexeme.Channel);
                             }
                         }
 
                         if (lexeme.IsUpTo)
                         {
-                            lexer.AddUpTo(tokenID,result,lexeme.GenericTokenParameters);
+                            lexer.AddUpTo(tokenID, result, lexeme.GenericTokenParameters);
                         }
 
                         if (lexeme.IsString)
@@ -477,23 +481,23 @@ private static BuildResult<ILexer<IN>> BuildGenericLexer<IN>(IDictionary<IN, Lis
                     }
                     catch (Exception e)
                     {
-                        result.AddError(new InitializationError(ErrorLevel.FATAL, e.Message,ErrorCodes.LEXER_UNKNOWN_ERROR));
+                        result.AddError(new InitializationError(ErrorLevel.FATAL, e.Message,
+                            ErrorCodes.LEXER_UNKNOWN_ERROR));
                     }
                 }
             }
-            
-            
+
 
             AddExtensions<IN>(Extensions, extensionBuilder, lexer);
 
-            
-            var allComments = GetCommentsAttribute<IN>(result,lang);
-            var CommentsForSubLexer = allComments.Where(x => attributes.Keys.ToList().Contains(x.Key)).ToDictionary(x => x.Key, x => x.Value);
+
+            var allComments = GetCommentsAttribute<IN>(result, lang);
+            var CommentsForSubLexer = allComments.Where(x => attributes.Keys.ToList().Contains(x.Key))
+                .ToDictionary(x => x.Key, x => x.Value);
             if (!result.IsError)
             {
                 foreach (var comment in CommentsForSubLexer)
                 {
-
                     foreach (var commentAttr in comment.Value)
                     {
                         var fsmBuilder = lexer.FSMBuilder;
@@ -507,7 +511,8 @@ private static BuildResult<ILexer<IN>> BuildGenericLexer<IN>(IDictionary<IN, Lis
                             fsmBuilder.ConstantTransition(commentAttr.SingleLineCommentStart);
                             fsmBuilder.Mark(GenericLexer<IN>.single_line_comment_start);
                             fsmBuilder.End(GenericToken.Comment);
-                            fsmBuilder.CallBack(GetCallbackSingle<IN>(comment.Key,commentAttr.DoNotIgnore, commentAttr.Channel));
+                            fsmBuilder.CallBack(GetCallbackSingle<IN>(comment.Key, commentAttr.DoNotIgnore,
+                                commentAttr.Channel));
                         }
 
                         var hasMultiLine = !string.IsNullOrWhiteSpace(commentAttr.MultiLineCommentStart);
@@ -515,12 +520,13 @@ private static BuildResult<ILexer<IN>> BuildGenericLexer<IN>(IDictionary<IN, Lis
                         {
                             lexer.MultiLineCommentStart = commentAttr.MultiLineCommentStart;
                             lexer.MultiLineCommentEnd = commentAttr.MultiLineCommentEnd;
-                            
+
                             fsmBuilder.GoTo(GenericLexer<IN>.start);
                             fsmBuilder.ConstantTransition(commentAttr.MultiLineCommentStart);
                             fsmBuilder.Mark(GenericLexer<IN>.multi_line_comment_start);
                             fsmBuilder.End(GenericToken.Comment);
-                            fsmBuilder.CallBack(GetCallbackMulti<IN>(comment.Key,commentAttr.DoNotIgnore, commentAttr.Channel));
+                            fsmBuilder.CallBack(GetCallbackMulti<IN>(comment.Key, commentAttr.DoNotIgnore,
+                                commentAttr.Channel));
                         }
                     }
                 }
@@ -534,22 +540,21 @@ private static BuildResult<ILexer<IN>> BuildGenericLexer<IN>(IDictionary<IN, Lis
                         if (!fsmBuilder.Marks.Any(mark => mark.Key == GenericLexer<IN>.in_identifier))
                         {
                             // no identifier pattern has been defined. Creating a default one to allow explicit keyword tokens
-                            (lexer as GenericLexer<IN>).InitializeIdentifier(new GenericLexer<IN>.Config()  { IdType = IdentifierType.Alpha});
+                            (lexer as GenericLexer<IN>).InitializeIdentifier(new GenericLexer<IN>.Config()
+                                { IdType = IdentifierType.Alpha });
                         }
-                        
+
                         var x = fsmBuilder.Fsm.Run(explicitToken, new LexerPosition());
                         if (x.IsSuccess)
                         {
-                            
-                            
-                            
                             var t = fsmBuilder.Marks;
                             var y = fsmBuilder.Marks.FirstOrDefault(k => k.Value == x.NodeId);
                             if (y.Key == GenericLexer<IN>.in_identifier) // explicit keyword
                             {
                                 var resultx = new BuildResult<ILexer<IN>>();
                                 result.Errors.AddRange(resultx.Errors);
-                                lexer.AddKeyWord(default(IN), explicitToken,false,false,ModeAttribute.DefaultLexerMode, resultx);
+                                lexer.AddKeyWord(default(IN), explicitToken, false, false,
+                                    ModeAttribute.DefaultLexerMode, resultx);
                                 ;
                             }
                             else
@@ -567,16 +572,15 @@ private static BuildResult<ILexer<IN>> BuildGenericLexer<IN>(IDictionary<IN, Lis
                         }
                     }
                 }
-
             }
-            
+
             result.Result = lexer;
             return result;
         }
-        
-        
 
-        private static (string delimiter, string escape) GetDelimiters(LexemeAttribute lexeme, string delimiter, string escape)
+
+        private static (string delimiter, string escape) GetDelimiters(LexemeAttribute lexeme, string delimiter,
+            string escape)
         {
             if (lexeme.HasGenericTokenParameters)
             {
@@ -591,23 +595,25 @@ private static (string delimiter, string escape) GetDelimiters(LexemeAttribute l
         }
 
         private static BuildResult<ILexer<IN>> CheckStringAndCharTokens<IN>(
-            IDictionary<IN, List<LexemeAttribute>> attributes, BuildResult<ILexer<IN>> result, string lang) where IN : struct
+            IDictionary<IN, List<LexemeAttribute>> attributes, BuildResult<ILexer<IN>> result, string lang)
+            where IN : struct
         {
             var allLexemes = attributes.Values.SelectMany<List<LexemeAttribute>, LexemeAttribute>(a => a);
 
             var allDelimiters = allLexemes
-                                .Where<LexemeAttribute>(a => a.IsString || a.IsChar)
-                                .Where<LexemeAttribute>(a => a.HasGenericTokenParameters)
-                                .Select<LexemeAttribute, string>(a => a.GenericTokenParameters[0]);
+                .Where<LexemeAttribute>(a => a.IsString || a.IsChar)
+                .Where<LexemeAttribute>(a => a.HasGenericTokenParameters)
+                .Select<LexemeAttribute, string>(a => a.GenericTokenParameters[0]);
 
             var duplicates = allDelimiters.GroupBy<string, string>(x => x)
-                                        .Where<IGrouping<string, string>>(g => g.Count<string>() > 1)
-                                        .Select(y => new { Element = y.Key, Counter = y.Count<string>() });
+                .Where<IGrouping<string, string>>(g => g.Count<string>() > 1)
+                .Select(y => new { Element = y.Key, Counter = y.Count<string>() });
 
             foreach (var duplicate in duplicates)
             {
                 result.AddError(new LexerInitializationError(ErrorLevel.FATAL,
-                    I18N.Instance.GetText(lang,I18NMessage.DuplicateStringCharDelimiters,duplicate.Element,duplicate.Counter.ToString()),
+                    I18N.Instance.GetText(lang, I18NMessage.DuplicateStringCharDelimiters, duplicate.Element,
+                        duplicate.Counter.ToString()),
                     ErrorCodes.LEXER_DUPLICATE_STRING_CHAR_DELIMITERS));
             }
 
@@ -615,46 +621,52 @@ private static BuildResult<ILexer<IN>> CheckStringAndCharTokens<IN>(
         }
 
 
-        private static Dictionary<IN, List<CommentAttribute>> GetCommentsAttribute<IN>(BuildResult<ILexer<IN>> result, string lang) where IN : struct
+        private static Dictionary<IN, List<CommentAttribute>> GetCommentsAttribute<IN>(BuildResult<ILexer<IN>> result,
+            string lang) where IN : struct
         {
             var attributes = new Dictionary<IN, List<CommentAttribute>>();
 
             var values = Enum.GetValues(typeof(IN));
             foreach (Enum value in values)
             {
-                var tokenID = (IN) (object) value;
+                var tokenID = (IN)(object)value;
                 var enumAttributes = value.GetAttributesOfType<CommentAttribute>();
-                if (enumAttributes != null && enumAttributes.Any<CommentAttribute>()) attributes[tokenID] = enumAttributes.ToList<CommentAttribute>();
+                if (enumAttributes != null && enumAttributes.Any<CommentAttribute>())
+                    attributes[tokenID] = enumAttributes.ToList<CommentAttribute>();
             }
 
-            var commentCount = attributes.Values.Select<List<CommentAttribute>, int>(l => l?.Count<CommentAttribute>(attr => attr.GetType() == typeof(CommentAttribute)) ?? 0).Sum();
-            var multiLineCommentCount = attributes.Values.Select<List<CommentAttribute>, int>(l => l?.Count<CommentAttribute>(attr => attr.GetType() == typeof(MultiLineCommentAttribute)) ?? 0).Sum();
-            var singleLineCommentCount = attributes.Values.Select<List<CommentAttribute>, int>(l => l?.Count<CommentAttribute>(attr => attr.GetType() == typeof(SingleLineCommentAttribute)) ?? 0).Sum();
+            var commentCount = attributes.Values.Select<List<CommentAttribute>, int>(l =>
+                l?.Count<CommentAttribute>(attr => attr.GetType() == typeof(CommentAttribute)) ?? 0).Sum();
+            var multiLineCommentCount = attributes.Values.Select<List<CommentAttribute>, int>(l =>
+                l?.Count<CommentAttribute>(attr => attr.GetType() == typeof(MultiLineCommentAttribute)) ?? 0).Sum();
+            var singleLineCommentCount = attributes.Values.Select<List<CommentAttribute>, int>(l =>
+                l?.Count<CommentAttribute>(attr => attr.GetType() == typeof(SingleLineCommentAttribute)) ?? 0).Sum();
 
             if (commentCount > 1)
             {
                 result.AddError(new LexerInitializationError(ErrorLevel.FATAL,
-                    I18N.Instance.GetText(lang,I18NMessage.TooManyComment),
+                    I18N.Instance.GetText(lang, I18NMessage.TooManyComment),
                     ErrorCodes.LEXER_TOO_MANY_COMMNENT));
             }
 
             if (multiLineCommentCount > 1)
             {
                 result.AddError(new LexerInitializationError(ErrorLevel.FATAL,
-                    I18N.Instance.GetText(lang,I18NMessage.TooManyMultilineComment),
+                    I18N.Instance.GetText(lang, I18NMessage.TooManyMultilineComment),
                     ErrorCodes.LEXER_TOO_MANY_MULTILINE_COMMNENT));
             }
 
             if (singleLineCommentCount > 1)
             {
-                result.AddError(new LexerInitializationError(ErrorLevel.FATAL, 
-                    I18N.Instance.GetText(lang,I18NMessage.TooManySingleLineComment),ErrorCodes.LEXER_TOO_MANY_SINGLELINE_COMMNENT));
+                result.AddError(new LexerInitializationError(ErrorLevel.FATAL,
+                    I18N.Instance.GetText(lang, I18NMessage.TooManySingleLineComment),
+                    ErrorCodes.LEXER_TOO_MANY_SINGLELINE_COMMNENT));
             }
 
             if (commentCount > 0 && (multiLineCommentCount > 0 || singleLineCommentCount > 0))
             {
-                result.AddError(new LexerInitializationError(ErrorLevel.FATAL, 
-                    I18N.Instance.GetText(lang,I18NMessage.CannotMixCommentAndSingleOrMulti),
+                result.AddError(new LexerInitializationError(ErrorLevel.FATAL,
+                    I18N.Instance.GetText(lang, I18NMessage.CannotMixCommentAndSingleOrMulti),
                     ErrorCodes.LEXER_CANNOT_MIX_COMMENT_AND_SINGLE_OR_MULTI));
             }
 
@@ -662,7 +674,7 @@ private static Dictionary<IN, List<CommentAttribute>> GetCommentsAttribute<IN>(B
         }
 
         private static void AddExtensions<IN>(Dictionary<IN, LexemeAttribute> extensions,
-            BuildExtension<IN> extensionBuilder, GenericLexer<IN> lexer) where IN : struct
+            Action<IN, LexemeAttribute, GenericLexer<IN>> extensionBuilder, GenericLexer<IN> lexer) where IN : struct
         {
             if (extensionBuilder != null)
             {
diff --git a/sly/lexer/fsm/FSMLexer.cs b/sly/lexer/fsm/FSMLexer.cs
index 29120c0c..5216ff8d 100644
--- a/sly/lexer/fsm/FSMLexer.cs
+++ b/sly/lexer/fsm/FSMLexer.cs
@@ -12,22 +12,19 @@ public static T At<T>(this ReadOnlyMemory<T> memory, int index)
         {
             return memory.Span[index];
         }
-        
+
         public static T At<T>(this ReadOnlyMemory<T> memory, LexerPosition position)
         {
             return memory.Span[position.Index];
         }
     }
 
-    public delegate void BuildExtension<IN>(IN token, LexemeAttribute lexem, GenericLexer<IN> lexer) where IN : struct;
-    
     public delegate List<Token<IN>> LexerPostProcess<IN>(List<Token<IN>> tokens) where IN : struct;
 
-    public class FSMLexer<N>  where N : struct
+    public class FSMLexer<N> where N : struct
     {
-        
         public string Mode { get; set; }
-        
+
         private readonly Dictionary<int, FSMNode<N>> Nodes;
 
         public char StringDelimiter = '"';
@@ -52,9 +49,9 @@ public FSMLexer()
         public bool IgnoreEOL { get; set; }
 
         public bool AggregateEOL { get; set; }
-        
+
         public bool IndentationAware { get; set; }
-        
+
         public string Indentation { get; set; }
 
 
@@ -71,10 +68,9 @@ public string ToGraphViz()
                 dump.Append(fsmNode.Value.Id);
                 var shape = fsmNode.Value.IsEnd ? "doublecircle" : "circle";
                 dump.AppendLine($@"[shape={shape} label=""{fsmNode.Value.GraphVizNodeLabel()}""] ");
-
             }
-            
-            foreach (var transition in Transitions.Values.SelectMany<List<FSMTransition>, FSMTransition>(x => x) )
+
+            foreach (var transition in Transitions.Values.SelectMany<List<FSMTransition>, FSMTransition>(x => x))
                 dump.AppendLine(transition.ToGraphViz<N>(Nodes));
 
             dump.AppendLine("}");
@@ -154,7 +150,6 @@ public FSMNode<N> AddNode()
 
         #region run
 
-        
         public FSMMatch<N> Run(string source, LexerPosition position)
         {
             return Run(new ReadOnlyMemory<char>(source.ToCharArray()), position);
@@ -168,6 +163,7 @@ public int ComputeIndentationSize(ReadOnlyMemory<char> source, int index)
             {
                 return 0;
             }
+
             string id = source.Slice(index, Indentation.Length).ToString();
             while (id == Indentation)
             {
@@ -175,6 +171,7 @@ public int ComputeIndentationSize(ReadOnlyMemory<char> source, int index)
                 index += Indentation.Length;
                 id = source.Slice(index, Indentation.Length).ToString();
             }
+
             return count;
         }
 
@@ -182,44 +179,43 @@ public List<char> GetIndentations(ReadOnlyMemory<char> source, int index)
         {
             List<Char> indentations = new List<char>();
             int i = 0;
-            if (index  >= source.Length)
+            if (index >= source.Length)
             {
                 return new List<char>();
                 ;
             }
-            char current = source.At<char>(index+i);
-            while (i < source.Length && (current == ' ' || current == '\t' ))
+
+            char current = source.At<char>(index + i);
+            while (i < source.Length && (current == ' ' || current == '\t'))
             {
                 indentations.Add(current);
                 i++;
-                current = source.At<char>(index+i);
+                current = source.At<char>(index + i);
             }
 
             return indentations;
         }
-        
-      
-        
+
+
         public FSMMatch<N> Run(ReadOnlyMemory<char> source, LexerPosition lexerPosition)
         {
-
             if (IndentationAware)
             {
-                var ind = ConsumeIndents(source, lexerPosition); 
+                var ind = ConsumeIndents(source, lexerPosition);
                 if (ind != null)
                 {
                     return ind;
                 }
             }
-            
+
             // if line start :
-            
+
             // consume tabs and count them
             // if count = previousCount +1 => add an indent token
             // if count = previousCount -1 => add an unindent token
             // else ....
-            
-            var ignoredTokens = ConsumeIgnored(source,lexerPosition);
+
+            var ignoredTokens = ConsumeIgnored(source, lexerPosition);
 
             if (IndentationAware) // could start of line
             {
@@ -256,7 +252,9 @@ public FSMMatch<N> Run(ReadOnlyMemory<char> source, LexerPosition lexerPosition)
                 {
                     // Remember the possible match
                     lexerPosition.Mode = this.Mode;
-                    result = new FSMMatch<N>(true, currentNode.Value, currentValue, position, currentNode.Id,lexerPosition, currentNode.IsLineEnding, currentNode.IsPopModeNode, currentNode.IsPushModeNode, currentNode.PushToMode,DecimalSeparator);
+                    result = new FSMMatch<N>(true, currentNode.Value, currentValue, position, currentNode.Id,
+                        lexerPosition, currentNode.IsLineEnding, currentNode.IsPopModeNode, currentNode.IsPushModeNode,
+                        currentNode.PushToMode, DecimalSeparator);
                 }
 
                 lexerPosition.Index++;
@@ -287,21 +285,20 @@ public FSMMatch<N> Run(ReadOnlyMemory<char> source, LexerPosition lexerPosition)
             }
 
             var errorChar = source.Slice(lexerPosition.Index, 1);
-            var ko = new FSMMatch<N>(false, default(N), errorChar, lexerPosition, -1,lexerPosition, false);
+            var ko = new FSMMatch<N>(false, default(N), errorChar, lexerPosition, -1, lexerPosition, false);
             return ko;
         }
 
         private FSMMatch<N> ConsumeIndents(ReadOnlyMemory<char> source, LexerPosition lexerPosition)
         {
-            
             if (lexerPosition.IsStartOfLine)
             {
                 var indents = GetIndentations(source, lexerPosition.Index);
-                
+
                 var currentIndentations = lexerPosition.Indentations.ToList<string>();
 
                 int uIndentCount = 0;
-                
+
                 int indentPosition = 0;
                 if (currentIndentations.Any<string>())
                 {
@@ -309,7 +306,7 @@ private FSMMatch<N> ConsumeIndents(ReadOnlyMemory<char> source, LexerPosition le
                     int indentCharCount = 0;
                     while (i < currentIndentations.Count && indentPosition < indents.Count)
                     {
-                        var current = currentIndentations[currentIndentations.Count-i-1];
+                        var current = currentIndentations[currentIndentations.Count - i - 1];
                         int j = 0;
                         if (indentPosition + current.Length > indents.Count)
                         {
@@ -328,7 +325,8 @@ private FSMMatch<N> ConsumeIndents(ReadOnlyMemory<char> source, LexerPosition le
                                 var actual = indents[j + indentPosition];
                                 if (actual != reference)
                                 {
-                                    var ko = new FSMMatch<N>(false, default(N), " ", lexerPosition, -1, lexerPosition, false)
+                                    var ko = new FSMMatch<N>(false, default(N), " ", lexerPosition, -1, lexerPosition,
+                                        false)
                                     {
                                         IsIndentationError = true
                                     };
@@ -345,7 +343,7 @@ private FSMMatch<N> ConsumeIndents(ReadOnlyMemory<char> source, LexerPosition le
                         {
                             var t = indents.Skip<char>(indentCharCount).ToArray<char>();
                             var newTab = new string(t);
-                            var indent = FSMMatch<N>.Indent(lexerPosition.Indentations.Count<string>()+1);
+                            var indent = FSMMatch<N>.Indent(lexerPosition.Indentations.Count<string>() + 1);
                             indent.Result = new Token<N>
                             {
                                 IsIndent = true,
@@ -356,8 +354,8 @@ private FSMMatch<N> ConsumeIndents(ReadOnlyMemory<char> source, LexerPosition le
                             indent.NewPosition.Column += indents.Count;
                             indent.NewPosition.Indentations = indent.NewPosition.Indentations.Push(newTab);
                             return indent;
-                            
                         }
+
                         indentPosition += current.Length;
                         i++;
                     }
@@ -368,8 +366,8 @@ private FSMMatch<N> ConsumeIndents(ReadOnlyMemory<char> source, LexerPosition le
                         currentIndentations.Reverse();
                         var unindented = currentIndentations.Take<string>(i).ToList<string>();
                         var spaces = unindented.Select<string, int>(x => x.Length).Sum();
-                        
-                        var uIndent = FSMMatch<N>.UIndent(uIndentCount,uIndentCount);
+
+                        var uIndent = FSMMatch<N>.UIndent(uIndentCount, uIndentCount);
                         uIndent.Result = new Token<N>
                         {
                             IsIndent = true,
@@ -383,6 +381,7 @@ private FSMMatch<N> ConsumeIndents(ReadOnlyMemory<char> source, LexerPosition le
                         {
                             uIndent.NewPosition.Indentations = uIndent.NewPosition.Indentations.Pop();
                         }
+
                         return uIndent;
                     }
                     else
@@ -408,9 +407,11 @@ private FSMMatch<N> ConsumeIndents(ReadOnlyMemory<char> source, LexerPosition le
                         indent.NewPosition = lexerPosition.Clone();
                         indent.NewPosition.Index += indents.Count;
                         indent.NewPosition.Column += indents.Count;
-                        indent.NewPosition.Indentations = indent.NewPosition.Indentations.Push(new string(indents.ToArray()));
+                        indent.NewPosition.Indentations =
+                            indent.NewPosition.Indentations.Push(new string(indents.ToArray()));
                         return indent;
                     }
+
                     ;
                     return null;
                 }
@@ -439,13 +440,12 @@ private FSMNode<N> Move(FSMNode<N> from, char token, ReadOnlyMemory<char> value)
         public FSMNode<N> GetNext(int from, char token)
         {
             var node = Nodes[from];
-            
+
             return Move(node, token, "".AsMemory());
         }
 
         private List<Token<N>> ConsumeIgnored(ReadOnlyMemory<char> source, LexerPosition position)
         {
-
             bool eolReached = false;
             List<Token<N>> ignoredTokens = new List<Token<N>>();
             while (position.Index < source.Length && !(eolReached && IndentationAware))
@@ -455,8 +455,9 @@ private List<Token<N>> ConsumeIgnored(ReadOnlyMemory<char> source, LexerPosition
                     var currentCharacter = source.At<char>(position.Index);
                     if (WhiteSpaces.Contains(currentCharacter))
                     {
-                        var whiteToken = new Token<N>(default(N),source.Slice(position.Index, 1), position, false, CommentType.No,
-                            Channels.WhiteSpaces,isWhiteSpace:true, decimalSeparator:DecimalSeparator);
+                        var whiteToken = new Token<N>(default(N), source.Slice(position.Index, 1), position, false,
+                            CommentType.No,
+                            Channels.WhiteSpaces, isWhiteSpace: true, decimalSeparator: DecimalSeparator);
                         ignoredTokens.Add(whiteToken);
                         whiteToken.IsWhiteSpace = true;
                         position.Index++;
@@ -484,10 +485,10 @@ private List<Token<N>> ConsumeIgnored(ReadOnlyMemory<char> source, LexerPosition
 
                 break;
             }
+
             return ignoredTokens;
         }
 
         #endregion
-        
     }
 }
\ No newline at end of file
diff --git a/sly/parser/generator/EBNFParserBuilder.cs b/sly/parser/generator/EBNFParserBuilder.cs
index a6e62f71..62c7f453 100644
--- a/sly/parser/generator/EBNFParserBuilder.cs
+++ b/sly/parser/generator/EBNFParserBuilder.cs
@@ -4,6 +4,7 @@
 using System.Reflection;
 using sly.buildresult;
 using sly.i18n;
+using sly.lexer;
 using sly.lexer.fsm;
 using sly.parser.generator.visitor;
 using sly.parser.llparser;
@@ -16,23 +17,23 @@ namespace sly.parser.generator
     /// </summary>
     internal class EBNFParserBuilder<IN, OUT> : ParserBuilder<IN, OUT> where IN : struct
     {
-        
         public EBNFParserBuilder(string i18n = null) : base(i18n)
         {
         }
-        
+
         public override BuildResult<Parser<IN, OUT>> BuildParser(object parserInstance, ParserType parserType,
-            string rootRule, BuildExtension<IN> extensionBuilder = null, LexerPostProcess<IN> lexerPostProcess = null)
+            string rootRule, Action<IN, LexemeAttribute, GenericLexer<IN>> extensionBuilder = null,
+            LexerPostProcess<IN> lexerPostProcess = null)
         {
             if (string.IsNullOrEmpty(rootRule))
             {
                 var rootAttribute = parserInstance.GetType().GetCustomAttribute<ParserRootAttribute>();
-                if (rootAttribute  != null)
+                if (rootAttribute != null)
                 {
                     rootRule = rootAttribute.RootRule;
                 }
             }
-            
+
             var ruleparser = new RuleParser<IN>();
             var builder = new ParserBuilder<EbnfTokenGeneric, GrammarNode<IN>>(I18n);
 
@@ -46,24 +47,25 @@ public override BuildResult<Parser<IN, OUT>> BuildParser(object parserInstance,
             try
             {
                 configuration = ExtractEbnfParserConfiguration(parserInstance.GetType(), grammarParser);
-                LeftRecursionChecker<IN,OUT> recursionChecker = new LeftRecursionChecker<IN,OUT>();
-                
+                LeftRecursionChecker<IN, OUT> recursionChecker = new LeftRecursionChecker<IN, OUT>();
+
                 // check left recursion.
-                var (foundRecursion, recursions) = LeftRecursionChecker<IN,OUT>.CheckLeftRecursion(configuration);
+                var (foundRecursion, recursions) = LeftRecursionChecker<IN, OUT>.CheckLeftRecursion(configuration);
                 if (foundRecursion)
                 {
-                    var recs = string.Join("\n", recursions.Select<List<string>, string>(x => string.Join(" > ",x)));
+                    var recs = string.Join("\n", recursions.Select<List<string>, string>(x => string.Join(" > ", x)));
                     result.AddError(new ParserInitializationError(ErrorLevel.FATAL,
-                        I18N.Instance.GetText(I18n,I18NMessage.LeftRecursion,recs),
+                        I18N.Instance.GetText(I18n, I18NMessage.LeftRecursion, recs),
                         ErrorCodes.PARSER_LEFT_RECURSIVE));
                     return result;
                 }
-                
+
                 configuration.StartingRule = rootRule;
             }
             catch (Exception e)
             {
-                result.AddError(new ParserInitializationError(ErrorLevel.ERROR, e.Message,ErrorCodes.PARSER_UNKNOWN_ERROR));
+                result.AddError(new ParserInitializationError(ErrorLevel.ERROR, e.Message,
+                    ErrorCodes.PARSER_UNKNOWN_ERROR));
                 return result;
             }
 
@@ -71,15 +73,17 @@ public override BuildResult<Parser<IN, OUT>> BuildParser(object parserInstance,
 
             SyntaxTreeVisitor<IN, OUT> visitor = null;
             visitor = new EBNFSyntaxTreeVisitor<IN, OUT>(configuration, parserInstance);
-            var parser = new Parser<IN, OUT>(I18n,syntaxParser, visitor);
+            var parser = new Parser<IN, OUT>(I18n, syntaxParser, visitor);
             parser.Configuration = configuration;
-            var lexerResult = BuildLexer(extensionBuilder,lexerPostProcess, configuration.GetAllExplicitTokenClauses().Select(x => x.ExplicitToken).Distinct().ToList());
+            var lexerResult = BuildLexer(extensionBuilder, lexerPostProcess,
+                configuration.GetAllExplicitTokenClauses().Select(x => x.ExplicitToken).Distinct().ToList());
             if (lexerResult.IsError)
             {
                 foreach (var lexerResultError in lexerResult.Errors)
                 {
                     result.AddError(lexerResultError);
                 }
+
                 return result;
             }
             else
@@ -101,12 +105,12 @@ protected override ISyntaxParser<IN, OUT> BuildSyntaxParser(ParserConfiguration<
             {
                 case ParserType.LL_RECURSIVE_DESCENT:
                 {
-                    parser = new RecursiveDescentSyntaxParser<IN, OUT>(conf, rootRule,I18n);
+                    parser = new RecursiveDescentSyntaxParser<IN, OUT>(conf, rootRule, I18n);
                     break;
                 }
                 case ParserType.EBNF_LL_RECURSIVE_DESCENT:
                 {
-                    parser = new EBNFRecursiveDescentSyntaxParser<IN, OUT>(conf, rootRule,I18n);
+                    parser = new EBNFRecursiveDescentSyntaxParser<IN, OUT>(conf, rootRule, I18n);
                     break;
                 }
                 default:
@@ -138,7 +142,7 @@ protected virtual ParserConfiguration<IN, OUT> ExtractEbnfParserConfiguration(Ty
             methods.ForEach(m =>
             {
                 var attributes =
-                    (ProductionAttribute[]) m.GetCustomAttributes(typeof(ProductionAttribute), true);
+                    (ProductionAttribute[])m.GetCustomAttributes(typeof(ProductionAttribute), true);
 
                 foreach (var attr in attributes)
                 {
@@ -146,7 +150,7 @@ protected virtual ParserConfiguration<IN, OUT> ExtractEbnfParserConfiguration(Ty
                     var parseResult = grammarParser.Parse(ruleString);
                     if (!parseResult.IsError)
                     {
-                        var rule = (Rule<IN>) parseResult.Result;
+                        var rule = (Rule<IN>)parseResult.Result;
                         rule.RuleString = ruleString;
                         rule.SetVisitor(m);
                         NonTerminal<IN> nonT = null;
diff --git a/sly/parser/generator/ParserBuilder.cs b/sly/parser/generator/ParserBuilder.cs
index 982c4eb7..cbce76a5 100644
--- a/sly/parser/generator/ParserBuilder.cs
+++ b/sly/parser/generator/ParserBuilder.cs
@@ -23,7 +23,7 @@ public delegate BuildResult<Parser<IN, OUT>> ParserChecker<IN, OUT>(BuildResult<
     public class ParserBuilder<IN, OUT> where IN : struct
     {
         #region API
-        
+
         public string I18n { get; set; }
 
         public ParserBuilder(string i18n)
@@ -32,9 +32,10 @@ public ParserBuilder(string i18n)
             {
                 i18n = CultureInfo.CurrentCulture.TwoLetterISOLanguageName;
             }
+
             I18n = i18n;
         }
-        
+
         public ParserBuilder() : this(null)
         {
         }
@@ -53,7 +54,8 @@ public ParserBuilder() : this(null)
         ///     <param name="rootRule">the name of the root non terminal of the grammar</param>
         ///     <returns></returns>
         public virtual BuildResult<Parser<IN, OUT>> BuildParser(object parserInstance, ParserType parserType,
-            string rootRule = null, BuildExtension<IN> extensionBuilder = null, LexerPostProcess<IN> lexerPostProcess = null)
+            string rootRule = null, Action<IN, LexemeAttribute, GenericLexer<IN>> extensionBuilder = null,
+            LexerPostProcess<IN> lexerPostProcess = null)
         {
             Parser<IN, OUT> parser = null;
             var result = new BuildResult<Parser<IN, OUT>>();
@@ -62,21 +64,22 @@ public virtual BuildResult<Parser<IN, OUT>> BuildParser(object parserInstance, P
                 case ParserType.LL_RECURSIVE_DESCENT:
                 {
                     var configuration = ExtractParserConfiguration(parserInstance.GetType());
-                    var (foundRecursion, recursions) = LeftRecursionChecker<IN,OUT>.CheckLeftRecursion(configuration);
+                    var (foundRecursion, recursions) = LeftRecursionChecker<IN, OUT>.CheckLeftRecursion(configuration);
                     if (foundRecursion)
                     {
-                        var recs = string.Join("\n", recursions.Select<List<string>, string>(x => string.Join(" > ",x)));
+                        var recs = string.Join("\n",
+                            recursions.Select<List<string>, string>(x => string.Join(" > ", x)));
                         result.AddError(new ParserInitializationError(ErrorLevel.FATAL,
-                            I18N.Instance.GetText(I18n,I18NMessage.LeftRecursion, recs),
+                            I18N.Instance.GetText(I18n, I18NMessage.LeftRecursion, recs),
                             ErrorCodes.PARSER_LEFT_RECURSIVE));
                         return result;
-
                     }
+
                     configuration.StartingRule = rootRule;
                     var syntaxParser = BuildSyntaxParser(configuration, parserType, rootRule);
                     var visitor = new SyntaxTreeVisitor<IN, OUT>(configuration, parserInstance);
-                    parser = new Parser<IN, OUT>(I18n,syntaxParser, visitor);
-                    
+                    parser = new Parser<IN, OUT>(I18n, syntaxParser, visitor);
+
                     parser.Instance = parserInstance;
                     parser.Configuration = configuration;
                     result.Result = parser;
@@ -86,7 +89,7 @@ public virtual BuildResult<Parser<IN, OUT>> BuildParser(object parserInstance, P
                 {
                     var builder = new EBNFParserBuilder<IN, OUT>(I18n);
                     result = builder.BuildParser(parserInstance, ParserType.EBNF_LL_RECURSIVE_DESCENT, rootRule,
-                        extensionBuilder,lexerPostProcess);
+                        extensionBuilder, lexerPostProcess);
                     break;
                 }
             }
@@ -96,12 +99,13 @@ public virtual BuildResult<Parser<IN, OUT>> BuildParser(object parserInstance, P
             {
                 var expressionResult = parser.BuildExpressionParser(result, rootRule);
                 if (expressionResult.IsError) result.AddErrors(expressionResult.Errors);
-                
-                
-                
+
+
                 result.Result.Configuration = expressionResult.Result;
-                
-                var lexerResult = BuildLexer(extensionBuilder,lexerPostProcess, result.Result.Configuration.GetAllExplicitTokenClauses().Select(x => x.ExplicitToken).Distinct().ToList());
+
+                var lexerResult = BuildLexer(extensionBuilder, lexerPostProcess,
+                    result.Result.Configuration.GetAllExplicitTokenClauses().Select(x => x.ExplicitToken).Distinct()
+                        .ToList());
                 if (lexerResult.IsError)
                 {
                     foreach (var lexerResultError in lexerResult.Errors)
@@ -114,14 +118,14 @@ public virtual BuildResult<Parser<IN, OUT>> BuildParser(object parserInstance, P
                     parser.Lexer = lexerResult.Result;
                     parser.Instance = parserInstance;
                     result.Result = parser;
-                    
                 }
-                
+
                 result = CheckParser(result);
                 if (result.IsError)
                 {
                     result.Result = null;
                 }
+
                 return result;
             }
             else
@@ -141,7 +145,7 @@ protected virtual ISyntaxParser<IN, OUT> BuildSyntaxParser(ParserConfiguration<I
             {
                 case ParserType.LL_RECURSIVE_DESCENT:
                 {
-                    parser = new RecursiveDescentSyntaxParser<IN, OUT>(conf, rootRule,I18n);
+                    parser = new RecursiveDescentSyntaxParser<IN, OUT>(conf, rootRule, I18n);
                     break;
                 }
                 default:
@@ -156,7 +160,6 @@ protected virtual ISyntaxParser<IN, OUT> BuildSyntaxParser(ParserConfiguration<I
 
         #endregion
 
-        
 
         #region CONFIGURATION
 
@@ -180,12 +183,12 @@ private Tuple<string, string> ExtractNTAndRule(string ruleString)
         }
 
 
-        protected virtual BuildResult<ILexer<IN>> BuildLexer(BuildExtension<IN> extensionBuilder = null,
+        protected virtual BuildResult<ILexer<IN>> BuildLexer(
+            Action<IN, LexemeAttribute, GenericLexer<IN>> extensionBuilder = null,
             LexerPostProcess<IN> lexerPostProcess = null, IList<string> explicitTokens = null)
         {
-            
-            
-            var lexer = LexerBuilder.BuildLexer<IN>(new BuildResult<ILexer<IN>>(), extensionBuilder, I18n, lexerPostProcess, explicitTokens);
+            var lexer = LexerBuilder.BuildLexer<IN>(new BuildResult<ILexer<IN>>(), extensionBuilder, I18n,
+                lexerPostProcess, explicitTokens);
 
             return lexer;
         }
@@ -207,7 +210,7 @@ protected virtual ParserConfiguration<IN, OUT> ExtractParserConfiguration(Type p
             parserClass.GetMethods();
             methods.ForEach(m =>
             {
-                var attributes = (ProductionAttribute[]) m.GetCustomAttributes(typeof(ProductionAttribute), true);
+                var attributes = (ProductionAttribute[])m.GetCustomAttributes(typeof(ProductionAttribute), true);
 
                 foreach (var attr in attributes)
                 {
@@ -240,7 +243,7 @@ private Rule<IN> BuildNonTerminal(Tuple<string, string> ntAndRule)
             rule.RuleString = $"{ntAndRule.Item1} : {ntAndRule.Item2}";
             var clauses = new List<IClause<IN>>();
             var ruleString = ntAndRule.Item2;
-            var clausesString = ruleString.Split(new[] {' '}, StringSplitOptions.RemoveEmptyEntries);
+            var clausesString = ruleString.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
             foreach (var item in clausesString)
             {
                 IClause<IN> clause = null;
@@ -269,7 +272,8 @@ private Rule<IN> BuildNonTerminal(Tuple<string, string> ntAndRule)
                 }
                 else if (item == "[d]")
                 {
-                    if (clauses.Last<IClause<IN>>() is TerminalClause<IN> discardedTerminal) discardedTerminal.Discarded = true;
+                    if (clauses.Last<IClause<IN>>() is TerminalClause<IN> discardedTerminal)
+                        discardedTerminal.Discarded = true;
                 }
                 else
                 {
@@ -321,7 +325,7 @@ private BuildResult<Parser<IN, OUT>> CheckUnreachable(BuildResult<Parser<IN, OUT
 
                 if (!found)
                     result.AddError(new ParserInitializationError(ErrorLevel.WARN,
-                        I18N.Instance.GetText(I18n,I18NMessage.NonTerminalNeverUsed, nonTerminal.Name),
+                        I18N.Instance.GetText(I18n, I18NMessage.NonTerminalNeverUsed, nonTerminal.Name),
                         ErrorCodes.NOT_AN_ERROR));
             }
 
@@ -365,7 +369,9 @@ private static bool NonTerminalReferences(NonTerminal<IN> nonTerminal, string re
                                     found = innerNonTerminal.NonTerminalName == referenceName;
                                     break;
                                 case ChoiceClause<IN> innerChoice when innerChoice.IsNonTerminalChoice:
-                                    found = innerChoice.Choices.Where<IClause<IN>>(c => (c as NonTerminalClause<IN>).NonTerminalName == referenceName).Any<IClause<IN>>();
+                                    found = innerChoice.Choices.Where<IClause<IN>>(c =>
+                                            (c as NonTerminalClause<IN>).NonTerminalName == referenceName)
+                                        .Any<IClause<IN>>();
                                     break;
                             }
 
@@ -380,6 +386,7 @@ private static bool NonTerminalReferences(NonTerminal<IN> nonTerminal, string re
                                 {
                                     found = nonTerm.NonTerminalName == referenceName;
                                 }
+
                                 i++;
                             }
 
@@ -389,6 +396,7 @@ private static bool NonTerminalReferences(NonTerminal<IN> nonTerminal, string re
 
                     iClause++;
                 }
+
                 iRule++;
             }
 
@@ -405,11 +413,12 @@ private BuildResult<Parser<IN, OUT>> CheckNotFound(BuildResult<Parser<IN, OUT>>
                 if (clause is NonTerminalClause<IN> ntClause)
                     if (!conf.NonTerminals.ContainsKey(ntClause.NonTerminalName))
                         result.AddError(new ParserInitializationError(ErrorLevel.ERROR,
-                            I18N.Instance.GetText(I18n,I18NMessage.ReferenceNotFound,ntClause.NonTerminalName,rule.RuleString),
+                            I18N.Instance.GetText(I18n, I18NMessage.ReferenceNotFound, ntClause.NonTerminalName,
+                                rule.RuleString),
                             ErrorCodes.PARSER_REFERENCE_NOT_FOUND));
             return result;
         }
-        
+
         private BuildResult<Parser<IN, OUT>> CheckAlternates(BuildResult<Parser<IN, OUT>> result,
             NonTerminal<IN> nonTerminal)
         {
@@ -424,13 +433,15 @@ private BuildResult<Parser<IN, OUT>> CheckAlternates(BuildResult<Parser<IN, OUT>
                         if (!choice.IsTerminalChoice && !choice.IsNonTerminalChoice)
                         {
                             result.AddError(new ParserInitializationError(ErrorLevel.ERROR,
-                                I18N.Instance.GetText(I18n,I18NMessage.MixedChoices,rule.RuleString,choice.ToString()),
+                                I18N.Instance.GetText(I18n, I18NMessage.MixedChoices, rule.RuleString,
+                                    choice.ToString()),
                                 ErrorCodes.PARSER_MIXED_CHOICES));
                         }
                         else if (choice.IsDiscarded && choice.IsNonTerminalChoice)
                         {
                             result.AddError(new ParserInitializationError(ErrorLevel.ERROR,
-                                I18N.Instance.GetText(I18n,I18NMessage.NonTerminalChoiceCannotBeDiscarded,rule.RuleString,choice.ToString()),
+                                I18N.Instance.GetText(I18n, I18NMessage.NonTerminalChoiceCannotBeDiscarded,
+                                    rule.RuleString, choice.ToString()),
                                 ErrorCodes.PARSER_NON_TERMINAL_CHOICE_CANNOT_BE_DISCARDED));
                         }
                     }
@@ -440,7 +451,7 @@ private BuildResult<Parser<IN, OUT>> CheckAlternates(BuildResult<Parser<IN, OUT>
             return result;
         }
 
-        private  BuildResult<Parser<IN, OUT>> CheckVisitorsSignature(BuildResult<Parser<IN, OUT>> result,
+        private BuildResult<Parser<IN, OUT>> CheckVisitorsSignature(BuildResult<Parser<IN, OUT>> result,
             NonTerminal<IN> nonTerminal)
         {
             foreach (var rule in nonTerminal.Rules)
@@ -450,13 +461,13 @@ private  BuildResult<Parser<IN, OUT>> CheckVisitorsSignature(BuildResult<Parser<
                     result = CheckVisitorSignature(result, rule);
                 }
             }
-            
+
             return result;
         }
 
-        
+
         private BuildResult<Parser<IN, OUT>> CheckVisitorSignature(BuildResult<Parser<IN, OUT>> result,
-            Rule<IN> rule) 
+            Rule<IN> rule)
         {
             if (!rule.IsExpressionRule)
             {
@@ -465,27 +476,35 @@ private BuildResult<Parser<IN, OUT>> CheckVisitorSignature(BuildResult<Parser<IN
                 {
                     ;
                 }
+
                 var returnInfo = visitor.ReturnParameter;
                 var expectedReturn = typeof(OUT);
                 var foundReturn = returnInfo.ParameterType;
                 if (!expectedReturn.IsAssignableFrom(foundReturn) && foundReturn != expectedReturn)
                 {
                     result.AddError(new InitializationError(ErrorLevel.FATAL,
-                        I18N.Instance.GetText(I18n,I18NMessage.IncorrectVisitorReturnType,visitor.Name,rule.RuleString,typeof(OUT).FullName,returnInfo.ParameterType.Name),
+                        I18N.Instance.GetText(I18n, I18NMessage.IncorrectVisitorReturnType, visitor.Name,
+                            rule.RuleString, typeof(OUT).FullName, returnInfo.ParameterType.Name),
                         ErrorCodes.PARSER_INCORRECT_VISITOR_RETURN_TYPE));
                 }
 
-                var realClauses = rule.Clauses.Where<IClause<IN>>(x => !(x is TerminalClause<IN> || x is ChoiceClause<IN>) || (x is TerminalClause<IN> t && !t.Discarded) || (x is ChoiceClause<IN> c && !c.IsDiscarded) ).ToList<IClause<IN>>();
+                var realClauses = rule.Clauses.Where<IClause<IN>>(x =>
+                        !(x is TerminalClause<IN> || x is ChoiceClause<IN>) ||
+                        (x is TerminalClause<IN> t && !t.Discarded) || (x is ChoiceClause<IN> c && !c.IsDiscarded))
+                    .ToList<IClause<IN>>();
 
-                if (visitor.GetParameters().Length != realClauses.Count && visitor.GetParameters().Length != realClauses.Count +1)
+                if (visitor.GetParameters().Length != realClauses.Count &&
+                    visitor.GetParameters().Length != realClauses.Count + 1)
                 {
                     result.AddError(new InitializationError(ErrorLevel.FATAL,
-                        I18N.Instance.GetText(I18n,I18NMessage.IncorrectVisitorParameterNumber,visitor.Name,rule.RuleString,realClauses.Count.ToString(),(realClauses.Count+1).ToString(),visitor.GetParameters().Length.ToString()),
+                        I18N.Instance.GetText(I18n, I18NMessage.IncorrectVisitorParameterNumber, visitor.Name,
+                            rule.RuleString, realClauses.Count.ToString(), (realClauses.Count + 1).ToString(),
+                            visitor.GetParameters().Length.ToString()),
                         ErrorCodes.PARSER_INCORRECT_VISITOR_PARAMETER_NUMBER));
                     // do not go further : it will cause an out of bound error.
                     return result;
                 }
-                
+
                 int i = 0;
                 foreach (var clause in realClauses)
                 {
@@ -506,19 +525,20 @@ private BuildResult<Parser<IN, OUT>> CheckVisitorSignature(BuildResult<Parser<IN
                             var found = arg.ParameterType;
                             if (nonTerminal.IsGroup)
                             {
-                                expected = typeof(Group<IN,OUT>);
+                                expected = typeof(Group<IN, OUT>);
                             }
                             else
                             {
                                 expected = typeof(OUT);
                             }
+
                             CheckArgType(result, rule, expected, visitor, arg);
                             break;
                         }
                         case ManyClause<IN> many:
                         {
                             Type expected = null;
-                            Type found =  arg.ParameterType;
+                            Type found = arg.ParameterType;
                             var innerClause = many.Clause;
                             switch (innerClause)
                             {
@@ -555,23 +575,25 @@ private BuildResult<Parser<IN, OUT>> CheckVisitorSignature(BuildResult<Parser<IN
                                     {
                                         expected = typeof(List<OUT>);
                                     }
+
                                     break;
                                 }
                             }
+
                             result = CheckArgType(result, rule, expected, visitor, arg);
                             break;
                         }
                         case GroupClause<IN> group:
                         {
-                            Type expected = typeof(Group<IN,OUT>);
-                            Type found =  arg.ParameterType;
+                            Type expected = typeof(Group<IN, OUT>);
+                            Type found = arg.ParameterType;
                             result = CheckArgType(result, rule, expected, visitor, arg);
                             break;
                         }
                         case OptionClause<IN> option:
                         {
                             Type expected = null;
-                            Type found =  arg.ParameterType;
+                            Type found = arg.ParameterType;
                             var innerClause = option.Clause;
                             switch (innerClause)
                             {
@@ -608,9 +630,11 @@ private BuildResult<Parser<IN, OUT>> CheckVisitorSignature(BuildResult<Parser<IN
                                     {
                                         expected = typeof(ValueOption<OUT>);
                                     }
+
                                     break;
                                 }
                             }
+
                             result = CheckArgType(result, rule, expected, visitor, arg);
                             break;
                         }
@@ -631,10 +655,11 @@ private BuildResult<Parser<IN, OUT>> CheckVisitorSignature(BuildResult<Parser<IN
                     if (!expectedReturn.IsAssignableFrom(foundReturn) && foundReturn != expectedReturn)
                     {
                         result.AddError(new InitializationError(ErrorLevel.FATAL,
-                            I18N.Instance.GetText(I18n,I18NMessage.IncorrectVisitorReturnType,visitor.Name,rule.RuleString,typeof(OUT).FullName,returnInfo.ParameterType.Name),
+                            I18N.Instance.GetText(I18n, I18NMessage.IncorrectVisitorReturnType, visitor.Name,
+                                rule.RuleString, typeof(OUT).FullName, returnInfo.ParameterType.Name),
                             ErrorCodes.PARSER_INCORRECT_VISITOR_RETURN_TYPE));
                     }
-                    
+
                     if (operation.IsUnary)
                     {
                         var parameters = visitor.GetParameters();
@@ -646,6 +671,7 @@ private BuildResult<Parser<IN, OUT>> CheckVisitorSignature(BuildResult<Parser<IN
                             // do not go further : it will cause an out of bound error.
                             return result;
                         }
+
                         if (operation.Affix == Affix.PreFix)
                         {
                             var token = parameters[0];
@@ -666,18 +692,19 @@ private BuildResult<Parser<IN, OUT>> CheckVisitorSignature(BuildResult<Parser<IN
                         var parameters = visitor.GetParameters();
                         if (parameters.Length != 3 && parameters.Length != 4)
                         {
-                            result.AddError(new InitializationError(ErrorLevel.FATAL,$"visitor {visitor.Name} for rule {rule.RuleString} has incorrect argument number : 3 or 4, found {parameters.Length}", ErrorCodes.PARSER_INCORRECT_VISITOR_PARAMETER_NUMBER));
+                            result.AddError(new InitializationError(ErrorLevel.FATAL,
+                                $"visitor {visitor.Name} for rule {rule.RuleString} has incorrect argument number : 3 or 4, found {parameters.Length}",
+                                ErrorCodes.PARSER_INCORRECT_VISITOR_PARAMETER_NUMBER));
                             // do not go further : it will cause an out of bound error.
                             return result;
                         }
 
                         var left = parameters[0];
-                        result = CheckArgType(result, rule, typeof(OUT),  visitor, left);
+                        result = CheckArgType(result, rule, typeof(OUT), visitor, left);
                         var op = parameters[1];
-                        result = CheckArgType(result, rule, typeof(Token<IN>),  visitor, op);
+                        result = CheckArgType(result, rule, typeof(Token<IN>), visitor, op);
                         var right = parameters[2];
-                        result = CheckArgType(result, rule, typeof(OUT),  visitor, right);
-                        
+                        result = CheckArgType(result, rule, typeof(OUT), visitor, right);
                     }
                 }
             }
@@ -685,21 +712,21 @@ private BuildResult<Parser<IN, OUT>> CheckVisitorSignature(BuildResult<Parser<IN
             return result;
         }
 
-        private  BuildResult<Parser<IN, OUT>> CheckArgType(BuildResult<Parser<IN, OUT>> result, Rule<IN> rule, Type expected, MethodInfo visitor,
-            ParameterInfo arg) 
+        private BuildResult<Parser<IN, OUT>> CheckArgType(BuildResult<Parser<IN, OUT>> result, Rule<IN> rule,
+            Type expected, MethodInfo visitor,
+            ParameterInfo arg)
         {
             if (!expected.IsAssignableFrom(arg.ParameterType) && arg.ParameterType != expected)
             {
                 result.AddError(new InitializationError(ErrorLevel.FATAL,
-                    I18N.Instance.GetText(I18n,I18NMessage.IncorrectVisitorParameterType,visitor.Name,rule.RuleString,arg.Name,expected.FullName,arg.ParameterType.FullName),
+                    I18N.Instance.GetText(I18n, I18NMessage.IncorrectVisitorParameterType, visitor.Name,
+                        rule.RuleString, arg.Name, expected.FullName, arg.ParameterType.FullName),
                     ErrorCodes.PARSER_INCORRECT_VISITOR_PARAMETER_TYPE));
             }
 
             return result;
         }
 
-       
-
         #endregion
     }
 }
\ No newline at end of file
diff --git a/sly/sly.csproj b/sly/sly.csproj
index 716e791e..4efc6ecf 100644
--- a/sly/sly.csproj
+++ b/sly/sly.csproj
@@ -6,11 +6,11 @@
     <AllowedOutputExtensionsInPackageBuildOutputFolder>$(AllowedOutputExtensionsInPackageBuildOutputFolder);.pdb</AllowedOutputExtensionsInPackageBuildOutputFolder>
     <Description>#LY is a parser generator halfway between parser combinators and parser generator like ANTLR</Description>
     <Authors>b3b00</Authors>
-    <version>2.9.4.0</version>
+    <version>2.9.4.1</version>
     <PackageProjectUrl>https://github.com/b3b00/sly</PackageProjectUrl>
     <RepositoryUrl>https://github.com/b3b00/sly</RepositoryUrl>
     <License>https://github.com/b3b00/sly/blob/master/LICENSE</License>
-    <PackageVersion>2.9.4.0</PackageVersion>
+    <PackageVersion>2.9.4.1</PackageVersion>
     <ApplicationIcon />
     <OutputType>Library</OutputType>
     <StartupObject />