@tbela99/css-parser 0.9.1 → 1.1.0

package/dist/lib/validation/syntax.js

@@ -1,1509 +1,828 @@
-import { ValidationTokenEnum, specialValues } from './parser/types.js';
+import { ValidationTokenEnum } from './parser/types.js';
 import { renderSyntax } from './parser/parse.js';
-import { ValidationLevel, EnumToken, funcLike } from '../ast/types.js';
+import { EnumToken, SyntaxValidationResult } from '../ast/types.js';
 import '../ast/minify.js';
 import '../ast/walk.js';
 import '../parser/parse.js';
-import { isLength } from '../syntax/syntax.js';
+import '../parser/tokenize.js';
 import '../parser/utils/config.js';
+import { wildCardFuncs, isIdentColor, mathFuncs } from '../syntax/syntax.js';
 import { renderToken } from '../renderer/render.js';
-import { getSyntaxConfig, getParsedSyntax } from './config.js';
-import { validateSelector } from './selector.js';
+import { funcLike, ColorKind, colorsFunc } from '../renderer/color/utils/constants.js';
+import { getSyntaxConfig, getParsedSyntax, getSyntax } from './config.js';
 import './syntaxes/complex-selector.js';
-import { validateImage } from './syntaxes/image.js';
 
 const config = getSyntaxConfig();
