@tbela99/css-parser 1.1.1-alpha4 → 1.2.0

package/dist/lib/validation/syntax.js

@@ -1,6 +1,6 @@
 import { ValidationTokenEnum } from './parser/types.js';
 import { renderSyntax } from './parser/parse.js';
-import { EnumToken, SyntaxValidationResult } from '../ast/types.js';
+import { EnumToken, SyntaxValidationResult, ColorType } from '../ast/types.js';
 import '../ast/minify.js';
 import '../ast/walk.js';
 import '../parser/parse.js';
@@ -8,7 +8,7 @@ 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, ColorKind, colorsFunc } from '../renderer/color/utils/constants.js';
+import { funcLike, colorsFunc } from '../syntax/color/utils/constants.js';
 import { getSyntaxConfig, getParsedSyntax, getSyntax } from './config.js';
 import './syntaxes/complex-selector.js';
 
@@ -17,12 +17,12 @@ const config = getSyntaxConfig();
 const allValues = getSyntaxConfig()["declarations" /* ValidationSyntaxGroupEnum.Declarations */].all.syntax.trim().split(/[\s|]+/g);
 function createContext(input) {
     const values = input.slice();
-    const result = values.slice();
-    if (result.at(-1)?.typ == EnumToken.WhitespaceTokenType) {
-        result.pop();
-    }
+    const result = values.filter(token => token.typ != EnumToken.CommentTokenType).slice();
     return {
         index: -1,
+        get length() {
+            return this.index < 0 ? result.length : this.index > result.length ? 0 : result.length - this.index;
+        },
         peek() {
             let index = this.index + 1;
             if (index >= result.length) {
@@ -42,15 +42,15 @@ function createContext(input) {
         },
         consume(token, howMany) {
             let newIndex = result.indexOf(token, this.index + 1);
-            if (newIndex == -1 || newIndex < this.index) {
-                return false;
-            }
+            // if (newIndex == -1 || newIndex < this.index) {
+            //     return false;
+            // }
             howMany ??= 0;
             let splice = 1;
-            if (result[newIndex - 1]?.typ == EnumToken.WhitespaceTokenType) {
-                splice++;
-                newIndex--;
-            }
+            // 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,9 +72,10 @@ function createContext(input) {
             this.index = index;
             return result[this.index] ?? null;
         },
-        tokens() {
-            return result;
-        },
+        // tokens<Token>(): Token[] {
+        //
+        //     return result as Token[];
+        // },
         slice() {
             return result.slice(this.index + 1);
         },
@@ -84,13 +85,14 @@ function createContext(input) {
             return context;
         },
         // @ts-ignore
-        toJSON() {
-            return {
-                index: this.index,
-                slice: this.slice(),
-                tokens: this.tokens()
-            };
-        }
+        // toJSON(): object {
+        //
+        //     return {
+        //         index: this.index,
+        //         slice: this.slice(),
+        //         tokens: this.tokens()
+        //     }
+        // }
     };
 }
 function evaluateSyntax(node, options) {
@@ -102,7 +104,6 @@ function evaluateSyntax(node, options) {
                 break;
             }
             ast = getParsedSyntax("declarations" /* ValidationSyntaxGroupEnum.Declarations */, node.nam);
-            // console.error({ast: ast.reduce((acc, curr) => acc + renderSyntax(curr), '')});
             if (ast != null) {
                 let token = null;
                 const values = node.val.slice();
@@ -122,13 +123,13 @@ function evaluateSyntax(node, options) {
                     }
                 }
                 result = doEvaluateSyntax(ast, createContext(values), { ...options, visited: new WeakMap() });
-                // console.error(JSON.stringify({ast, values, result}, null, 1));
                 if (result.valid == SyntaxValidationResult.Valid && !result.context.done()) {
                     let token = null;
-                    while ((token = result.context.next()) != null) {
-                        if (token.typ == EnumToken.WhitespaceTokenType || token.typ == EnumToken.CommentTokenType) {
-                            continue;
-                        }
+                    if ((token = result.context.next()) != null) {
+                        // if (token.typ == EnumToken.WhitespaceTokenType || token.typ == EnumToken.CommentTokenType) {
+                        //
+                        //     continue;
+                        // }
                         return {
                             ...result,
                             valid: SyntaxValidationResult.Drop,
@@ -144,10 +145,10 @@ function evaluateSyntax(node, options) {
                 };
             }
             break;
-        case EnumToken.RuleNodeType:
-        case EnumToken.AtRuleNodeType:
-        case EnumToken.KeyframeAtRuleNodeType:
-        case EnumToken.KeyFrameRuleNodeType:
+        // case EnumToken.RuleNodeType:
+        // case EnumToken.AtRuleNodeType:
+        // case EnumToken.KeyframeAtRuleNodeType:
+        // case EnumToken.KeyFrameRuleNodeType:
         // default:
         //
         //     throw new Error(`Not implemented: ${node.typ}`);
@@ -180,8 +181,20 @@ function doEvaluateSyntax(syntaxes, context, options) {
     let syntax;
     let i = 0;
     let result;
+    let tmpResult;
     let token = null;
-    // console.error(`>> doEvaluateSyntax: ${syntaxes.reduce((acc, curr) => acc + renderSyntax(curr), '')}\n>> ${JSON.stringify({syntaxes}, null, 1)}>> context: ${context.slice<Token>().reduce((acc, curr) => acc + renderToken(curr), '')}`);
+    if (context.done()) {
+        const success = syntaxes.some(s => s.isOptional || s.isRepeatable || s.isRepeatableGroup);
+        return {
+            valid: success ? SyntaxValidationResult.Valid : SyntaxValidationResult.Drop,
+            node: null,
+            syntax: null,
+            error: '',
+            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()) {
@@ -191,6 +204,10 @@ function doEvaluateSyntax(syntaxes, context, options) {
             break;
         }
         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) {
+            return doEvaluateSyntax(getParsedSyntax("functions" /* ValidationSyntaxGroupEnum.Functions */, 'var')?.[0]?.chi ?? [], createContext(token.chi), options);
+        }
         if (syntax.typ == ValidationTokenEnum.Whitespace) {
             if (context.peek()?.typ == EnumToken.WhitespaceTokenType) {
                 context.next();
@@ -201,7 +218,13 @@ function doEvaluateSyntax(syntaxes, context, options) {
             result = matchList(syntax, context, options);
         }
         else if (options.isRepeatable !== false && syntax.isRepeatable) {
-            result = matchRepeatable(syntax, context, options);
+            tmpResult = matchRepeatable(syntax, context, options);
+            if (tmpResult.valid == SyntaxValidationResult.Valid) {
+                result = tmpResult;
+            }
+            else {
+                continue;
+            }
         }
         else if (options.occurence !== false && syntax.occurence != null) {
             result = matchOccurence(syntax, context, options);
@@ -211,7 +234,6 @@ function doEvaluateSyntax(syntaxes, context, options) {
         }
         else {
             if (isVisited(token, syntax, 'doEvaluateSyntax', options)) {
-                // console.error(`cyclic dependency: ${renderSyntax(syntax)}`);
                 return {
                     valid: SyntaxValidationResult.Drop,
                     node: token,
@@ -256,9 +278,9 @@ function matchAtLeastOnce(syntax, context, options) {
     }
     return {
         valid: success ? SyntaxValidationResult.Valid : SyntaxValidationResult.Drop,
-        node: context.current(),
+        node: context.peek(),
         syntax,
-        error: success ? '' : `could not match atLeastOnce: ${renderSyntax(syntax)}`,
+        error: success ? '' : `could not match syntax: ${renderSyntax(syntax)}`,
         context
     };
 }
@@ -281,7 +303,7 @@ function matchRepeatable(syntax, context, options) {
     };
 }
 function matchList(syntax, context, options) {
-    let success = false;
+    let success;
     let result;
     let count = 0;
     let con = context.clone();
@@ -290,15 +312,16 @@ 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 list: ${renderSyntax(syntax)}`,
-                context
-            };
-        }
+        // 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,
@@ -319,7 +342,7 @@ function matchList(syntax, context, options) {
         }
     }
     success = count > 0;
-    if (count && syntax.occurence != null) {
+    if (success && syntax.occurence != null) {
         success = count >= syntax.occurence.min;
         if (success && syntax.occurence.max != null) {
             success = count <= syntax.occurence.max;
@@ -327,7 +350,7 @@ function matchList(syntax, context, options) {
     }
     return {
         valid: success ? SyntaxValidationResult.Valid : SyntaxValidationResult.Drop,
-        node: context.current(),
+        node: context.peek(),
         syntax,
         error: '',
         context
@@ -352,14 +375,13 @@ function matchOccurence(syntax, context, options) {
     }
     return {
         valid: sucesss ? SyntaxValidationResult.Valid : SyntaxValidationResult.Drop,
-        node: context.current(),
+        node: context.peek(),
         syntax,
         error: sucesss ? '' : `expected ${renderSyntax(syntax)} ${syntax.occurence.min} to ${syntax.occurence.max} occurences, got ${counter}`,
         context
     };
 }
 function match(syntax, context, options) {
-    // console.error(`>> match(): ${renderSyntax(syntax)}\n>> ${JSON.stringify({syntax}, null, 1)}>> context: ${context.slice<Token>().reduce((acc, curr) => acc + renderToken(curr), '')}`);
     let success = false;
     let result;
     let token = context.peek();
@@ -377,26 +399,29 @@ function match(syntax, context, options) {
             }
             return {
                 valid: SyntaxValidationResult.Drop,
-                node: context.current(),
+                node: context.peek(),
                 syntax,
                 error: `expected '${ValidationTokenEnum[syntax.typ].toLowerCase()}', got '${context.done() ? null : renderToken(context.peek())}'`,
                 context
             };
         }
     }
-    if (token.typ == EnumToken.WhitespaceTokenType) {
-        context.next();
-        // @ts-ignore
-        if (syntax?.typ == ValidationTokenEnum.Whitespace) {
-            return {
-                valid: SyntaxValidationResult.Valid,
-                node: null,
-                syntax,
-                error: '',
-                context
-            };
-        }
-    }
+    // 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,
@@ -432,7 +457,7 @@ function match(syntax, context, options) {
             return matchPropertyType(syntax, context, options);
         case ValidationTokenEnum.ValidationFunctionDefinition:
             token = context.peek();
-            if (token.typ == EnumToken.ParensTokenType || !funcLike.concat(EnumToken.ColorTokenType) || (!('chi' in token))) {
+            if (token.typ == EnumToken.ParensTokenType || !funcLike.concat(EnumToken.ColorTokenType).includes(token.typ) || (!('chi' in token))) {
                 return {
                     valid: SyntaxValidationResult.Drop,
                     node: context.next(),
@@ -441,17 +466,13 @@ function match(syntax, context, options) {
                     context
                 };
             }
-            // {
-            // console.error(JSON.stringify({funcDef: (getParsedSyntax(ValidationSyntaxGroupEnum.Syntaxes, (syntax as ValidationFunctionDefinitionToken).val + '()')?.[0] as ValidationFunctionToken).chi}, null, 1))
-            //
-            // const child = getParsedSyntax(ValidationSyntaxGroupEnum.Syntaxes, (syntax as ValidationFunctionDefinitionToken).val + '()')?.[0] as ValidationFunctionToken;
             result = match(getParsedSyntax("syntaxes" /* ValidationSyntaxGroupEnum.Syntaxes */, syntax.val + '()')?.[0], context, options);
+            // console.error(`>>[]
             if (result.valid == SyntaxValidationResult.Valid) {
                 context.next();
                 result.context = context;
                 return result;
             }
-            // }
             break;
         case ValidationTokenEnum.DeclarationType:
             return doEvaluateSyntax(getParsedSyntax("declarations" /* ValidationSyntaxGroupEnum.Declarations */, syntax.val), context, {
@@ -461,37 +482,49 @@ function match(syntax, context, options) {
                 occurence: null,
                 atLeastOnce: null
             });
-        case ValidationTokenEnum.Parens:
-            token = context.peek();
-            if (token.typ != EnumToken.ParensTokenType) {
-                break;
-            }
-            success = doEvaluateSyntax(syntax.chi, createContext(token.chi), {
-                ...options,
-                isRepeatable: null,
-                isList: null,
-                occurence: null,
-                atLeastOnce: null
-            }).valid == SyntaxValidationResult.Valid;
-            break;
+        // 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()?.typ == EnumToken.NumberTokenType;
-            if (success) {
-                context.next();
-            }
-            break;
-        case ValidationTokenEnum.Whitespace:
-            success = context.peek()?.typ == EnumToken.WhitespaceTokenType;
-            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();
@@ -506,21 +539,22 @@ function match(syntax, context, options) {
             if (!wildCardFuncs.includes(syntax.val) && syntax.val != token.val) {
                 break;
             }
-            if (token.typ != EnumToken.ParensTokenType && funcLike.includes(token.typ)) {
-                success = doEvaluateSyntax(syntax.chi, createContext(token.chi), {
-                    ...options,
-                    isRepeatable: null,
-                    isList: null,
-                    occurence: null,
-                    atLeastOnce: null
-                }).valid == SyntaxValidationResult.Valid;
+            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)}`);
                 if (success) {
                     context.next();
                 }
                 break;
             }
-            if (syntax.typ == ValidationTokenEnum.Function) {
-                success = funcLike.includes(token.typ) && doEvaluateSyntax(getParsedSyntax("syntaxes" /* ValidationSyntaxGroupEnum.Syntaxes */, syntax.val + '()')?.[0]?.chi, createContext(token.chi), {
+            if (token.typ != EnumToken.ParensTokenType && funcLike.includes(token.typ)) {
+                success = doEvaluateSyntax(syntax.chi, createContext(token.chi), {
                     ...options,
                     isRepeatable: null,
                     isList: null,
@@ -549,7 +583,9 @@ function match(syntax, context, options) {
 function matchPropertyType(syntax, context, options) {
     if (![
         'bg-position',
-        'length-percentage', 'flex', 'calc-sum', 'color', 'color-base', 'system-color', 'deprecated-system-color',
+        'integer',
+        'length-percentage', 'flex', 'calc-sum', 'color',
+        'color-base', 'system-color', 'deprecated-system-color',
         'pseudo-class-selector', 'pseudo-element-selector'
     ].includes(syntax.val)) {
         if (syntax.val in config["syntaxes" /* ValidationSyntaxGroupEnum.Syntaxes */]) {
@@ -611,7 +647,7 @@ function matchPropertyType(syntax, context, options) {
                             valid: SyntaxValidationResult.Drop,
                             node: token,
                             syntax,
-                            error: `expected <length>`,
+                            error: `expected <length-percentage>`,
                             context
                         };
                     }
@@ -693,10 +729,10 @@ function matchPropertyType(syntax, context, options) {
             success = token.typ == EnumToken.DashedIdenTokenType;
             break;
         case 'system-color':
-            success = (token.typ == EnumToken.ColorTokenType && token.kin == ColorKind.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 && token.val.localeCompare('currentcolor', 'en', { sensitivity: 'base' }) == 0) || (token.typ == EnumToken.FunctionTokenType && wildCardFuncs.includes(token.val));
             break;
         case 'deprecated-system-color':
-            success = (token.typ == EnumToken.ColorTokenType && token.kin == ColorKind.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 && token.val.localeCompare('currentcolor', 'en', { sensitivity: 'base' }) == 0) || (token.typ == EnumToken.FunctionTokenType && wildCardFuncs.includes(token.val));
             break;
         case 'color':
         case 'color-base':
@@ -712,10 +748,10 @@ function matchPropertyType(syntax, context, options) {
             }
             break;
         case 'hex-color':
-            success = (token.typ == EnumToken.ColorTokenType && token.kin == ColorKind.HEX) || (token.typ == EnumToken.FunctionTokenType && wildCardFuncs.includes(token.val));
+            success = (token.typ == EnumToken.ColorTokenType && token.kin == ColorType.HEX) || (token.typ == EnumToken.FunctionTokenType && wildCardFuncs.includes(token.val));
             break;
         case 'integer':
-            success = (token.typ == EnumToken.NumberTokenType && Number.isInteger(+(token.val))) || (token.typ == EnumToken.FunctionTokenType && token.val == 'calc');
+            success = (token.typ == EnumToken.NumberTokenType && Number.isInteger(+(token.val))) || (token.typ == EnumToken.FunctionTokenType && mathFuncs.includes(token.val.toLowerCase()) || (token.typ == EnumToken.FunctionTokenType && wildCardFuncs.includes(token.val)));
             if ('range' in syntax) {
                 success = success && +token.val >= +syntax.range[0] && +token.val <= +syntax.range[1];
             }
@@ -759,7 +795,7 @@ function matchPropertyType(syntax, context, options) {
             success = token.typ == EnumToken.HashTokenType;
             break;
         case 'string':
-            success = token.typ == EnumToken.StringTokenType || token.typ == EnumToken.IdenTokenType || (token.typ == EnumToken.FunctionTokenType && wildCardFuncs.includes(token.val));
+            success = token.typ == EnumToken.StringTokenType || token.typ == EnumToken.UrlTokenTokenType || token.typ == EnumToken.HashTokenType || token.typ == EnumToken.IdenTokenType || (token.typ == EnumToken.FunctionTokenType && wildCardFuncs.includes(token.val));
             break;
         case 'time':
             success = token.typ == EnumToken.TimeTokenType || (token.typ == EnumToken.FunctionTokenType && token.val == 'calc');
@@ -794,7 +830,6 @@ function matchPropertyType(syntax, context, options) {
         ['length-percentage', 'length', 'number', 'number-token', 'angle', 'percentage', 'dimension'].includes(syntax.val)) {
         if (!success) {
             success = mathFuncs.includes(token.val.toLowerCase()) &&
-                // (token as FunctionToken).val + '()' in config[ValidationSyntaxGroupEnum.Syntaxes] &&
                 doEvaluateSyntax(getParsedSyntax("syntaxes" /* ValidationSyntaxGroupEnum.Syntaxes */, token.val + '()')?.[0]?.chi ?? [], createContext(token.chi), {
                     ...options,
                     isRepeatable: null,
@@ -824,10 +859,12 @@ function someOf(syntaxes, context, options) {
     let success = false;
     const matched = [];
     for (i = 0; i < syntaxes.length; i++) {
-        if (context.peek()?.typ == EnumToken.WhitespaceTokenType) {
-            context.next();
-        }
+        // 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()) {
@@ -840,11 +877,13 @@ 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.current(),
+        node: context.peek(),
         syntax: null,
-        error: success ? '' : `could not match someOf: ${syntaxes.reduce((acc, curr) => acc + (acc.length > 0 ? ' | ' : '') + curr.reduce((acc, curr) => acc + renderSyntax(curr), ''), '')}`,
+        error: success ? '' : `could not match syntax: ${syntaxes.reduce((acc, curr) => acc + (acc.length > 0 ? ' | ' : '') + curr.reduce((acc, curr) => acc + renderSyntax(curr), ''), '')}`,
         context
     };
 }
@@ -866,9 +905,9 @@ function anyOf(syntaxes, context, options) {
     }
     return {
         valid: success ? SyntaxValidationResult.Valid : SyntaxValidationResult.Drop,
-        node: context.current(),
+        node: context.peek(),
         syntax: null,
-        error: success ? '' : `could not match anyOf: ${syntaxes.reduce((acc, curr) => acc + '[' + curr.reduce((acc, curr) => acc + renderSyntax(curr), '') + ']', '')}`,
+        error: success ? '' : `could not match syntax: ${syntaxes.reduce((acc, curr) => acc + '[' + curr.reduce((acc, curr) => acc + renderSyntax(curr), '') + ']', '')}`,
         context
     };
 }
@@ -895,9 +934,10 @@ 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]);
-            }
+            // 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 == '/')) {
@@ -914,18 +954,17 @@ function allOf(syntax, context, options) {
     let j;
     for (i = 0; i < syntax.length; i++) {
         if (syntax[i].length == 1 && syntax[i][0].isOptional) {
-            syntax[i][0].isOptional = false;
             j = 0;
             cp = con.clone();
             slice = cp.slice();
             if (cp.done()) {
-                syntax[i][0].isOptional = true;
                 syntax.splice(i, 1);
                 i = -1;
                 continue;
             }
             while (!cp.done()) {
-                result = doEvaluateSyntax(syntax[i], cp.clone(), options);
+                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) {
@@ -940,9 +979,8 @@ function allOf(syntax, context, options) {
                 cp.next();
                 j++;
             }
-            syntax[i][0].isOptional = true;
             // @ts-ignore
-            if (result?.valid == SyntaxValidationResult.Valid) {
+            if (result?.valid == SyntaxValidationResult.Valid || (syntax[i].length == 1 && syntax[i][0].isOptional)) {
                 syntax.splice(i, 1);
                 i = -1;
             }
@@ -955,12 +993,13 @@ function allOf(syntax, context, options) {
             i = -1;
         }
     }
+    // console.error()
     const success = syntax.length == 0;
     return {
         valid: success ? SyntaxValidationResult.Valid : SyntaxValidationResult.Drop,
-        node: context.current(),
+        node: context.peek(),
         syntax: syntax?.[0]?.[0] ?? null,
-        error: `could not match allOf: ${syntax.reduce((acc, curr) => acc + '[' + curr.reduce((acc, curr) => acc + renderSyntax(curr), '') + ']', '')}`,
+        error: `could not match syntax: ${syntax.reduce((acc, curr) => acc + '[' + curr.reduce((acc, curr) => acc + renderSyntax(curr), '') + ']', '')}`,
         context: success ? con : context
     };
 }

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

@@ -4,7 +4,7 @@ import '../../ast/walk.js';
 import '../../parser/parse.js';
 import '../../parser/tokenize.js';
 import '../../parser/utils/config.js';
-import '../../renderer/color/utils/constants.js';
+import '../../syntax/color/utils/constants.js';
 import '../../renderer/sourcemap/lib/encode.js';
 import { validateSelector } from './selector.js';
 import { consumeWhitespace } from '../utils/whitespace.js';
@@ -13,16 +13,17 @@ 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'
-        };
-    }
+    // 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);
@@ -31,14 +32,7 @@ function validateComplexSelectorList(tokens, root, options) {
         }
     }
     // @ts-ignore
-    return result ?? {
-        valid: SyntaxValidationResult.Drop,
-        context: [],
-        // @ts-ignore
-        node: root,
-        syntax: null,
-        error: 'expecting complex selector list'
-    };
+    return result;
 }
 
 export { validateComplexSelectorList };