@tbela99/css-parser 1.2.0 → 1.3.1

package/dist/lib/validation/syntax.js

@@ -8,9 +8,11 @@ import '../parser/tokenize.js';
 import '../parser/utils/config.js';
 import { wildCardFuncs, isIdentColor, mathFuncs } from '../syntax/syntax.js';
 import { renderToken } from '../renderer/render.js';
-import { funcLike, colorsFunc } from '../syntax/color/utils/constants.js';
+import '../renderer/sourcemap/lib/encode.js';
 import { getSyntaxConfig, getParsedSyntax, getSyntax } from './config.js';
 import './syntaxes/complex-selector.js';
+import { funcLike, colorsFunc } from '../syntax/color/utils/constants.js';
+import '../ast/features/type.js';
 
 const config = getSyntaxConfig();
 // @ts-ignore
@@ -42,15 +44,8 @@ function createContext(input) {
         },
         consume(token, howMany) {
             let newIndex = result.indexOf(token, this.index + 1);
-            // if (newIndex == -1 || newIndex < this.index) {
-            //     return false;
-            // }
             howMany ??= 0;
             let splice = 1;
-            // if (result[newIndex - 1]?.typ == EnumToken.WhitespaceTokenType) {
-            //     splice++;
-            //     newIndex--;
-            // }
             result.splice(this.index + 1, 0, ...result.splice(newIndex, splice + howMany));
             this.index += howMany + splice;
             return true;
@@ -72,10 +67,6 @@ function createContext(input) {
             this.index = index;
             return result[this.index] ?? null;
         },
-        // tokens<Token>(): Token[] {
-        //
-        //     return result as Token[];
-        // },
         slice() {
             return result.slice(this.index + 1);
         },
@@ -83,16 +74,7 @@ function createContext(input) {
             const context = createContext(result.slice());
             context.index = this.index;
             return context;
-        },
-        // @ts-ignore
-        // toJSON(): object {
-        //
-        //     return {
-        //         index: this.index,
-        //         slice: this.slice(),
-        //         tokens: this.tokens()
-        //     }
-        // }
+        }
     };
 }
 function evaluateSyntax(node, options) {
@@ -126,10 +108,6 @@ function evaluateSyntax(node, options) {
                 if (result.valid == SyntaxValidationResult.Valid && !result.context.done()) {
                     let token = null;
                     if ((token = result.context.next()) != null) {
-                        // if (token.typ == EnumToken.WhitespaceTokenType || token.typ == EnumToken.CommentTokenType) {
-                        //
-                        //     continue;
-                        // }
                         return {
                             ...result,
                             valid: SyntaxValidationResult.Drop,
@@ -145,13 +123,6 @@ function evaluateSyntax(node, options) {
                 };
             }
             break;
-        // case EnumToken.RuleNodeType:
-        // case EnumToken.AtRuleNodeType:
-        // case EnumToken.KeyframeAtRuleNodeType:
-        // case EnumToken.KeyFrameRuleNodeType:
-        // default:
-        //
-        //     throw new Error(`Not implemented: ${node.typ}`);
     }
     return {
         valid: SyntaxValidationResult.Valid,
@@ -193,8 +164,6 @@ function doEvaluateSyntax(syntaxes, context, options) {
             context
         };
     }
-    // console.error(`>> ${syntaxes.reduce((acc, curr) => acc + renderSyntax(curr), '')}\n>> ${context.slice<Token>().reduce((acc, curr) => acc + renderToken(curr), '')}`);
-    // console.error(new Error('doEvaluateSyntax'));
     for (; i < syntaxes.length; i++) {
         syntax = syntaxes[i];
         if (context.done()) {
@@ -205,7 +174,7 @@ function doEvaluateSyntax(syntaxes, context, options) {
         }
         token = context.peek();
         // if var() is the last token, then match the remaining syntax and return
-        if (context.length == 1 && token.typ == EnumToken.FunctionTokenType && 'var'.localeCompare(token.val, undefined, { sensitivity: 'base' }) == 0) {
+        if (context.length == 1 && token.typ == EnumToken.FunctionTokenType && 'var' === token.val?.toLowerCase?.()) {
             return doEvaluateSyntax(getParsedSyntax("functions" /* ValidationSyntaxGroupEnum.Functions */, 'var')?.[0]?.chi ?? [], createContext(token.chi), options);
         }
         if (syntax.typ == ValidationTokenEnum.Whitespace) {
@@ -312,16 +281,6 @@ function matchList(syntax, context, options) {
         while (!con.done() && con.peek()?.typ != EnumToken.CommaTokenType) {
             tokens.push(con.next());
         }
-        // if (tokens.length == 0) {
-        //
-        //     return {
-        //         valid: SyntaxValidationResult.Drop,
-        //         node: context.peek(),
-        //         syntax,
-        //         error: `could not match syntax: ${renderSyntax(syntax)}`,
-        //         context
-        //     }
-        // }
         result = doEvaluateSyntax([syntax], createContext(tokens), {
             ...options,
             isList: false,
@@ -406,22 +365,6 @@ function match(syntax, context, options) {
             };
         }
     }
-    // if (token.typ == EnumToken.WhitespaceTokenType) {
-    //
-    //     context.next();
-    //
-    //     // @ts-ignore
-    //     if (syntax?.typ == ValidationTokenEnum.Whitespace) {
-    //
-    //         return {
-    //             valid: SyntaxValidationResult.Valid,
-    //             node: null,
-    //             syntax,
-    //             error: '',
-    //             context
-    //         }
-    //     }
-    // }
     if (syntax.typ != ValidationTokenEnum.PropertyType && (token?.typ == EnumToken.FunctionTokenType && wildCardFuncs.includes(token.val))) {
         const result = doEvaluateSyntax(getParsedSyntax("functions" /* ValidationSyntaxGroupEnum.Functions */, token.val)?.[0]?.chi ?? [], createContext(token.chi), {
             ...options,
@@ -439,7 +382,7 @@ function match(syntax, context, options) {
         case ValidationTokenEnum.Keyword:
             success = (token.typ == EnumToken.IdenTokenType || token.typ == EnumToken.DashedIdenTokenType || isIdentColor(token)) &&
                 (token.val == syntax.val ||
-                    syntax.val.localeCompare(token.val, undefined, { sensitivity: 'base' }) == 0 ||
+                    syntax.val === token.val?.toLowerCase?.() ||
                     // config.declarations.all
                     allValues.includes(token.val.toLowerCase()));
             if (success) {
@@ -467,7 +410,6 @@ function match(syntax, context, options) {
                 };
             }
             result = match(getParsedSyntax("syntaxes" /* ValidationSyntaxGroupEnum.Syntaxes */, syntax.val + '()')?.[0], context, options);
-            // console.error(`>>[]
             if (result.valid == SyntaxValidationResult.Valid) {
                 context.next();
                 result.context = context;
@@ -482,49 +424,12 @@ function match(syntax, context, options) {
                 occurence: null,
                 atLeastOnce: null
             });
-        // case ValidationTokenEnum.Parens:
-        //
-        //     token = context.peek() as Token;
-        //     if (token.typ != EnumToken.ParensTokenType) {
-        //
-        //         break;
-        //     }
-        //
-        //     success = doEvaluateSyntax((syntax as ValidationParensToken).chi as ValidationToken[], createContext((token as ParensToken).chi), {
-        //         ...options,
-        //         isRepeatable: null,
-        //         isList: null,
-        //         occurence: null,
-        //         atLeastOnce: null
-        //     } as ValidationOptions).valid == SyntaxValidationResult.Valid;
-        //     break;
         case ValidationTokenEnum.Comma:
             success = context.peek()?.typ == EnumToken.CommaTokenType;
             if (success) {
                 context.next();
             }
             break;
-        // case ValidationTokenEnum.Number:
-        //
-        //     success = context.peek<Token>()?.typ == EnumToken.NumberTokenType;
-        //
-        //     if (success) {
-        //
-        //         context.next();
-        //     }
-        //
-        //     break;
-        //
-        // case ValidationTokenEnum.Whitespace:
-        //
-        //     success = context.peek<Token>()?.typ == EnumToken.WhitespaceTokenType;
-        //
-        //     if (success) {
-        //
-        //         context.next();
-        //     }
-        //
-        //     break;
         case ValidationTokenEnum.Separator:
             {
                 const token = context.peek();
@@ -540,14 +445,7 @@ function match(syntax, context, options) {
                 break;
             }
             if (syntax.typ == ValidationTokenEnum.Function) {
-                success = funcLike.includes(token.typ) && syntax.val.localeCompare(token.val, undefined, { sensitivity: 'base' }) == 0 && doEvaluateSyntax(syntax.chi, createContext(token.chi), options).valid == SyntaxValidationResult.Valid;
-                // console.error(`>> match: ${JSON.stringify({
-                //     syntax,
-                //     token,
-                //     // result,
-                //     tr2: syntax,
-                //     success
-                // }, null, 1)}`);
+                success = funcLike.includes(token.typ) && syntax.val.toLowerCase() === token.val?.toLowerCase?.() && doEvaluateSyntax(syntax.chi, createContext(token.chi), options).valid == SyntaxValidationResult.Valid;
                 if (success) {
                     context.next();
                 }
@@ -566,7 +464,6 @@ function match(syntax, context, options) {
                 }
                 break;
             }
-        // throw new Error(`Not implemented: ${ValidationTokenEnum[syntax.typ] ?? syntax.typ} : ${renderSyntax(syntax)} : ${renderToken(context.peek() as Token)} : ${JSON.stringify(syntax, null, 1)} | ${JSON.stringify(context.peek(), null, 1)}`);
     }
     if (!success && token.typ == EnumToken.IdenTokenType && allValues.includes(token.val.toLowerCase())) {
         success = true;
@@ -679,7 +576,7 @@ function matchPropertyType(syntax, context, options) {
                     token = context.peek();
                     continue;
                 }
-                success = token.typ == EnumToken.LengthTokenType || token.typ == EnumToken.PercentageTokenType || (token.typ == EnumToken.NumberTokenType && token.val == '0');
+                success = token.typ == EnumToken.LengthTokenType || token.typ == EnumToken.PercentageTokenType || (token.typ == EnumToken.NumberTokenType && token.val == 0);
                 if (!success) {
                     break;
                 }
@@ -729,14 +626,14 @@ function matchPropertyType(syntax, context, options) {
             success = token.typ == EnumToken.DashedIdenTokenType;
             break;
         case 'system-color':
-            success = (token.typ == EnumToken.ColorTokenType && token.kin == ColorType.SYS) || (token.typ == EnumToken.IdenTokenType && token.val.localeCompare('currentcolor', 'en', { sensitivity: 'base' }) == 0) || (token.typ == EnumToken.FunctionTokenType && wildCardFuncs.includes(token.val));
+            success = (token.typ == EnumToken.ColorTokenType && token.kin == ColorType.SYS) || (token.typ == EnumToken.IdenTokenType && 'currentcolor' === token.val.toLowerCase()) || (token.typ == EnumToken.FunctionTokenType && wildCardFuncs.includes(token.val));
             break;
         case 'deprecated-system-color':
-            success = (token.typ == EnumToken.ColorTokenType && token.kin == ColorType.DPSYS) || (token.typ == EnumToken.IdenTokenType && token.val.localeCompare('currentcolor', 'en', { sensitivity: 'base' }) == 0) || (token.typ == EnumToken.FunctionTokenType && wildCardFuncs.includes(token.val));
+            success = (token.typ == EnumToken.ColorTokenType && token.kin == ColorType.DPSYS) || (token.typ == EnumToken.IdenTokenType && 'currentcolor' === token.val.toLowerCase()) || (token.typ == EnumToken.FunctionTokenType && wildCardFuncs.includes(token.val));
             break;
         case 'color':
         case 'color-base':
-            success = token.typ == EnumToken.ColorTokenType || (token.typ == EnumToken.IdenTokenType && token.val.localeCompare('currentcolor', 'en', { sensitivity: 'base' }) == 0) || (token.typ == EnumToken.IdenTokenType && token.val.localeCompare('transparent', 'en', { sensitivity: 'base' }) == 0) || (token.typ == EnumToken.FunctionTokenType && wildCardFuncs.includes(token.val));
+            success = token.typ == EnumToken.ColorTokenType || (token.typ == EnumToken.IdenTokenType && 'currentcolor' === token.val.toLowerCase()) || (token.typ == EnumToken.IdenTokenType && 'transparent' === token.val.toLowerCase()) || (token.typ == EnumToken.FunctionTokenType && wildCardFuncs.includes(token.val));
             if (!success && token.typ == EnumToken.FunctionTokenType && colorsFunc.includes(token.val)) {
                 success = doEvaluateSyntax(getParsedSyntax("functions" /* ValidationSyntaxGroupEnum.Functions */, token.val)?.[0]?.chi, createContext(token.chi), {
                     ...options,
@@ -777,19 +674,19 @@ function matchPropertyType(syntax, context, options) {
             }
             break;
         case 'angle':
-            success = token.typ == EnumToken.AngleTokenType || (token.typ == EnumToken.NumberTokenType && token.val == '0') || (token.typ == EnumToken.FunctionTokenType && token.val == 'calc');
+            success = token.typ == EnumToken.AngleTokenType || (token.typ == EnumToken.NumberTokenType && token.val == 0) || (token.typ == EnumToken.FunctionTokenType && token.val == 'calc');
             break;
         case 'length':
-            success = token.typ == EnumToken.LengthTokenType || (token.typ == EnumToken.NumberTokenType && token.val == '0') || (token.typ == EnumToken.FunctionTokenType && token.val == 'calc');
+            success = token.typ == EnumToken.LengthTokenType || (token.typ == EnumToken.NumberTokenType && token.val == 0) || (token.typ == EnumToken.FunctionTokenType && token.val == 'calc');
             break;
         case 'percentage':
-            success = token.typ == EnumToken.PercentageTokenType || (token.typ == EnumToken.NumberTokenType && token.val == '0') || (token.typ == EnumToken.FunctionTokenType && token.val == 'calc');
+            success = token.typ == EnumToken.PercentageTokenType || (token.typ == EnumToken.NumberTokenType && token.val == 0) || (token.typ == EnumToken.FunctionTokenType && token.val == 'calc');
             break;
         case 'length-percentage':
-            success = token.typ == EnumToken.LengthTokenType || token.typ == EnumToken.PercentageTokenType || (token.typ == EnumToken.NumberTokenType && token.val == '0') || (token.typ == EnumToken.FunctionTokenType && token.val == 'calc');
+            success = token.typ == EnumToken.LengthTokenType || token.typ == EnumToken.PercentageTokenType || (token.typ == EnumToken.NumberTokenType && token.val == 0) || (token.typ == EnumToken.FunctionTokenType && token.val == 'calc');
             break;
         case 'resolution':
-            success = token.typ == EnumToken.ResolutionTokenType || token.typ == EnumToken.PercentageTokenType || (token.typ == EnumToken.NumberTokenType && token.val == '0') || (token.typ == EnumToken.FunctionTokenType && token.val == 'calc');
+            success = token.typ == EnumToken.ResolutionTokenType || token.typ == EnumToken.PercentageTokenType || (token.typ == EnumToken.NumberTokenType && token.val == 0) || (token.typ == EnumToken.FunctionTokenType && token.val == 'calc');
             break;
         case 'hash-token':
             success = token.typ == EnumToken.HashTokenType;
@@ -801,7 +698,7 @@ function matchPropertyType(syntax, context, options) {
             success = token.typ == EnumToken.TimeTokenType || (token.typ == EnumToken.FunctionTokenType && token.val == 'calc');
             break;
         case 'zero':
-            success = token.val == '0' || (token.typ == EnumToken.FunctionTokenType && token.val == 'calc');
+            success = token.val == 0 || (token.typ == EnumToken.FunctionTokenType && token.val == 'calc');
             break;
         case 'pseudo-element-selector':
             success = token.typ == EnumToken.PseudoElementTokenType;
@@ -821,9 +718,6 @@ function matchPropertyType(syntax, context, options) {
                 }
             }
             break;
-        // default:
-        //
-        //     throw new Error(`Not implemented: ${ValidationTokenEnum[syntax.typ] ?? syntax.typ} : ${renderSyntax(syntax)}\n${JSON.stringify(syntax, null, 1)}`);
     }
     if (!success &&
         token.typ == EnumToken.FunctionTokenType &&
@@ -859,12 +753,7 @@ function someOf(syntaxes, context, options) {
     let success = false;
     const matched = [];
     for (i = 0; i < syntaxes.length; i++) {
-        // if (context.peek<Token>()?.typ == EnumToken.WhitespaceTokenType) {
-        //
-        //     context.next();
-        // }
         result = doEvaluateSyntax(syntaxes[i], context.clone(), options);
-        // console.error(`>> someOf: ${JSON.stringify({result}, null, 1)}`);
         if (result.valid == SyntaxValidationResult.Valid) {
             success = true;
             if (result.context.done()) {
@@ -877,8 +766,6 @@ function someOf(syntaxes, context, options) {
         // pick the best match
         matched.sort((a, b) => a.context.done() ? -1 : b.context.done() ? 1 : b.context.index - a.context.index);
     }
-    // console.error(JSON.stringify({matched}, null, 1));
-    // console.error(new Error('someOf'));
     return matched[0] ?? {
         valid: SyntaxValidationResult.Drop,
         node: context.peek(),
@@ -934,10 +821,6 @@ function allOf(syntax, context, options) {
     for (i = 0; i < slice.length; i++) {
         if (slice[i].typ == EnumToken.FunctionTokenType && wildCardFuncs.includes(slice[i].val.toLowerCase())) {
             vars.push(slice[i]);
-            // if (slice[i + 1]?.typ == EnumToken.WhitespaceTokenType) {
-            //
-            //     vars.push(slice[++i]);
-            // }
             continue;
         }
         if (slice[i].typ == EnumToken.CommaTokenType || (slice[i].typ == EnumToken.LiteralTokenType && slice[i].val == '/')) {
@@ -964,7 +847,6 @@ function allOf(syntax, context, options) {
             }
             while (!cp.done()) {
                 result = doEvaluateSyntax(syntax[i], cp.clone(), { ...options, isOptional: false });
-                // console.error(`>> allOf: syntaxes[${i}]: ${syntax[i].length} ${syntax[i].reduce((acc, curr) => acc + renderSyntax(curr), '')}\n>> ${cp.slice<Token>().reduce((acc, curr) => acc + renderToken(curr), '')}\n>> ${JSON.stringify({result}, null, 1)}`);
                 if (result.valid == SyntaxValidationResult.Valid) {
                     let end = slice.indexOf(cp.current());
                     if (end == -1) {

package/dist/lib/validation/syntaxes/complex-selector-list.js

@@ -13,17 +13,6 @@ import { splitTokenList } from '../utils/list.js';
 function validateComplexSelectorList(tokens, root, options) {
     tokens = tokens.slice();
     consumeWhitespace(tokens);
-    // if (tokens.length == 0) {
-    //
-    //     return {
-    //         valid: SyntaxValidationResult.Drop,
-    //         context: [],
-    //         // @ts-ignore
-    //         node: root,
-    //         syntax: null,
-    //         error: 'expecting complex selector list'
-    //     }
-    // }
     let result = null;
     for (const t of splitTokenList(tokens)) {
         result = validateSelector(t, root, options);

package/dist/lib/validation/syntaxes/family-name.js

@@ -12,18 +12,6 @@ function validateFamilyName(tokens, atRule) {
     let node;
     tokens = tokens.slice();
     consumeWhitespace(tokens);
-    // if (tokens.length == 0) {
-    //
-    //     // @ts-ignore
-    //     return {
-    //         valid: SyntaxValidationResult.Drop,
-    //         matches: [],
-    //         node: atRule,
-    //         syntax: null,
-    //         error: 'expected at-rule prelude',
-    //         tokens
-    //     } as ValidationSyntaxResult;
-    // }
     if (tokens.length == 0 || tokens[0].typ == EnumToken.CommaTokenType) {
         // @ts-ignore
         return {
@@ -36,26 +24,6 @@ function validateFamilyName(tokens, atRule) {
         };
     }
     while (tokens.length > 0) {
-        // @ts-ignore
-        // if (tokens[0].typ == EnumToken.CommaTokenType) {
-        //
-        //     node = tokens.shift() as Token;
-        //
-        //     consumeWhitespace(tokens);
-        //
-        //     if (tokens.length == 0) {
-        //
-        //         // @ts-ignore
-        //         return {
-        //             valid: SyntaxValidationResult.Drop,
-        //             matches: [],
-        //             node,
-        //             syntax: null,
-        //             error: 'unexpected token',
-        //             tokens
-        //         } as ValidationSyntaxResult;
-        //     }
-        // }
         node = tokens[0];
         if (![EnumToken.IdenTokenType, EnumToken.StringTokenType].includes(node.typ)) {
             // @ts-ignore

package/dist/lib/validation/syntaxes/keyframe-selector.js

@@ -11,17 +11,6 @@ import '../../renderer/sourcemap/lib/encode.js';
 
 function validateKeyframeSelector(tokens, options) {
     consumeWhitespace(tokens);
-    // if (tokens.length == 0) {
-    //
-    //     // @ts-ignore
-    //     return {
-    //         valid: SyntaxValidationResult.Drop,
-    //         context: [],
-    //         node: null,
-    //         syntax: null,
-    //         error: 'expected keyframe selector'
-    //     }
-    // }
     for (const t of splitTokenList(tokens)) {
         if (t.length != 1 || (t[0].typ != EnumToken.PercentageTokenType && !(t[0].typ == EnumToken.IdenTokenType && ['from', 'to', 'cover', 'contain', 'entry', 'exit', 'entry-crossing', 'exit-crossing'].includes(t[0].val)))) {
             return {

package/dist/lib/validation/syntaxes/relative-selector-list.js

@@ -13,33 +13,7 @@ import { splitTokenList } from '../utils/list.js';
 function validateRelativeSelectorList(tokens, root, options) {
     tokens = tokens.slice();
     consumeWhitespace(tokens);
-    // if (tokens.length == 0) {
-    //
-    //     return {
-    //         valid: SyntaxValidationResult.Drop,
-    //         matches: [],
-    //         // @ts-ignore
-    //         node: root,
-    //         // @ts-ignore
-    //         syntax: null,
-    //         error: 'expecting relative selector list',
-    //         tokens
-    //     }
-    // }
     for (const t of splitTokenList(tokens)) {
-        // if (t.length == 0) {
-        //
-        //     return {
-        //         valid: SyntaxValidationResult.Drop,
-        //         matches: [],
-        //         // @ts-ignore
-        //         node: root,
-        //         // @ts-ignore
-        //         syntax: null,
-        //         error: 'unexpected comma',
-        //         tokens
-        //     }
-        // }
         const result = validateRelativeSelector(t, root, options);
         if (result.valid == SyntaxValidationResult.Drop) {
             return result;

package/dist/lib/validation/syntaxes/url.js

@@ -9,43 +9,10 @@ import '../../renderer/sourcemap/lib/encode.js';
 import { consumeWhitespace } from '../utils/whitespace.js';
 
 function validateURL(token) {
-    // if (token.typ == EnumToken.UrlTokenTokenType) {
-    //
-    //     // @ts-ignore
-    //     return {
-    //         valid: SyntaxValidationResult.Valid,
-    //         context: [],
-    //         node: token,
-    //         // @ts-ignore
-    //         syntax: 'url()',
-    //         error: ''
-    //     }
-    // }
-    // if (token.typ != EnumToken.UrlFunctionTokenType) {
-    //
-    //     // @ts-ignore
-    //     return {
-    //         valid: SyntaxValidationResult.Drop,
-    //         context: [],
-    //         node: token,
-    //         // @ts-ignore
-    //         syntax: 'url()',
-    //         error: 'expected url()'
-    //     }
-    // }
     const children = token.chi.slice();
     consumeWhitespace(children);
     if (children.length > 0 && [EnumToken.UrlTokenTokenType, EnumToken.StringTokenType, EnumToken.HashTokenType].includes(children[0].typ)) {
         children.shift();
-        // @ts-ignore
-        // return {
-        //     valid: SyntaxValidationResult.Drop,
-        //     context: [],
-        //     node: children[0] ?? token,
-        //     // @ts-ignore
-        //     syntax: 'url()',
-        //     error: 'expected url-token'
-        // }
     }
     consumeWhitespace(children);
     if (children.length > 0) {

package/dist/lib/validation/utils/list.js

@@ -10,10 +10,6 @@ import '../../renderer/sourcemap/lib/encode.js';
 function stripCommaToken(tokenList) {
     let result = [];
     for (let i = 0; i < tokenList.length; i++) {
-        // if (tokenList[i].typ == EnumToken.CommaTokenType && last != null && last.typ == EnumToken.CommaTokenType) {
-        //
-        //     return null;
-        // }
         if (tokenList[i].typ != EnumToken.WhitespaceTokenType) {
             tokenList[i];
         }
@@ -26,10 +22,6 @@ function stripCommaToken(tokenList) {
 }
 function splitTokenList(tokenList, split = [EnumToken.CommaTokenType]) {
     return tokenList.reduce((acc, curr) => {
-        // if (curr.typ == EnumToken.CommentTokenType) {
-        //
-        //     return acc;
-        // }
         if (split.includes(curr.typ)) {
             acc.push([]);
         }