-function consumeToken(tokens) {
-    tokens.shift();
-}
-function consumeSyntax(syntaxes) {
-    syntaxes.shift();
-}
-function splice(tokens, matches) {
-    if (matches.length == 0) {
-        return tokens;
-    }
-    // @ts-ignore
-    const index = tokens.indexOf(matches.at(-1));
-    if (index > -1) {
-        tokens.splice(0, index + 1);
-    }
-    return tokens;
-}
-function validateSyntax(syntaxes, tokens, root, options, context = { level: 0 }) {
-    console.error(JSON.stringify({
-        syntax: syntaxes?.reduce?.((acc, curr) => acc + renderSyntax(curr), ''),
-        // syntaxes,
-        tokens: tokens.reduce((acc, curr) => acc + renderToken(curr), ''),
-        s: new Error('bar').stack
-    }, null, 1));
-    if (syntaxes == null) {
-        // @ts-ignore
-        return {
-            valid: ValidationLevel.Drop,
-            matches: [],
-            node: tokens[0] ?? null,
-            syntax: null,
-            error: 'no matching syntaxes found',
-            tokens
-        };
-    }
-    let token = null;
-    let syntax;
-    let result = null;
-    let validSyntax = false;
-    let matched = false;
-    const matches = [];
-    tokens = tokens.slice();
-    syntaxes = syntaxes.slice();
-    tokens = tokens.slice();
-    if (context.cache == null) {
-        context.cache = new WeakMap;
-    }
-    if (context.tokens == null) {
-        context.tokens = tokens.slice();
+// @ts-ignore
+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();
     }
-    context = { ...context };
-    main: while (tokens.length > 0) {
-        if (syntaxes.length == 0) {
-            break;
-        }
-        token = tokens[0];
-        syntax = syntaxes[0];
-        // @ts-ignore
-        context.position = context.tokens.indexOf(token);
-        const cached = context.cache.get(token)?.get(syntax.text) ?? null;
-        if (cached != null) {
-            if (cached.error.length > 0) {
-                return { ...cached, tokens, node: cached.valid == ValidationLevel.Valid ? null : token };
-            }
-            syntaxes.shift();
-            tokens.shift();
-            continue;
-        }
-        if (token.typ == EnumToken.DescendantCombinatorTokenType) {
-            tokens.shift();
-            if (syntax.typ == ValidationTokenEnum.Whitespace) {
-                syntaxes.shift();
-            }
-            continue;
-        }
-        else if (syntax.typ == ValidationTokenEnum.Whitespace) {
-            syntaxes.shift();
-            if (token.typ == EnumToken.WhitespaceTokenType) {
-                tokens.shift();
-            }
-            continue;
-        }
-        else if (syntax.typ == ValidationTokenEnum.Block && EnumToken.AtRuleTokenType == token.typ && ('chi' in token)) {
-            syntaxes.shift();
-            tokens.shift();
+    return {
+        index: -1,
+        peek() {
+            let index = this.index + 1;
+            if (index >= result.length) {
+                return null;
+            }
+            if (result[index]?.typ == EnumToken.WhitespaceTokenType) {
+                index++;
+            }
+            return result[index] ?? null;
+        },
+        update(context) {
             // @ts-ignore
-            matches.push(token);
-            continue;
+            const newIndex = result.indexOf(context.current());
+            if (newIndex != -1) {
+                // console.error({newIndex, v: result[newIndex]});
+                // console.error(new Error('update'))
+                this.index = newIndex;
+            }
+        },
+        done() {
+            return this.index + 1 >= result.length;
+        },
+        current() {
+            return result[this.index] ?? null;
+        },
+        next() {
+            let index = this.index + 1;
+            if (index >= result.length) {
+                return null;
+            }
+            if (result[index]?.typ == EnumToken.WhitespaceTokenType) {
+                index++;
+            }
+            this.index = index;
+            return result[this.index] ?? null;
+        },
+        tokens() {
+            return result;
+        },
+        slice() {
+            return result.slice(this.index + 1);
+        },
+        clone() {
+            const context = createContext(input.slice());
+            context.index = this.index;
+            return context;
         }
-        if (syntax.isOptional) {
-            if (!context.cache.has(token)) {
-                context.cache.set(token, new Map);
-            }
-            if (context.cache.get(token).has(syntax.text)) {
-                result = context.cache.get(token).get(syntax.text);
-                return { ...result, tokens, node: result.valid == ValidationLevel.Valid ? null : token };
-            }
-            // @ts-ignore
-            const { isOptional, ...c } = syntax;
-            // @ts-ignore
-            let result2;
-            // @ts-ignore
-            result2 = validateSyntax([c], tokens, root, options, context);
-            if (result2.valid == ValidationLevel.Valid && result2.matches.length > 0) {
-                tokens = result2.tokens;
-                // splice(tokens, result2.matches);
-                // tokens = result2.tokens;
-                // @ts-ignore
-                matches.push(...result2.matches);
-                matched = true;
-                result = result2;
-            }
-            else {
-                syntaxes.shift();
-                continue;
-            }
-            syntaxes.shift();
-            if (syntaxes.length == 0) {
-                // @ts-ignore
-                return {
-                    valid: ValidationLevel.Valid,
-                    matches: result2.matches,
-                    node: result2.node,
-                    syntax: result2.syntax,
-                    error: result2.error,
-                    tokens
-                };
+    };
+}
+function evaluateSyntax(node, options, parent) {
+    let ast;
+    let result;
+    switch (node.typ) {
+        case EnumToken.DeclarationNodeType:
+            if (node.nam.startsWith('--')) {
+                break;
             }
-            continue;
-        }
-        if (syntax.isList) {
-            let index = -1;
-            // @ts-ignore
-            let { isList, ...c } = syntax;
-            // const c: ValidationToken = {...syntaxes, isList: false} as ValidationToken;
-            let result2 = null;
-            validSyntax = false;
-            do {
-                for (let i = index + 1; i < tokens.length; i++) {
-                    if (tokens[i].typ == EnumToken.CommaTokenType) {
-                        index = i;
+            ast = getParsedSyntax("declarations" /* ValidationSyntaxGroupEnum.Declarations */, node.nam);
+            if (ast != null) {
+                let token = null;
+                const values = node.val.slice();
+                while (values.length > 0) {
+                    token = values.at(-1);
+                    if (token.typ == EnumToken.WhitespaceTokenType || token.typ == EnumToken.CommentTokenType) {
+                        values.pop();
+                    }
+                    else {
+                        if (token.typ == EnumToken.ImportantTokenType) {
+                            values.pop();
+                            if (values.at(-1)?.typ == EnumToken.WhitespaceTokenType) {
+                                values.pop();
+                            }
+                        }
                         break;
                     }
                 }
-                if (tokens[index + 1]?.typ == EnumToken.CommaTokenType) {
-                    return {
-                        valid: ValidationLevel.Drop,
-                        matches,
-                        node: tokens[0],
-                        syntax,
-                        error: 'unexpected token',
-                        tokens
-                    };
-                }
-                if (index == -1) {
-                    index = tokens.length;
-                }
-                if (index == 0) {
-                    break;
-                }
-                // @ts-ignore
-                result2 = validateSyntax([c], tokens.slice(0, index), root, options, context);
-                matched = result2.valid == ValidationLevel.Valid && result2.matches.length > 0;
-                if (matched) {
-                    const l = tokens.length;
-                    validSyntax = true;
-                    // @ts-ignore
-                    // matches.push(...result2.matches);
-                    // splice(tokens, result2.matches);
-                    if (tokens.length == 1 && tokens[0].typ == EnumToken.CommaTokenType) {
+                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;
+                        }
                         return {
-                            valid: ValidationLevel.Drop,
-                            matches,
-                            node: tokens[0],
-                            syntax,
-                            error: 'unexpected token',
-                            tokens
+                            ...result,
+                            valid: SyntaxValidationResult.Drop,
+                            node: token,
+                            syntax: getSyntax("declarations" /* ValidationSyntaxGroupEnum.Declarations */, node.nam),
+                            error: `unexpected token: '${renderToken(token)}'`,
                         };
                     }
-                    tokens = tokens.slice(index);
-                    result = result2;
-                    // @ts-ignore
-                    matches.push(...result2.matches);
-                    if (result.tokens.length > 0) {
-                        if (index == -1) {
-                            tokens = result.tokens;
-                        }
-                        else {
-                            tokens = tokens.slice(index - result.tokens.length);
-                        }
-                    }
-                    else if (index > 0) {
-                        tokens = tokens.slice(index);
-                    }
-                    index = -1;
-                    if (l == tokens.length) {
-                        break;
-                    }
-                }
-                else {
-                    break;
                 }
-            } while (tokens.length > 0);
-            // if (level == 0) {
-            // }
-            if (!matched) {
                 return {
-                    valid: ValidationLevel.Drop,
-                    // @ts-ignore
-                    matches: [...new Set(matches)],
-                    node: token,
-                    syntax,
-                    error: 'unexpected token',
-                    tokens
+                    ...result,
+                    syntax: getSyntax("declarations" /* ValidationSyntaxGroupEnum.Declarations */, node.nam)
                 };
             }
-            syntaxes.shift();
-            continue;
+            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,
+        node,
+        syntax: null,
+        error: ''
+    };
+}
+function clearVisited(token, syntax, key, options) {
+    options.visited.get(token)?.get?.(key)?.delete(syntax);
+}
+function isVisited(token, syntax, key, options) {
+    if (options.visited.get(token)?.get?.(key)?.has(syntax)) {
+        return true;
+    }
+    if (!options.visited.has(token)) {
+        options.visited.set(token, new Map());
+    }
+    if (!options.visited.get(token).has(key)) {
+        options.visited.get(token).set(key, new Set());
+    }
+    options.visited.get(token).get(key).add(syntax);
+    return false;
+}
+// https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_Values_and_Units/Value_definition_syntax
+function doEvaluateSyntax(syntaxes, context, options) {
+    let syntax;
+    let i = 0;
+    let result;
+    let token = null;
+    for (; i < syntaxes.length; i++) {
+        syntax = syntaxes[i];
+        if (context.done()) {
+            if (syntax.typ == ValidationTokenEnum.Whitespace || syntax.isOptional || syntax.isRepeatable) {
+                continue;
+            }
+            break;
         }
-        if (syntax.isRepeatable) {
-            // @ts-ignore
-            let { isRepeatable, ...c } = syntax;
-            let result2 = null;
-            validSyntax = false;
-            let l = tokens.length;
-            let tok = null;
-            do {
-                // @ts-ignore
-                result2 = validateSyntax([c], tokens, root, options, context);
-                if (result2.matches.length == 0 && result2.error.length > 0) {
-                    syntaxes.shift();
-                    break main;
-                }
-                if (result2.valid == ValidationLevel.Valid) {
-                    tokens = result2.tokens;
-                    // @ts-ignore
-                    matches.push(...result2.matches);
-                    result = result2;
-                    if (l == tokens.length) {
-                        if (tok == tokens[0]) {
-                            break;
-                        }
-                        if (result2.matches.length == 0 && tokens.length > 0) {
-                            tokens = result2.tokens;
-                            tok = tokens[0];
-                            continue;
-                        }
-                        break;
-                    }
-                    if (matches.length == 0) {
-                        tokens = result2.tokens;
-                    }
-                    l = tokens.length;
-                    continue;
-                }
-                break;
-            } while (result2.valid == ValidationLevel.Valid && tokens.length > 0);
-            // if (lastResult != null) {
-            //
-            //     splice(tokens, lastResult.matches);
-            //     // tokens = lastResult.tokens;
-            // }
-            syntaxes.shift();
+        token = context.peek();
+        if (syntax.typ == ValidationTokenEnum.Whitespace) {
+            if (context.peek()?.typ == EnumToken.WhitespaceTokenType) {
+                context.next();
+            }
             continue;
         }
-        // at least one match
-        if (syntax.isRepeatableGroup) {
-            validSyntax = false;
-            let count = 0;
-            let l = tokens.length;
-            let result2 = null;
-            do {
-                // @ts-ignore
-                const { isRepeatableGroup, ...c } = syntax;
-                // @ts-ignore
-                result2 = validateSyntax([c], tokens, root, options, context);
-                if (result2.valid == ValidationLevel.Drop || result2.matches.length == 0) {
-                    if (count > 0) {
-                        syntaxes.shift();
-                        // if (result2.matches.length == 0) {
-                        tokens = result2.tokens;
-                        // break main;
-                        if (syntaxes.length == 0) {
-                            return result2;
-                        }
-                        break main;
-                    }
-                    return result2;
-                }
-                if (result2.valid == ValidationLevel.Valid && result2.matches.length > 0) {
-                    count++;
-                    // lastResult = result;
-                    validSyntax = true;
-                    tokens = result2.tokens;
-                    // splice(tokens, result2.matches);
-                    // tokens = result2.tokens;
-                    // @ts-ignore
-                    matches.push(...result2.matches);
-                    result = result2;
-                    if (l == tokens.length) {
-                        break;
-                    }
-                    l = tokens.length;
-                }
-                else {
-                    break;
-                }
-            } while (tokens.length > 0 && result.valid == ValidationLevel.Valid);
-            // if (lastResult != null) {
-            //
-            //     splice(tokens, lastResult.matches);
-            //     // tokens = lastResult.tokens;
-            // }
-            // at least one match is expected
-            if (!validSyntax /* || result.matches.length == 0 */) {
-                // @ts-ignore
+        else if (options.isList !== false && syntax.isList) {
+            result = matchList(syntax, context, options);
+        }
+        else if (options.isRepeatable !== false && syntax.isRepeatable) {
+            result = matchRepeatable(syntax, context, options);
+        }
+        else if (options.occurence !== false && syntax.occurence != null) {
+            result = matchOccurence(syntax, context, options);
+        }
+        else if (options.atLeastOnce !== false && syntax.atLeastOnce) {
+            result = matchAtLeastOnce(syntax, context, options);
+        }
+        else {
+            if (isVisited(token, syntax, 'doEvaluateSyntax', options)) {
                 return {
-                    valid: ValidationLevel.Drop,
+                    valid: SyntaxValidationResult.Drop,
                     node: token,
-                    tokens,
                     syntax,
-                    error: 'unexpected token',
-                    matches: []
+                    error: `cyclic dependency: ${renderSyntax(syntax)}`,
+                    context
                 };
             }
-            syntaxes.shift();
-            continue;
-        }
-        if (syntax.atLeastOnce) {
-            const { atLeastOnce, ...c } = syntax;
-            result = validateSyntax([c], tokens, root, options, context);
-            if (result.valid == ValidationLevel.Drop) {
-                return result;
-            }
-            splice(tokens, result.matches);
-            // tokens = result.tokens;
-            // @ts-ignore
-            matches.push(...result.matches);
-            let l = tokens.length;
-            let r = validateSyntax([c], tokens, root, options, context);
-            while (r.valid == ValidationLevel.Valid) {
-                splice(tokens, r.matches);
-                // tokens = r.tokens;
-                r = validateSyntax([c], tokens, root, options, context);
-                if (l == tokens.length) {
-                    break;
-                }
-                if (r.valid == ValidationLevel.Valid && r.matches.length > 0) {
-                    // @ts-ignore
-                    matches.push(...result.matches);
-                }
-                l = tokens.length;
+            result = match(syntax, context, options);
+            if (result.valid == SyntaxValidationResult.Valid) {
+                clearVisited(token, syntax, 'doEvaluateSyntax', options);
             }
-            syntaxes.shift();
-            continue;
         }
-        // @ts-ignore
-        if (syntax.occurence != null) {
-            // @ts-ignore
-            const { occurence, ...c } = syntax;
-            // && syntaxes.occurence.max != null
-            // consume all tokens
-            let match = 1;
-            // @ts-ignore
-            result = validateSyntax([c], tokens, root, options, context);
-            if (result.valid == ValidationLevel.Drop) {
-                return result;
-            }
-            if (result.matches.length == 0) {
-                syntaxes.shift();
+        if (result.valid == SyntaxValidationResult.Drop) {
+            if (syntax.isOptional) {
                 continue;
             }
-            // splice(tokens, result.matches);
-            // tokens = result.tokens;
-            // @ts-ignore
-            matches.push(...result.matches);
-            matched = true;
-            tokens = result.tokens;
-            while (occurence.max == null || match < occurence.max) {
-                // trim whitespace
-                if (tokens[0]?.typ == EnumToken.WhitespaceTokenType) {
-                    tokens.shift();
-                }
-                // @ts-ignore
-                let r = validateSyntax([c], tokens, root, options, context);
-                if (r.valid != ValidationLevel.Valid || r.matches.length == 0) {
-                    break;
-                }
-                result = r;
-                // splice(tokens, r.matches);
-                // tokens = r.tokens;
-                // @ts-ignore
-                matches.push(...result.matches);
-                match++;
-                tokens = r.tokens;
-                result = r;
-                if (tokens.length == 0 || (occurence.max != null && match >= occurence.max)) {
-                    break;
-                }
-                // @ts-ignore
-                // r = validateSyntax([c], tokens, root, options, context);
-            }
-            syntaxes.shift();
+            return result;
+        }
+        context.update(result.context);
+    }
+    return {
+        valid: SyntaxValidationResult.Valid,
+        node: null,
+        syntax: syntaxes[i - 1],
+        error: '',
+        context
+    };
+}
+function matchAtLeastOnce(syntax, context, options) {
+    let success = false;
+    let result;
+    while (!context.done()) {
+        result = match(syntax, context.clone(), { ...options, atLeastOnce: false });
+        if (result.valid == SyntaxValidationResult.Valid) {
+            success = true;
+            context.update(result.context);
             continue;
         }
-        // @ts-ignore
-        if (syntax.typ == ValidationTokenEnum.Whitespace) {
-            if (token.typ == EnumToken.WhitespaceTokenType) {
-                tokens.shift();
-            }
-            syntaxes.shift();
+        break;
+    }
+    return {
+        valid: success ? SyntaxValidationResult.Valid : SyntaxValidationResult.Drop,
+        node: context.current(),
+        syntax,
+        error: success ? '' : `could not match atLeastOnce: ${renderSyntax(syntax)}`,
+        context
+    };
+}
+function matchRepeatable(syntax, context, options) {
+    let result;
+    while (!context.done()) {
+        result = match(syntax, context.clone(), { ...options, isRepeatable: false });
+        if (result.valid == SyntaxValidationResult.Valid) {
+            context.update(result.context);
             continue;
         }
-        // @ts-ignore
-        if (token.val != null && specialValues.includes(token.val)) {
-            matched = true;
-            result = {
-                valid: ValidationLevel.Valid,
-                matches: [token],
-                node: null,
+        break;
+    }
+    return {
+        valid: SyntaxValidationResult.Valid,
+        node: null,
+        syntax,
+        error: '',
+        context
+    };
+}
+function matchList(syntax, context, options) {
+    let success = false;
+    let result;
+    let count = 0;
+    let con = context.clone();
+    let tokens = [];
+    while (!con.done()) {
+        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: '',
-                tokens
+                error: `could not match list: ${renderSyntax(syntax)}`,
+                context
             };
-            // @ts-ignore
-            matches.push(...result.matches);
         }
-        else {
-            result = doValidateSyntax(syntax, token, tokens, root, options, context);
-            matched = result.valid == ValidationLevel.Valid && result.matches.length > 0;
-            if (matched) {
-                // splice(tokens, result.matches);
-                tokens = result.tokens;
-                // @ts-ignore
-                matches.push(...result.matches);
+        result = doEvaluateSyntax([syntax], createContext(tokens), {
+            ...options,
+            isList: false,
+            occurence: false
+        });
+        if (result.valid == SyntaxValidationResult.Valid) {
+            context = con.clone();
+            count++;
+            // pop comma
+            if (con.done() || con.peek()?.typ != EnumToken.CommaTokenType) {
+                break;
             }
+            con.next();
+            tokens.length = 0;
         }
-        if (result.valid == ValidationLevel.Drop) {
-            // @ts-ignore
-            return { ...result, matches, tokens, node: result.valid == ValidationLevel.Valid ? null : token };
-        }
-        consumeSyntax(syntaxes);
-        if (tokens.length == 0) {
-            return result;
+        else {
+            break;
         }
     }
-    if (result?.valid == ValidationLevel.Valid) {
-        // splice(tokens, result.matches);
-        tokens = result.tokens;
-        // @ts-ignore
-        matches.push(...result.matches);
-    }
-    if ( /* result == null && */tokens.length == 0 && syntaxes.length > 0) {
-        validSyntax = isOptionalSyntax(syntaxes);
-    }
-    if (result == null) {
-        result = {
-            valid: validSyntax ? ValidationLevel.Valid : ValidationLevel.Drop,
-            matches,
-            node: validSyntax ? null : tokens[0] ?? null,
-            // @ts-ignore
-            syntax,
-            error: validSyntax ? '' : 'unexpected token',
-            tokens
-        };
-    }
-    if (token != null) {
-        if (!context.cache.has(token)) {
-            context.cache.set(token, new Map);
+    success = count > 0;
+    if (count && syntax.occurence != null) {
+        success = count >= syntax.occurence.min;
+        if (success && syntax.occurence.max != null) {
+            success = count <= syntax.occurence.max;
         }
-        context.cache.get(token).set(syntax.text, result);
-    }
-    if (result != null) {
-        // @ts-ignore
-        return { ...result, matches: [...(new Set(matches))] };
     }
-    return result;
-}
-function isOptionalSyntax(syntaxes) {
-    return syntaxes.length > 0 && syntaxes.every(t => t.typ == ValidationTokenEnum.Whitespace || t.isOptional || t.isRepeatable || (t.typ == ValidationTokenEnum.PropertyType && isOptionalSyntax(getParsedSyntax("syntaxes" /* ValidationSyntaxGroupEnum.Syntaxes */, t.val) ?? getParsedSyntax("declarations" /* ValidationSyntaxGroupEnum.Declarations */, t.val) ?? [])));
+    return {
+        valid: success ? SyntaxValidationResult.Valid : SyntaxValidationResult.Drop,
+        node: context.current(),
+        syntax,
+        error: '',
+        context
+    };
 }
-function doValidateSyntax(syntax, token, tokens, root, options, context) {
-    let valid = false;
+function matchOccurence(syntax, context, options) {
+    let counter = 0;
     let result;
-    let children;
-    let queue;
-    let matches;
-    let child;
-    let astNodes = new Set;
-    if (token.typ == EnumToken.NestingSelectorTokenType && syntax.typ == 2) {
-        valid = root != null && 'relative-selector' == syntax.val;
-        return {
-            valid: valid ? ValidationLevel.Valid : ValidationLevel.Drop,
-            matches: valid ? [token] : [],
-            node: valid ? null : token,
-            syntax,
-            error: valid ? '' : 'unexpected token',
-            tokens
-        };
+    do {
+        result = match(syntax, context.clone(), { ...options, occurence: false });
+        if (result.valid == SyntaxValidationResult.Drop) {
+            break;
+        }
+        counter++;
+        context.update(result.context);
+    } while (result.valid == SyntaxValidationResult.Valid && !context.done());
+    let sucesss = counter >= syntax.occurence.min;
+    if (sucesss && syntax.occurence.max != null) {
+        if (Number.isFinite(syntax.occurence.max)) {
+            sucesss = sucesss && counter <= syntax.occurence.max;
+        }
     }
+    return {
+        valid: sucesss ? SyntaxValidationResult.Valid : SyntaxValidationResult.Drop,
+        node: context.current(),
+        syntax,
+        error: sucesss ? '' : `expected ${renderSyntax(syntax)} ${syntax.occurence.min} to ${syntax.occurence.max} occurences, got ${counter}`,
+        context
+    };
+}
+function match(syntax, context, options) {
+    let success = false;
+    let result;
+    let token = context.peek();
     switch (syntax.typ) {
-        case ValidationTokenEnum.Comma:
-            valid = token.typ === EnumToken.CommaTokenType;
-            // @ts-ignore
-            result = {
-                valid: valid ? ValidationLevel.Valid : ValidationLevel.Drop,
-                matches: valid ? [token] : [],
-                node: valid ? null : token,
+        case ValidationTokenEnum.PipeToken:
+            return someOf(syntax.chi, context, options);
+        case ValidationTokenEnum.Bracket:
+            return doEvaluateSyntax(syntax.chi, context, options);
+        case ValidationTokenEnum.AmpersandToken:
+            return allOf(flatten(syntax), context, options);
+        case ValidationTokenEnum.ColumnToken: {
+            let result = anyOf(flatten(syntax), context, options);
+            if (result.valid == SyntaxValidationResult.Valid) {
+                return result;
+            }
+            return {
+                valid: SyntaxValidationResult.Drop,
+                node: context.next(),
                 syntax,
-                error: valid ? '' : 'unexpected token',
-                tokens
+                error: `expected '${ValidationTokenEnum[syntax.typ].toLowerCase()}', got '${context.done() ? null : renderToken(context.peek())}'`,
+                context
             };
-            break;
-        case ValidationTokenEnum.AtRule:
-            if (token.typ != EnumToken.AtRuleNodeType) {
-                // @ts-ignore
-                return {
-                    valid: ValidationLevel.Drop,
-                    matches: [],
-                    node: token,
-                    syntax,
-                    error: 'expecting at-rule',
-                    tokens
-                };
-            }
-            if (token.nam != syntax.val) {
-                // @ts-ignore
-                return {
-                    valid: ValidationLevel.Drop,
-                    matches: [],
-                    node: token,
-                    syntax,
-                    error: `expecting '@${syntax.val}' but found '@${token.nam}'`,
-                    tokens
-                };
-            }
-            if (root == null) {
-                return {
-                    valid: ValidationLevel.Valid,
-                    matches: [token],
-                    node: null,
-                    syntax,
-                    error: '',
-                    tokens
-                };
-            }
-            if (root.typ != EnumToken.AtRuleNodeType) {
-                // @ts-ignore
-                return {
-                    valid: ValidationLevel.Drop,
-                    matches: [],
-                    node: token,
-                    syntax,
-                    error: 'not allowed here',
-                    tokens
-                };
-            }
-            if (!('chi' in token)) {
-                // @ts-ignore
-                return {
-                    valid: ValidationLevel.Drop,
-                    matches: [],
-                    node: token,
-                    syntax,
-                    error: '@at-rule must have children',
-                    tokens
-                };
-            }
-            // @ts-ignore
-            result = {
-                valid: ValidationLevel.Valid,
-                matches: [token],
+        }
+    }
+    if (token.typ == EnumToken.WhitespaceTokenType) {
+        context.next();
+        // @ts-ignore
+        if (syntax?.typ == ValidationTokenEnum.Whitespace) {
+            return {
+                valid: SyntaxValidationResult.Valid,
                 node: null,
                 syntax,
                 error: '',
-                tokens
+                context
             };
-            break;
-        case ValidationTokenEnum.AtRuleDefinition:
-            if (token.typ != EnumToken.AtRuleNodeType) {
-                // @ts-ignore
-                return {
-                    valid: ValidationLevel.Drop,
-                    matches: [],
-                    node: token,
-                    syntax,
-                    error: 'expecting at-rule',
-                    tokens
-                };
-            }
-            if ('chi' in syntax && !('chi' in token)) {
-                // @ts-ignore
+        }
+    }
+    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,
+            isRepeatable: null,
+            isList: null,
+            occurence: null,
+            atLeastOnce: null
+        });
+        if (result.valid == SyntaxValidationResult.Valid) {
+            context.next();
+        }
+        return { ...result, context };
+    }
+    switch (syntax.typ) {
+        case ValidationTokenEnum.Keyword:
+            success = (token.typ == EnumToken.IdenTokenType || token.typ == EnumToken.DashedIdenTokenType) &&
+                (token.val == syntax.val ||
+                    syntax.val.localeCompare(token.val, undefined, { sensitivity: 'base' }) == 0 ||
+                    // config.declarations.all
+                    allValues.includes(token.val.toLowerCase()));
+            if (success) {
+                context.next();
                 return {
-                    valid: ValidationLevel.Drop,
-                    matches: [],
+                    valid: success ? SyntaxValidationResult.Valid : SyntaxValidationResult.Drop,
                     node: token,
                     syntax,
-                    error: '@at-rule must have children',
-                    tokens
+                    error: success ? '' : `expected keyword: '${syntax.val}', got ${renderToken(token)}`,
+                    context
                 };
             }
-            if ('chi' in token && !('chi' in token)) {
-                // @ts-ignore
+            break;
+        case ValidationTokenEnum.PropertyType:
+            return matchPropertyType(syntax, context, options);
+        case ValidationTokenEnum.ValidationFunctionDefinition:
+            token = context.peek();
+            if (token.typ == EnumToken.ParensTokenType || !funcLike.concat(EnumToken.ColorTokenType) || (!('chi' in token))) {
                 return {
-                    valid: ValidationLevel.Drop,
-                    matches: [],
-                    node: token,
+                    valid: SyntaxValidationResult.Drop,
+                    node: context.next(),
                     syntax,
-                    error: 'children not allowed here',
-                    tokens
+                    error: `expected function or color token, got ${renderToken(token)}`,
+                    context
                 };
             }
-            const s = getParsedSyntax("atRules" /* ValidationSyntaxGroupEnum.AtRules */, '@' + token.nam);
-            if ('prelude' in syntax) {
-                if (!('tokens' in token)) {
-                    // @ts-ignore
-                    return {
-                        valid: ValidationLevel.Drop,
-                        matches: [],
-                        node: token,
-                        syntax,
-                        error: 'expected at-rule prelude',
-                        tokens
-                    };
-                }
-                result = validateSyntax(s[0].prelude, token.tokens, root, options, {
-                    ...context,
-                    tokens: null,
-                    level: context.level + 1
+            {
+                result = doEvaluateSyntax((getParsedSyntax("syntaxes" /* ValidationSyntaxGroupEnum.Syntaxes */, syntax.val + '()')?.[0]).chi, createContext(token.chi), {
+                    ...options,
+                    isRepeatable: null,
+                    isList: null,
+                    occurence: null,
+                    atLeastOnce: null
                 });
-                if (result.valid == ValidationLevel.Drop) {
+                if (result.valid == SyntaxValidationResult.Valid) {
+                    context.next();
+                    result.context = context;
                     return result;
                 }
             }
-            const hasBody = 'chi' in s[0];
-            if ('chi' in token) {
-                if (!hasBody) {
-                    // @ts-ignore
-                    return {
-                        valid: ValidationLevel.Drop,
-                        matches: [],
-                        node: token,
-                        syntax,
-                        error: 'unexpected at-rule body',
-                        tokens
-                    };
-                }
-            }
-            else if (hasBody) {
-                // @ts-ignore
-                return {
-                    valid: ValidationLevel.Drop,
-                    matches: [],
-                    node: token,
-                    syntax,
-                    error: 'expecting at-rule body',
-                    tokens
-                };
-            }
             break;
         case ValidationTokenEnum.DeclarationType:
-            // @ts-ignore
-            result = validateSyntax(getParsedSyntax("declarations" /* ValidationSyntaxGroupEnum.Declarations */, syntax.val), [token], root, options, context);
-            break;
-        case ValidationTokenEnum.Keyword:
-            valid = (token.typ == EnumToken.IdenTokenType && token.val.localeCompare(syntax.val, 'en', { sensitivity: 'base' }) == 0) ||
-                (token.typ == EnumToken.ColorTokenType && token.kin == 'lit' && syntax.val.localeCompare(token.val, 'en', { sensitivity: 'base' }) == 0);
-            result = {
-                valid: valid ? ValidationLevel.Valid : ValidationLevel.Drop,
-                matches: valid ? [token] : [],
-                node: valid ? null : token,
-                syntax,
-                error: valid ? '' : 'unexpected token',
-                tokens
-            };
-            break;
-        case ValidationTokenEnum.SemiColon:
-            valid = root == null || [EnumToken.RuleNodeType, EnumToken.AtRuleNodeType, EnumToken.StyleSheetNodeType].includes(root.typ);
-            result = {
-                valid: valid ? ValidationLevel.Valid : ValidationLevel.Drop,
-                matches: valid ? [token] : [],
-                node: valid ? null : token,
-                syntax,
-                error: valid ? '' : 'unexpected token',
-                tokens
-            };
-            break;
-        case ValidationTokenEnum.Separator:
-            valid = token.typ == EnumToken.LiteralTokenType && token.val != '/';
-            result = {
-                valid: valid ? ValidationLevel.Valid : ValidationLevel.Drop,
-                matches: valid ? [token] : [],
-                node: valid ? null : token,
-                syntax,
-                error: valid ? '' : 'unexpected token',
-                tokens
-            };
-            break;
-        case ValidationTokenEnum.PropertyType:
-            //
-            if ('image' == syntax.val) {
-                valid = token.typ == EnumToken.UrlFunctionTokenType || token.typ == EnumToken.ImageFunctionTokenType;
-                if (!valid) {
-                    return {
-                        valid: ValidationLevel.Drop,
-                        matches: [],
-                        node: token,
-                        syntax,
-                        error: 'unexpected <image>',
-                        tokens
-                    };
-                }
-                result = validateImage(token);
-            }
-            else if (['media-feature', 'mf-plain'].includes(syntax.val)) {
-                valid = token.typ == EnumToken.DeclarationNodeType;
-                result = {
-                    valid: valid ? ValidationLevel.Valid : ValidationLevel.Drop,
-                    matches: valid ? [token] : [],
-                    node: valid ? null : token,
-                    syntax,
-                    error: valid ? '' : 'unexpected token',
-                    tokens
-                };
-            }
-            else if (syntax.val == 'pseudo-page') {
-                valid = token.typ == EnumToken.PseudoClassTokenType && [':left', ':right', ':first', ':blank'].includes(token.val);
-                result = {
-                    valid: valid ? ValidationLevel.Valid : ValidationLevel.Drop,
-                    matches: valid ? [token] : [],
-                    node: valid ? null : token,
-                    syntax,
-                    error: valid ? '' : 'unexpected token',
-                    tokens
-                };
-            }
-            else if (syntax.val == 'page-body') {
-                if (token.typ == EnumToken.DeclarationNodeType) {
-                    valid = true;
-                    // @ts-ignore
-                    result = {
-                        valid: ValidationLevel.Valid,
-                        matches: [token],
-                        node: null,
-                        syntax,
-                        error: '',
-                        tokens
-                    };
-                    while (tokens.length > 0 && [EnumToken.DeclarationNodeType].includes(tokens[0].typ)) {
-                        // @ts-ignore
-                        result.matches.push(tokens.shift());
-                    }
-                }
-                else if (token.typ == EnumToken.AtRuleNodeType) {
-                    result = validateSyntax(getParsedSyntax("syntaxes" /* ValidationSyntaxGroupEnum.Syntaxes */, 'page-margin-box-type'), [token], root, options, context);
-                }
-            }
-            else if (syntax.val == 'group-rule-body') {
-                valid = [EnumToken.AtRuleNodeType, EnumToken.RuleNodeType].includes(token.typ);
-                if (!valid && token.typ == EnumToken.DeclarationNodeType && root?.typ == EnumToken.AtRuleNodeType && root.nam == 'media') {
-                    // allowed only if nested rule
-                    let parent = root;
-                    while (parent != null) {
-                        if (parent.typ == EnumToken.RuleNodeType) {
-                            valid = true;
-                            break;
-                        }
-                        // @ts-ignore
-                        parent = parent.parent;
-                    }
-                }
-                // @ts-ignore
-                result = {
-                    valid: valid ? ValidationLevel.Valid : ValidationLevel.Drop,
-                    matches: [],
-                    node: valid ? null : token,
-                    syntax,
-                    error: valid ? '' : 'token is not allowed as a child',
-                    tokens
-                };
-                if (!valid) {
-                    return result;
-                }
-            }
-            //
-            else if ('type-selector' == syntax.val) {
-                valid = (token.typ == EnumToken.UniversalSelectorTokenType) ||
-                    token.typ == EnumToken.IdenTokenType || (token.typ == EnumToken.NameSpaceAttributeTokenType &&
-                    (token.l == null || token.l.typ == EnumToken.IdenTokenType ||
-                        (token.l.typ == EnumToken.LiteralTokenType && token.l.val == '*')) &&
-                    token.r.typ == EnumToken.IdenTokenType);
-                result = {
-                    valid: valid ? ValidationLevel.Valid : ValidationLevel.Drop,
-                    matches: valid ? [token] : [],
-                    node: token,
-                    syntax,
-                    error: valid ? '' : 'unexpected token',
-                    tokens
-                };
-            }
-            else if ('wq-name' == syntax.val) {
-                valid = token.typ == EnumToken.IdenTokenType || (token.typ == EnumToken.NameSpaceAttributeTokenType &&
-                    (token.l == null || token.l.typ == EnumToken.IdenTokenType || (token.l.typ == EnumToken.LiteralTokenType && token.l.val == '*')) &&
-                    token.r.typ == EnumToken.IdenTokenType);
-                result = {
-                    valid: valid ? ValidationLevel.Valid : ValidationLevel.Drop,
-                    matches: valid ? [token] : [],
-                    node: token,
-                    syntax,
-                    error: valid ? '' : 'unexpected token',
-                    tokens
-                };
-            }
-            else if (EnumToken.UniversalSelectorTokenType == token.typ && 'subclass-selector' == syntax.val) {
-                valid = true;
-                result = {
-                    valid: ValidationLevel.Valid,
-                    matches: [token],
-                    node: null,
-                    syntax,
-                    error: '',
-                    tokens
-                };
-            }
-            else if ('attribute-selector' == syntax.val) {
-                valid = token.typ == EnumToken.AttrTokenType && token.chi.length > 0;
-                if (valid) {
-                    const children = token.chi.filter(t => t.typ != EnumToken.WhitespaceTokenType && t.typ != EnumToken.CommaTokenType);
-                    valid = children.length == 1 && [
-                        EnumToken.IdenTokenType,
-                        EnumToken.NameSpaceAttributeTokenType,
-                        EnumToken.MatchExpressionTokenType
-                    ].includes(children[0].typ);
-                    if (valid && children[0].typ == EnumToken.MatchExpressionTokenType) {
-                        const t = children[0];
-                        valid = [
-                            EnumToken.IdenTokenType,
-                            EnumToken.NameSpaceAttributeTokenType
-                        ].includes(t.l.typ) &&
-                            (t.op == null || ([
-                                EnumToken.DelimTokenType, EnumToken.DashMatchTokenType,
-                                EnumToken.StartMatchTokenType, EnumToken.ContainMatchTokenType,
-                                EnumToken.EndMatchTokenType, EnumToken.IncludeMatchTokenType
-                            ].includes(t.op.typ) &&
-                                t.r != null &&
-                                [
-                                    EnumToken.StringTokenType,
-                                    EnumToken.IdenTokenType
-                                ].includes(t.r.typ)));
-                        if (valid && t.attr != null) {
-                            const s = getParsedSyntax("syntaxes" /* ValidationSyntaxGroupEnum.Syntaxes */, 'attr-modifier')[0];
-                            valid = s.chi.some((l) => l.some((r) => r.val == t.attr));
-                        }
-                    }
-                }
-                result = {
-                    valid: valid ? ValidationLevel.Valid : ValidationLevel.Drop,
-                    matches: valid ? [token] : [],
-                    node: valid ? null : token,
-                    syntax,
-                    error: valid ? '' : 'unexpected token',
-                    tokens
-                };
-                if (!valid) {
-                    return result;
-                }
-            }
-            else if ('combinator' == syntax.val) {
-                valid = [
-                    EnumToken.DescendantCombinatorTokenType,
-                    EnumToken.SubsequentSiblingCombinatorTokenType,
-                    EnumToken.NextSiblingCombinatorTokenType,
-                    EnumToken.ChildCombinatorTokenType,
-                    EnumToken.ColumnCombinatorTokenType
-                ].includes(token.typ);
-                if (valid) {
-                    // @ts-ignore
-                    const position = context.tokens.indexOf(token);
-                    if (root == null) {
-                        valid = position > 0 && context.tokens[position - 1]?.typ != EnumToken.CommaTokenType;
-                    }
-                }
-                result = {
-                    valid: valid ? ValidationLevel.Valid : ValidationLevel.Drop,
-                    matches: valid ? [token] : [],
-                    node: valid ? null : token,
-                    syntax,
-                    error: valid ? '' : 'unexpected token',
-                    tokens
-                };
-                if (!valid) {
-                    return result;
-                }
-            }
-            else if ('ident-token' == syntax.val) {
-                valid = token.typ == EnumToken.IdenTokenType;
-                result = {
-                    valid: valid ? ValidationLevel.Valid : ValidationLevel.Drop,
-                    matches: valid ? [token] : [],
-                    node: valid ? null : token,
-                    syntax,
-                    error: valid ? '' : 'unexpected token',
-                    tokens
-                };
-            }
-            else if ('hex-color' == syntax.val) {
-                valid = token.typ == EnumToken.ColorTokenType && token.kin == 'hex';
-                result = {
-                    valid: valid ? ValidationLevel.Valid : ValidationLevel.Drop,
-                    matches: valid ? [token] : [],
-                    node: valid ? null : token,
-                    syntax,
-                    error: valid ? '' : 'unexpected token',
-                    tokens
-                };
-            }
-            else if ('resolution' == syntax.val) {
-                valid = token.typ == EnumToken.ResolutionTokenType;
-                result = {
-                    valid: valid ? ValidationLevel.Valid : ValidationLevel.Drop,
-                    matches: valid ? [token] : [],
-                    node: valid ? null : token,
-                    syntax,
-                    error: valid ? '' : 'unexpected token',
-                    tokens
-                };
-            }
-            else if ('angle' == syntax.val) {
-                valid = token.typ == EnumToken.AngleTokenType || (token.typ == EnumToken.NumberTokenType && token.val == '0');
-                result = {
-                    valid: valid ? ValidationLevel.Valid : ValidationLevel.Drop,
-                    matches: valid ? [token] : [],
-                    node: valid ? null : token,
-                    syntax,
-                    error: valid ? '' : 'unexpected token',
-                    tokens
-                };
-            }
-            else if ('time' == syntax.val) {
-                valid = token.typ == EnumToken.TimingFunctionTokenType;
-                result = {
-                    valid: valid ? ValidationLevel.Valid : ValidationLevel.Drop,
-                    matches: valid ? [token] : [],
-                    node: valid ? null : token,
-                    syntax,
-                    error: valid ? '' : 'unexpected token',
-                    tokens
-                };
-            }
-            else if ('ident' == syntax.val) {
-                valid = token.typ == EnumToken.IdenTokenType;
-                result = {
-                    valid: valid ? ValidationLevel.Valid : ValidationLevel.Drop,
-                    matches: valid ? [token] : [],
-                    node: valid ? null : token,
-                    syntax,
-                    error: valid ? '' : 'unexpected token',
-                    tokens
-                };
-            }
-            else if (['id-selector', 'hash-token'].includes(syntax.val)) {
-                valid = token.typ == EnumToken.HashTokenType;
-                result = {
-                    valid: valid ? ValidationLevel.Valid : ValidationLevel.Drop,
-                    matches: valid ? [token] : [],
-                    node: valid ? null : token,
-                    syntax,
-                    error: valid ? '' : 'unexpected token',
-                    tokens
-                };
-            }
-            else if (['integer', 'number'].includes(syntax.val)) {
-                // valid = token.typ == EnumToken.NumberTokenType;
-                valid = token.typ == EnumToken.NumberTokenType && ('integer' != syntax.val || Number.isInteger(+token.val));
-                if (valid && 'range' in syntax) {
-                    const value = Number(token.val);
-                    const range = syntax.range;
-                    valid = value >= range[0] && (range[1] == null || value <= range[1]);
-                }
-                result = {
-                    valid: valid ? ValidationLevel.Valid : ValidationLevel.Drop,
-                    matches: valid ? [token] : [],
-                    node: valid ? null : token,
-                    syntax,
-                    error: valid ? '' : 'unexpected token',
-                    tokens
-                };
-            }
-            else if ('length' == syntax.val) {
-                valid = isLength(token) || (token.typ == EnumToken.NumberTokenType && token.val == '0');
-                // @ts-ignore
-                result = {
-                    valid: valid ? ValidationLevel.Valid : ValidationLevel.Drop,
-                    matches: valid ? [token] : [],
-                    node: valid ? null : token,
-                    syntax,
-                    error: valid ? '' : 'unexpected token',
-                    tokens
-                };
-            }
-            else if ('percentage' == syntax.val) {
-                valid = token.typ == EnumToken.PercentageTokenType || (token.typ == EnumToken.NumberTokenType && token.val == '0');
-                result = {
-                    valid: valid ? ValidationLevel.Valid : ValidationLevel.Drop,
-                    matches: valid ? [token] : [],
-                    node: valid ? null : token,
-                    syntax,
-                    error: valid ? '' : 'unexpected token',
-                    tokens
-                };
-            }
-            else if ('dashed-ident' == syntax.val) {
-                valid = token.typ == EnumToken.DashedIdenTokenType;
-                result = {
-                    valid: valid ? ValidationLevel.Valid : ValidationLevel.Drop,
-                    matches: valid ? [token] : [],
-                    node: valid ? null : token,
-                    syntax,
-                    error: valid ? '' : 'unexpected token',
-                    tokens
-                };
-            }
-            else if ('custom-ident' == syntax.val) {
-                valid = token.typ == EnumToken.DashedIdenTokenType || token.typ == EnumToken.IdenTokenType;
-                result = {
-                    valid: valid ? ValidationLevel.Valid : ValidationLevel.Drop,
-                    matches: valid ? [token] : [],
-                    node: valid ? null : token,
-                    syntax,
-                    error: valid ? '' : 'unexpected token',
-                    tokens
-                };
-            }
-            else if ('custom-property-name' == syntax.val) {
-                valid = token.typ == EnumToken.DashedIdenTokenType;
-                result = {
-                    valid: valid ? ValidationLevel.Valid : ValidationLevel.Drop,
-                    matches: valid ? [token] : [],
-                    node: valid ? null : token,
-                    syntax,
-                    error: valid ? '' : 'unexpected token',
-                    tokens
-                };
+            return doEvaluateSyntax(getParsedSyntax("declarations" /* ValidationSyntaxGroupEnum.Declarations */, syntax.val), context, {
+                ...options,
+                isRepeatable: null,
+                isList: null,
+                occurence: null,
+                atLeastOnce: null
+            });
+        case ValidationTokenEnum.Parens:
+            token = context.peek();
+            if (token.typ != EnumToken.ParensTokenType) {
+                break;
             }
-            else if ('string' == syntax.val) {
-                valid = token.typ == EnumToken.StringTokenType;
-                result = {
-                    valid: valid ? ValidationLevel.Valid : ValidationLevel.Drop,
-                    matches: valid ? [token] : [],
-                    node: valid ? null : token,
-                    syntax,
-                    error: valid ? '' : 'unexpected token',
-                    tokens
-                };
+            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();
             }
-            else if ('declaration-value' == syntax.val) {
-                valid = token.typ != EnumToken.LiteralTokenType;
-                result = {
-                    valid: valid ? ValidationLevel.Valid : ValidationLevel.Drop,
-                    matches: valid ? [token] : [],
-                    node: valid ? null : token,
-                    syntax,
-                    error: valid ? '' : 'unexpected token',
-                    tokens
-                };
+            break;
+        case ValidationTokenEnum.Number:
+            success = context.peek()?.typ == EnumToken.NumberTokenType;
+            if (success) {
+                context.next();
             }
-            else if ('url' == syntax.val) {
-                valid = token.typ == EnumToken.UrlFunctionTokenType || token.typ == EnumToken.StringTokenType;
-                result = {
-                    valid: valid ? ValidationLevel.Valid : ValidationLevel.Drop,
-                    matches: valid ? [token] : [],
-                    node: valid ? null : token,
-                    syntax,
-                    error: valid ? '' : 'unexpected token',
-                    tokens
-                };
+            break;
+        case ValidationTokenEnum.Whitespace:
+            success = context.peek()?.typ == EnumToken.WhitespaceTokenType;
+            if (success) {
+                context.next();
             }
-            else if ('declaration' == syntax.val) {
-                valid = token.typ == EnumToken.DeclarationNodeType && (token.nam.startsWith(('--')) || token.nam in config.declarations || token.nam in config.syntaxes);
-                if (!valid) {
-                    // @ts-ignore
-                    result = {
-                        valid: ValidationLevel.Drop,
-                        matches: [],
-                        node: token,
-                        syntax,
-                        error: 'unexpected token',
-                        tokens
-                    };
-                }
-                else if (token.nam.startsWith(('--'))) {
-                    result = {
-                        valid: ValidationLevel.Valid,
-                        matches: [token],
-                        node: null,
-                        syntax,
-                        error: '',
-                        tokens
-                    };
-                }
-                else {
-                    result = validateSyntax(getParsedSyntax("declarations" /* ValidationSyntaxGroupEnum.Declarations */, token.nam) ?? getParsedSyntax("syntaxes" /* ValidationSyntaxGroupEnum.Syntaxes */, token.nam), token.val, token, options, {
-                        ...context,
-                        tokens: null,
-                        level: 0
-                    });
-                    if (result.valid == ValidationLevel.Valid && result.error.length == 0) {
-                        tokens = result.tokens;
-                    }
+            break;
+        case ValidationTokenEnum.Separator:
+            {
+                const token = context.peek();
+                success = token?.typ == EnumToken.LiteralTokenType && token.val == '/';
+                if (success) {
+                    context.next();
                 }
             }
-            else if ('class-selector' == syntax.val) {
-                valid = EnumToken.ClassSelectorTokenType == token.typ || EnumToken.UniversalSelectorTokenType == token.typ;
-                result = {
-                    valid: valid ? ValidationLevel.Valid : ValidationLevel.Drop,
-                    matches: valid ? [token] : [],
-                    node: token,
-                    syntax,
-                    error: valid ? '' : 'unexpected token',
-                    tokens
-                };
+            break;
+        default:
+            token = context.peek();
+            if (!wildCardFuncs.includes(syntax.val) && syntax.val != token.val) {
+                break;
             }
-            // else if ('complex-selector' == (syntaxes as ValidationPropertyToken).val) {
-            //
-            //     result = validateSyntax(getParsedSyntax(ValidationSyntaxGroupEnum.Syntaxes, (syntaxes as ValidationPropertyToken).val) as ValidationToken[], tokens, root as AstNode, options, context);
-            //
-            // }
-            else if (['pseudo-element-selector', 'pseudo-class-selector'].includes(syntax.val)) {
-                valid = false;
-                if (token.typ == EnumToken.PseudoClassTokenType) {
-                    let val = token.val;
-                    if (val == ':before' || val == ':after') {
-                        val = ':' + val;
-                    }
-                    valid = val in config.selectors;
-                    if (!valid && val.match(/^:?:-/) != null) {
-                        const match = token.val.match(/^(:?:)(-[^-]+-)(.*)$/);
-                        if (match != null) {
-                            valid = true;
-                        }
-                    }
-                    result = {
-                        valid: valid ? ValidationLevel.Valid : ValidationLevel.Drop,
-                        matches: valid ? [token] : [],
-                        node: valid ? null : token,
-                        syntax,
-                        error: valid ? '' : 'invalid pseudo class',
-                        tokens
-                    };
+            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 (success) {
+                    context.next();
                 }
-                else if (token.typ == EnumToken.PseudoClassFuncTokenType) {
-                    let key = token.val in config.selectors ? token.val : token.val + '()';
-                    valid = key in config.selectors;
-                    if (!valid && token.val.match(/^:?:-/)) {
-                        const match = token.val.match(/^(:?:)(-[^-]+-)(.*)$/);
-                        if (match != null) {
-                            key = match[1] + match[3] in config.selectors ? match[1] + match[3] : match[1] + match[3] + '()';
-                            valid = key in config.selectors;
-                        }
-                    }
-                    const s = getParsedSyntax("selectors" /* ValidationSyntaxGroupEnum.Selectors */, key);
-                    if (s != null) {
-                        const r = s[0];
-                        if (r.typ != ValidationTokenEnum.PseudoClassFunctionToken) {
-                            valid = false;
-                        }
-                        else {
-                            result = validateSyntax(s[0].chi, token.chi, root, options, {
-                                ...context,
-                                tokens: null,
-                                level: context.level + 1
-                            });
-                            break;
-                        }
-                    }
-                }
-                result = {
-                    valid: valid ? ValidationLevel.Valid : ValidationLevel.Drop,
-                    matches: valid ? [token] : [],
-                    node: token,
-                    syntax,
-                    error: valid ? '' : 'unexpected token',
-                    tokens
-                };
+                break;
             }
-            // <relative-selector-list>
-            // <complex-selector-list>
-            else if ('relative-selector' == syntax.val) {
-                if (tokens.length == 1 && token.typ == EnumToken.NestingSelectorTokenType) {
-                    return {
-                        valid: ValidationLevel.Valid,
-                        matches: [token],
-                        node: token,
-                        syntax,
-                        error: '',
-                        tokens
-                    };
+            if (syntax.typ == ValidationTokenEnum.Function) {
+                success = funcLike.includes(token.typ) && doEvaluateSyntax(getParsedSyntax("syntaxes" /* ValidationSyntaxGroupEnum.Syntaxes */, syntax.val + '()')?.[0]?.chi, createContext(token.chi), {
+                    ...options,
+                    isRepeatable: null,
+                    isList: null,
+                    occurence: null,
+                    atLeastOnce: null
+                }).valid == SyntaxValidationResult.Valid;
+                if (success) {
+                    context.next();
                 }
-                result = validateSyntax(getParsedSyntax("syntaxes" /* ValidationSyntaxGroupEnum.Syntaxes */, syntax.val), token.typ == EnumToken.NestingSelectorTokenType ? tokens.slice(1) : tokens, root, options, context);
+                break;
             }
-            // <relative-selector-list>
-            // <complex-selector-list>
-            else if (['forgiving-selector-list', 'forgiving-relative-selector-list'].includes(syntax.val)) {
+        // 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;
+        context.next();
+    }
+    return {
+        valid: success ? SyntaxValidationResult.Valid : SyntaxValidationResult.Drop,
+        node: context.peek(),
+        syntax,
+        error: success ? '' : `expected '${ValidationTokenEnum[syntax.typ].toLowerCase()}', got '${renderToken(context.peek())}'`,
+        context
+    };
+}
+function matchPropertyType(syntax, context, options) {
+    if (![
+        '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 */]) {
+            return doEvaluateSyntax(getParsedSyntax("syntaxes" /* ValidationSyntaxGroupEnum.Syntaxes */, syntax.val), context, {
+                ...options,
+                isRepeatable: null,
+                isList: null,
+                occurence: null,
+                atLeastOnce: null
+            });
+        }
+    }
+    let success = true;
+    let token = context.peek();
+    if ((token?.typ == EnumToken.FunctionTokenType && wildCardFuncs.includes(token.val))) {
+        const result = doEvaluateSyntax(getParsedSyntax("functions" /* ValidationSyntaxGroupEnum.Functions */, token.val)?.[0]?.chi ?? [], createContext(token.chi), {
+            ...options,
+            isRepeatable: null,
+            isList: null,
+            occurence: null,
+            atLeastOnce: null
+        });
+        if (result.valid == SyntaxValidationResult.Valid) {
+            context.next();
+        }
+        return { ...result, context };
+    }
+    switch (syntax.val) {
+        case 'calc-sum':
+            success = (token.typ == EnumToken.FunctionTokenType && mathFuncs.includes(token.val)) ||
                 // @ts-ignore
-                result = { tokens: tokens.slice(), ...validateSelector(tokens, options, root) };
-            }
-            // https://github.com/mdn/data/pull/186#issuecomment-369604537
-            else if (syntax.val.endsWith('-token')) {
-                const val = syntax.val;
-                valid = true;
-                switch (val) {
-                    case 'function-token':
-                        valid = token.typ != EnumToken.ParensTokenType && funcLike.includes(token.typ);
-                        break;
-                    case 'ident-token':
-                        valid = token.typ == EnumToken.DashedIdenTokenType || token.typ == EnumToken.IdenTokenType;
-                        break;
-                    case 'hash-token':
-                        valid = token.typ == EnumToken.HashTokenType;
-                        break;
-                    case 'string-token':
-                        valid = token.typ == EnumToken.StringTokenType;
-                        break;
-                    default:
-                        console.error(new Error(`unhandled syntax: '<${val}>'`));
-                        break;
-                }
-                result = {
-                    valid: valid ? ValidationLevel.Valid : ValidationLevel.Drop,
-                    matches: valid ? [token] : [],
-                    node: valid ? null : token,
-                    syntax,
-                    error: valid ? '' : 'unexpected token',
-                    tokens
-                };
-            }
-            else if ('wq-name' == syntax.val) {
-                valid = token.typ == EnumToken.IdenTokenType || (token.typ == EnumToken.NameSpaceAttributeTokenType &&
-                    (token.l == null || token.l.typ == EnumToken.IdenTokenType || (token.l.typ == EnumToken.LiteralTokenType && token.l.val == '*')) &&
-                    token.r.typ == EnumToken.IdenTokenType);
-                result = {
-                    valid: valid ? ValidationLevel.Valid : ValidationLevel.Drop,
-                    matches: valid ? [token] : [],
-                    node: token,
-                    syntax,
-                    error: valid ? '' : 'unexpected token',
-                    tokens
-                };
-            }
-            else {
-                const val = syntax.val;
-                // https://github.com/mdn/data/pull/186#issuecomment-369604537
-                if (val == 'any-value') {
-                    return {
-                        valid: ValidationLevel.Valid,
-                        matches: [token],
-                        node: null,
-                        syntax,
-                        error: '',
-                        tokens
-                    };
-                }
-                else if (val in config.declarations || val in config.syntaxes) {
-                    result = validateSyntax(getParsedSyntax("syntaxes" /* ValidationSyntaxGroupEnum.Syntaxes */, val) ?? getParsedSyntax("declarations" /* ValidationSyntaxGroupEnum.Declarations */, val), tokens, root, options, context);
-                }
-                else {
-                    // @ts-ignore
-                    result = {
-                        valid: ValidationLevel.Drop,
-                        matches: [],
-                        node: token,
-                        syntax,
-                        error: 'unexpected token',
-                        tokens
-                    };
-                }
-            }
+                (token.typ == EnumToken.IdenTokenType && typeof Math[token.val.toUpperCase()] == 'number') ||
+                [EnumToken.BinaryExpressionTokenType, EnumToken.NumberTokenType, EnumToken.PercentageTokenType, EnumToken.DimensionTokenType, EnumToken.LengthTokenType, EnumToken.AngleTokenType, EnumToken.TimeTokenType, EnumToken.ResolutionTokenType, EnumToken.FrequencyTokenType].includes(token.typ);
             break;
-        case ValidationTokenEnum.Parens:
-        case ValidationTokenEnum.Function:
-            if (syntax.typ == ValidationTokenEnum.Parens) {
-                valid = token.typ == EnumToken.ParensTokenType;
-            }
-            else {
-                valid = 'chi' in token && 'val' in token &&
-                    token.val.localeCompare(syntax.val, 'en', { sensitivity: 'base' }) == 0;
+        case 'declaration-value':
+            while (!context.done()) {
+                context.next();
             }
-            result = !valid ?
-                // @ts-ignore
-                {
-                    valid: ValidationLevel.Drop,
-                    matches: [],
-                    node: token,
-                    syntax,
-                    error: 'unexpected token',
-                    tokens
-                } : validateSyntax(syntax.chi, token.chi, root, options, {
-                ...context,
-                tokens: null,
-                level: context.level + 1
-            });
+            success = true;
             break;
-        case ValidationTokenEnum.ValidationFunctionDefinition:
-            valid = 'val' in token && 'chi' in token;
-            result = {
-                valid: valid ? ValidationLevel.Valid : ValidationLevel.Drop,
-                matches: valid ? [token] : [],
-                node: valid ? null : token,
-                syntax,
-                error: '',
-                tokens
-            };
-            if (result.valid == ValidationLevel.Valid) {
-                valid = token.val.localeCompare(syntax.val, 'en', { sensitivity: 'base' }) == 0;
-                result = {
-                    valid: valid ? ValidationLevel.Valid : ValidationLevel.Drop,
-                    matches: valid ? [token] : [],
-                    node: valid ? null : token,
-                    error: '',
-                    syntax,
-                    tokens
-                };
-                if (result.valid == ValidationLevel.Valid) {
-                    const s = getParsedSyntax("syntaxes" /* ValidationSyntaxGroupEnum.Syntaxes */, syntax.val + '()'); // config[ValidationSyntaxGroupEnum.Syntaxes][(syntaxes as ValidationFunctionDefinitionToken).val + '()'] as ValidationSyntaxNode;
-                    result = validateSyntax(s, tokens, root, options, context);
-                }
-            }
+        case 'url-token':
+            success = token.typ == EnumToken.UrlTokenTokenType || token.typ == EnumToken.StringTokenType || (token.typ == EnumToken.FunctionTokenType && wildCardFuncs.includes(token.val));
             break;
-        case ValidationTokenEnum.Bracket:
-            result = validateSyntax(syntax.chi, tokens, root, options, context);
+        case 'ident':
+        case 'ident-token':
+        case 'custom-ident':
+            success = token.typ == EnumToken.IdenTokenType || token.typ == EnumToken.DashedIdenTokenType || isIdentColor(token);
             break;
-        case ValidationTokenEnum.PipeToken:
-            for (const lines of syntax.chi) {
-                result = validateSyntax(lines, tokens, root, options, context);
-                if (result.valid == ValidationLevel.Valid) {
-                    break;
-                }
-            }
+        case 'dashed-ident':
+        case 'custom-property-name':
+            success = token.typ == EnumToken.DashedIdenTokenType;
             break;
-        case ValidationTokenEnum.AmpersandToken:
-            children = [...syntax.l.slice(), ...syntax.r.slice()];
-            matches = [];
-            queue = [];
-            let m = [];
-            for (let j = 0; j < children.length; j++) {
-                const res = validateSyntax([children[j]], tokens, root, options, context);
-                // @ts-ignore
-                if (res.valid == ValidationLevel.Valid) {
-                    m.push(...res.matches);
-                    matches.push(...children.splice(j, 1));
-                    j = 0;
-                    // @ts-ignore
-                    astNodes.delete(token);
-                    consumeToken(tokens);
-                    token = tokens[0];
-                    if (token == null) {
-                        break;
-                    }
-                    // @ts-ignore
-                    astNodes.add(token);
-                }
+        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));
+            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));
+            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));
+            if (!success && token.typ == EnumToken.FunctionTokenType && colorsFunc.includes(token.val)) {
+                success = doEvaluateSyntax(getParsedSyntax("functions" /* ValidationSyntaxGroupEnum.Functions */, token.val)?.[0]?.chi, createContext(token.chi), {
+                    ...options,
+                    isRepeatable: null,
+                    isList: null,
+                    occurence: null,
+                    atLeastOnce: null
+                }).valid == SyntaxValidationResult.Valid;
             }
-            if (astNodes.size > 0) {
-                // @ts-ignore
-                tokens.unshift(...astNodes);
-                astNodes = new Set();
+            break;
+        case 'hex-color':
+            success = (token.typ == EnumToken.ColorTokenType && token.kin == ColorKind.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');
+            if ('range' in syntax) {
+                success = success && +token.val >= +syntax.range[0] && +token.val <= +syntax.range[1];
             }
-            valid = matches.length > 0;
-            result = {
-                valid: valid ? ValidationLevel.Valid : ValidationLevel.Drop,
-                matches: m,
-                node: valid ? null : token,
-                syntax,
-                error: valid ? '' : 'expecting token',
-                tokens
-            };
             break;
-        case ValidationTokenEnum.ColumnArrayToken:
-            {
-                matches = [];
-                queue = [];
-                const children = syntax.chi;
-                let child;
-                while (child = children.shift()) {
-                    result = validateSyntax([child], tokens, root, options, context);
-                    if (result.valid == ValidationLevel.Valid) {
-                        matches.push(child);
-                        consumeToken(tokens);
-                        token = tokens[0];
-                        if (queue.length > 0) {
-                            children.unshift(...queue);
-                            queue = [];
-                        }
-                        if (token == null) {
-                            break;
-                        }
-                    }
-                    else {
-                        queue.push(child);
-                    }
-                }
-                valid = matches.length > 0;
-                result = {
-                    valid: valid ? ValidationLevel.Valid : ValidationLevel.Drop,
-                    matches: valid ? [token] : [],
-                    node: valid ? null : token,
-                    syntax,
-                    error: valid ? '' : 'expecting token',
-                    tokens
-                };
+        case 'dimension':
+            success = [
+                EnumToken.DimensionTokenType,
+                EnumToken.LengthTokenType,
+                EnumToken.AngleTokenType,
+                EnumToken.TimeTokenType,
+                EnumToken.ResolutionTokenType,
+                EnumToken.FrequencyTokenType
+            ].includes(token.typ) || (token.typ == EnumToken.FunctionTokenType && token.val == 'calc');
+            break;
+        case 'flex':
+            success = token.typ == EnumToken.FlexTokenType || (token.typ == EnumToken.FunctionTokenType && token.val == 'calc');
+            break;
+        case 'number':
+        case 'number-token':
+            success = token.typ == EnumToken.NumberTokenType;
+            if ('range' in syntax) {
+                success = success && +token.val >= +syntax.range[0] && +token.val <= +syntax.range[1];
             }
             break;
-        case ValidationTokenEnum.ColumnToken:
-            children = [...syntax.l.slice(), ...syntax.r.slice()];
-            matches = [];
-            queue = [];
-            while ((child = children.shift())) {
-                const res = validateSyntax([child], tokens, root, options, context);
-                if (res.valid == ValidationLevel.Valid) {
-                    matches.push(child);
-                    consumeToken(tokens);
-                    token = tokens[0];
-                    if (queue.length > 0) {
-                        children.unshift(...queue);
-                        queue = [];
-                    }
-                    if (token == null) {
-                        break;
-                    }
-                }
-                else {
-                    queue.push(child);
+        case 'angle':
+            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');
+            break;
+        case 'percentage':
+            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');
+            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');
+            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));
+            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');
+            break;
+        case 'pseudo-element-selector':
+            success = token.typ == EnumToken.PseudoElementTokenType;
+            break;
+        case 'pseudo-class-selector':
+            success = token.typ == EnumToken.PseudoClassTokenType || token.typ == EnumToken.PseudoClassFuncTokenType;
+            if (success) {
+                success = token.val + (token.typ == EnumToken.PseudoClassTokenType ? '' : '()') in config["selectors" /* ValidationSyntaxGroupEnum.Selectors */];
+                if (success && token.typ == EnumToken.PseudoClassFuncTokenType) {
+                    success = doEvaluateSyntax(getParsedSyntax("selectors" /* ValidationSyntaxGroupEnum.Selectors */, token.val + '()')?.[0]?.chi ?? [], createContext(token.chi), {
+                        ...options,
+                        isRepeatable: null,
+                        isList: null,
+                        occurence: null,
+                        atLeastOnce: null
+                    }).valid == SyntaxValidationResult.Valid;
                 }
             }
-            valid = matches.length > 0;
-            result = {
-                valid: valid ? ValidationLevel.Valid : ValidationLevel.Drop,
-                matches: valid ? [token] : [],
-                node: valid ? null : token,
-                syntax,
-                error: valid ? '' : 'expecting token',
-                tokens
-            };
             break;
-        case ValidationTokenEnum.StringToken:
-            valid = token.typ == EnumToken.StringTokenType && syntax.val.slice(1, -1) == token.val.slice(1, -1);
-            return {
-                valid: valid ? ValidationLevel.Valid : ValidationLevel.Drop,
-                matches: valid ? [token] : [],
-                node: valid ? null : token,
-                syntax,
-                error: valid ? '' : 'expecting token',
-                tokens
-            };
-        case ValidationTokenEnum.PseudoClassFunctionToken:
-            valid = token.typ == EnumToken.PseudoClassFuncTokenType;
-            if (valid) {
-                let key = token.val in config.selectors ? token.val : token.val + '()';
-                const s = getParsedSyntax("syntaxes" /* ValidationSyntaxGroupEnum.Syntaxes */, key);
-                valid = s != null && validateSyntax(s, token.chi, root, options, {
-                    ...context,
-                    tokens: null,
-                    level: context.level + 1
-                }).valid == ValidationLevel.Valid;
+        // 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 &&
+        ['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,
+                    isList: null,
+                    occurence: null,
+                    atLeastOnce: null
+                }).valid == SyntaxValidationResult.Valid;
+        }
+    }
+    if (!success && token.typ == EnumToken.IdenTokenType) {
+        success = allValues.includes(token.val.toLowerCase());
+    }
+    if (success) {
+        context.next();
+    }
+    return {
+        valid: success ? SyntaxValidationResult.Valid : SyntaxValidationResult.Drop,
+        node: token,
+        syntax,
+        error: success ? '' : `expected '${syntax.val}', got ${renderToken(token)}`,
+        context
+    };
+}
+function someOf(syntaxes, context, options) {
+    let result;
+    let i;
+    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;
+            if (result.context.done()) {
+                return result;
             }
-            result = {
-                valid: valid ? ValidationLevel.Valid : ValidationLevel.Drop,
-                matches: valid ? [token] : [],
-                node: valid ? null : token,
-                syntax,
-                error: valid ? '' : 'invalid token',
-                tokens
-            };
-            break;
-        case ValidationTokenEnum.DeclarationDefinitionToken:
-            if (token.typ != EnumToken.DeclarationNodeType || token.nam != syntax.nam) {
-                return {
-                    valid: ValidationLevel.Drop,
-                    matches: [],
-                    node: token,
-                    syntax,
-                    error: '',
-                    tokens
-                };
+            matched.push(result);
+        }
+    }
+    if (matched.length > 0) {
+        // pick the best match
+        matched.sort((a, b) => a.context.done() ? -1 : b.context.done() ? 1 : b.context.index - a.context.index);
+    }
+    return matched[0] ?? {
+        valid: SyntaxValidationResult.Drop,
+        node: context.current(),
+        syntax: null,
+        error: success ? '' : `could not match someOf: ${syntaxes.reduce((acc, curr) => acc + (acc.length > 0 ? ' | ' : '') + curr.reduce((acc, curr) => acc + renderSyntax(curr), ''), '')}`,
+        context
+    };
+}
+function anyOf(syntaxes, context, options) {
+    let result;
+    let i;
+    let success = false;
+    for (i = 0; i < syntaxes.length; i++) {
+        result = doEvaluateSyntax(syntaxes[i], context.clone(), options);
+        if (result.valid == SyntaxValidationResult.Valid) {
+            success = true;
+            context.update(result.context);
+            if (result.context.done()) {
+                return result;
             }
-            return validateSyntax([syntax.val], token.val, root, options, context);
-        default:
-            throw new Error('not implemented: ' + JSON.stringify({ syntax, token, tokens }, null, 1));
+            syntaxes.splice(i, 1);
+            i = -1;
+        }
+    }
+    return {
+        valid: success ? SyntaxValidationResult.Valid : SyntaxValidationResult.Drop,
+        node: context.current(),
+        syntax: null,
+        error: success ? '' : `could not match anyOf: ${syntaxes.reduce((acc, curr) => acc + '[' + curr.reduce((acc, curr) => acc + renderSyntax(curr), '') + ']', '')}`,
+        context
+    };
+}
+function allOf(syntax, context, options) {
+    let result;
+    let i;
+    // sort tokens -> wildCard -> last
+    // 1px var(...) 2px => 1px 2px var(...)
+    const slice = context.slice();
+    const vars = [];
+    const tokens = [];
+    for (i = 0; i < slice.length; i++) {
+        if (slice[i].typ == EnumToken.FunctionTokenType && wildCardFuncs.includes(slice[i].val.toLowerCase())) {
+            vars.push(slice[i]);
+            slice.splice(i, 1);
+            if (slice[i]?.typ == EnumToken.WhitespaceTokenType) {
+                vars.push(slice[i]);
+                slice.splice(i, 1);
+                if (i > 0) {
+                    i--;
+                }
+            }
+            if (i > 0) {
+                i--;
+            }
+            continue;
+        }
+        if (slice[i].typ == EnumToken.CommaTokenType || (slice[i].typ == EnumToken.LiteralTokenType && slice[i].val == '/')) {
+            tokens.push(...vars);
+            vars.length = 0;
+        }
+        tokens.push(slice[i]);
+    }
+    if (vars.length > 0) {
+        tokens.push(...vars);
+    }
+    const con = createContext(tokens);
+    for (i = 0; i < syntax.length; i++) {
+        result = doEvaluateSyntax(syntax[i], con.clone(), options);
+        if (result.valid == SyntaxValidationResult.Valid) {
+            con.update(result.context);
+            syntax.splice(i, 1);
+            i = -1;
+        }
+    }
+    const success = syntax.length == 0;
+    return {
+        valid: success ? SyntaxValidationResult.Valid : SyntaxValidationResult.Drop,
+        node: context.current(),
+        syntax: syntax?.[0]?.[0] ?? null,
+        error: `could not match allOf: ${syntax.reduce((acc, curr) => acc + '[' + curr.reduce((acc, curr) => acc + renderSyntax(curr), '') + ']', '')}`,
+        context: success ? con : context
+    };
+}
+function flatten(syntax) {
+    const stack = [syntax.l, syntax.r];
+    const data = [];
+    let s;
+    let i = 0;
+    for (; i < stack.length; i++) {
+        if (stack[i].length == 1 && stack[i][0].typ == syntax.typ) {
+            s = stack[i][0];
+            stack.splice(i--, 1, s.l, s.r);
+        }
+        else {
+            data.push(stack[i]);
+        }
     }
-    // @ts-ignore
-    return result;
+    return data;
 }
 
-export { validateSyntax };
+export { createContext, doEvaluateSyntax, evaluateSyntax };