@tbela99/css-parser 1.1.1 → 1.3.0

package/dist/lib/validation/parser/parse.js

@@ -1,12 +1,12 @@
 import { ValidationTokenEnum } from './types.js';
 import { isIdent, isPseudo } from '../../syntax/syntax.js';
-import { getTokenType as getTokenType$1 } from '../../parser/parse.js';
-import '../../parser/tokenize.js';
-import '../../parser/utils/config.js';
 import { EnumToken } from '../../ast/types.js';
 import '../../ast/minify.js';
 import '../../ast/walk.js';
-import '../../renderer/color/utils/constants.js';
+import { getTokenType as getTokenType$1 } from '../../parser/parse.js';
+import '../../parser/tokenize.js';
+import '../../parser/utils/config.js';
+import '../../syntax/color/utils/constants.js';
 import '../../renderer/sourcemap/lib/encode.js';
 
 const skipped = [
@@ -175,7 +175,6 @@ function parseSyntax(syntax) {
         typ: ValidationTokenEnum.Root,
         chi: []
     }, 'pos', { ...objectProperties, value: { ind: 0, lin: 1, col: 0 } });
-    // return minify(doParseSyntax(syntaxes, tokenize(syntaxes), root)) as ValidationRootToken;
     return minify(doParseSyntax(syntax, tokenize(syntax), root));
 }
 function matchParens(syntax, iterator) {
@@ -351,9 +350,6 @@ function matchAtRule(syntax, iterator) {
                 token.typ = ValidationTokenEnum.AtRule;
                 break;
             }
-            if (item.value.typ != ValidationTokenEnum.Whitespace) {
-                console.error('unexpected token', item.value);
-            }
             item = iterator.next();
             if (item.done) {
                 break;
@@ -665,6 +661,10 @@ function parseSyntaxTokens(syntax, iterator) {
                         }
                     }
                 }
+                if ('occurence' in item.value) {
+                    // @ts-ignore
+                    items[i].occurence = { ...item.value.occurence };
+                }
                 break;
             case ValidationTokenEnum.Pipe:
                 item.value.chi = item.value.chi.map((t) => parseSyntaxTokens(syntax, t[Symbol.iterator]()));
@@ -966,9 +966,6 @@ function renderSyntax(token, parent) {
             return '{' + token.chi.reduce((acc, t) => acc + renderSyntax(t), '') + '}';
         case ValidationTokenEnum.DeclarationDefinitionToken:
             return token.nam + ': ' + renderSyntax(token.val);
-        // case ValidationTokenEnum.ColumnArrayToken:
-        //
-        //     return (token as ValidationColumnArrayToken).chi.reduce((acc: string, curr: ValidationToken) => acc + (acc.trim().length > 0 ? '||' : '') + renderSyntax(curr), '');
         default:
             throw new Error('Unhandled token: ' + JSON.stringify({ token }, null, 1));
     }

package/dist/lib/validation/selector.js

@@ -4,23 +4,15 @@ 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 { validateRelativeSelectorList } from './syntaxes/relative-selector-list.js';
 import './syntaxes/complex-selector.js';
-import { validateKeyframeBlockList } from './syntaxes/keyframe-block-list.js';
 import './syntax.js';
 import './config.js';
 import { validateSelectorList } from './syntaxes/selector-list.js';
 
 function validateSelector(selector, options, root) {
-    if (root == null) {
-        return validateSelectorList(selector, root, options);
-    }
-    // @ts-ignore
-    if (root.typ == EnumToken.AtRuleNodeType && root.nam.match(/^(-[a-z]+-)?keyframes$/)) {
-        return validateKeyframeBlockList(selector);
-    }
     let isNested = root.typ == EnumToken.RuleNodeType ? 1 : 0;
     let currentRoot = root.parent;
     while (currentRoot != null && isNested == 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,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,9 +65,6 @@ function createContext(input) {
             this.index = index;
             return result[this.index] ?? null;
         },
-        tokens() {
-            return result;
-        },
         slice() {
             return result.slice(this.index + 1);
         },
@@ -82,14 +72,6 @@ function createContext(input) {
             const context = createContext(result.slice());
             context.index = this.index;
             return context;
-        },
-        // @ts-ignore
-        toJSON() {
-            return {
-                index: this.index,
-                slice: this.slice(),
-                tokens: this.tokens()
-            };
         }
     };
 }
@@ -123,10 +105,7 @@ function evaluateSyntax(node, options) {
                 result = doEvaluateSyntax(ast, createContext(values), { ...options, visited: new WeakMap() });
                 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) {
                         return {
                             ...result,
                             valid: SyntaxValidationResult.Drop,
@@ -142,13 +121,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,
@@ -178,7 +150,18 @@ function doEvaluateSyntax(syntaxes, context, options) {
     let syntax;
     let i = 0;
     let result;
+    let tmpResult;
     let token = null;
+    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
+        };
+    }
     for (; i < syntaxes.length; i++) {
         syntax = syntaxes[i];
         if (context.done()) {
@@ -188,6 +171,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' === token.val?.toLowerCase?.()) {
+            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();
@@ -198,7 +185,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);
@@ -252,9 +245,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
     };
 }
@@ -277,7 +270,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();
@@ -286,15 +279,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 list: ${renderSyntax(syntax)}`,
-                context
-            };
-        }
         result = doEvaluateSyntax([syntax], createContext(tokens), {
             ...options,
             isList: false,
@@ -315,7 +299,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;
@@ -323,7 +307,7 @@ function matchList(syntax, context, options) {
     }
     return {
         valid: success ? SyntaxValidationResult.Valid : SyntaxValidationResult.Drop,
-        node: context.current(),
+        node: context.peek(),
         syntax,
         error: '',
         context
@@ -348,7 +332,7 @@ 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
@@ -372,26 +356,13 @@ 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 (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,
@@ -409,7 +380,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) {
@@ -427,7 +398,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(),
@@ -451,37 +422,12 @@ 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.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.Separator:
             {
                 const token = context.peek();
@@ -496,21 +442,15 @@ 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.toLowerCase() === token.val?.toLowerCase?.() && doEvaluateSyntax(syntax.chi, createContext(token.chi), options).valid == SyntaxValidationResult.Valid;
                 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,
@@ -522,7 +462,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;
@@ -539,7 +478,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 */]) {
@@ -633,7 +574,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;
                 }
@@ -683,14 +624,14 @@ 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 && 'currentcolor' === token.val.toLowerCase()) || (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 && '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,
@@ -702,10 +643,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];
             }
@@ -731,31 +672,31 @@ 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;
             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');
             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;
@@ -775,9 +716,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 &&
@@ -813,9 +751,6 @@ 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();
-        }
         result = doEvaluateSyntax(syntaxes[i], context.clone(), options);
         if (result.valid == SyntaxValidationResult.Valid) {
             success = true;
@@ -831,9 +766,9 @@ function someOf(syntaxes, context, options) {
     }
     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
     };
 }
@@ -855,9 +790,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
     };
 }
@@ -884,9 +819,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 == '/')) {
@@ -903,18 +835,16 @@ 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 });
                 if (result.valid == SyntaxValidationResult.Valid) {
                     let end = slice.indexOf(cp.current());
                     if (end == -1) {
@@ -929,9 +859,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;
             }
@@ -944,12 +873,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,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);
@@ -31,14 +21,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 };

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

@@ -6,7 +6,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 { validateCompoundSelector } from './compound-selector.js';