@tbela99/css-parser 1.0.0 → 1.1.1-alpha4

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

@@ -1,20 +1,14 @@
 import { ValidationTokenEnum } from './types.js';
 import { isIdent, isPseudo } from '../../syntax/syntax.js';
+import { getTokenType as getTokenType$1 } from '../../parser/parse.js';
+import '../../parser/tokenize.js';
+import '../../parser/utils/config.js';
+import { EnumToken } from '../../ast/types.js';
+import '../../ast/minify.js';
+import '../../ast/walk.js';
+import '../../renderer/color/utils/constants.js';
+import '../../renderer/sourcemap/lib/encode.js';
 
-var WalkValidationTokenEnum;
-(function (WalkValidationTokenEnum) {
-    WalkValidationTokenEnum[WalkValidationTokenEnum["IgnoreChildren"] = 0] = "IgnoreChildren";
-    WalkValidationTokenEnum[WalkValidationTokenEnum["IgnoreNode"] = 1] = "IgnoreNode";
-    WalkValidationTokenEnum[WalkValidationTokenEnum["IgnoreAll"] = 2] = "IgnoreAll";
-})(WalkValidationTokenEnum || (WalkValidationTokenEnum = {}));
-var WalkValidationTokenKeyTypeEnum;
-(function (WalkValidationTokenKeyTypeEnum) {
-    WalkValidationTokenKeyTypeEnum["Array"] = "array";
-    WalkValidationTokenKeyTypeEnum["Children"] = "chi";
-    WalkValidationTokenKeyTypeEnum["Left"] = "l";
-    WalkValidationTokenKeyTypeEnum["Right"] = "r";
-    WalkValidationTokenKeyTypeEnum["Prelude"] = "prelude";
-})(WalkValidationTokenKeyTypeEnum || (WalkValidationTokenKeyTypeEnum = {}));
 const skipped = [
     ValidationTokenEnum.Star,
     ValidationTokenEnum.HashMark,
@@ -28,18 +22,6 @@ const objectProperties = {
     writable: true,
     configurable: true
 };
-// syntaxes: keyword | <'property'> | <function>
-// "none | [ [<dashed-ident> || <try-tactic>] | inset-area( <'inset-area'> ) ]#"
-// ""
-// : "<outline-radius>{1,4} [ / <outline-radius>{1,4} ]?
-// ""
-// false | true
-// [ <mask-reference> || <position> [ / <bg-size> ]? || <repeat-style> || [ <box> | border | padding | content | text ] || [ <box> | border | padding | content ] ]#
-// false | true | green | pipe
-// keyword | <'property'> | <function>
-// [<dashed-ident> || <try-tactic>]
-// [ <mask-reference> || <position> [ / <bg-size> ]? || <repeat-style> || [ <box> | border | padding | content | text ] || [ <box> | border | padding | content ] ]#
-// none | [ [<dashed-ident> || <try-tactic>] | inset-area( <'inset-area'> ) ]
 function* tokenize(syntax, position = { ind: 0, lin: 1, col: 0 }, currentPosition = {
     ind: -1,
     lin: 1,
@@ -51,6 +33,13 @@ function* tokenize(syntax, position = { ind: 0, lin: 1, col: 0 }, currentPositio
         let chr = syntax.charAt(i);
         move(currentPosition, chr);
         switch (chr) {
+            case '∞':
+                if (buffer.length > 0) {
+                    yield getTokenType(buffer, position, currentPosition);
+                }
+                yield getTokenType(chr, position, currentPosition);
+                buffer = '';
+                break;
             case '\\':
                 if (buffer.length > 0) {
                     yield getTokenType(buffer, position, currentPosition);
@@ -181,66 +170,13 @@ function* tokenize(syntax, position = { ind: 0, lin: 1, col: 0 }, currentPositio
         yield getTokenType(buffer, position, currentPosition);
     }
 }
-function columnCallback(token, parent, key) {
-    if (key == WalkValidationTokenKeyTypeEnum.Prelude) {
-        return WalkValidationTokenEnum.IgnoreAll;
-    }
-    if (token.typ == ValidationTokenEnum.ColumnToken || token.typ == ValidationTokenEnum.Whitespace) {
-        return WalkValidationTokenEnum.IgnoreNode;
-    }
-    return WalkValidationTokenEnum.IgnoreChildren;
-}
-function toColumnArray(ast, parent) {
-    const result = new Map;
-    // @ts-ignore
-    for (const { token } of walkValidationToken(ast, null, columnCallback)) {
-        result.set(JSON.stringify(token), token);
-    }
-    const node = {
-        typ: ValidationTokenEnum.ColumnArrayToken,
-        chi: [...result.values()]
-    };
-    if (parent != null) {
-        replaceNode(parent, ast, node);
-    }
-    return node;
-}
-function replaceNode(parent, target, node) {
-    if ('l' in parent && parent.l == target) {
-        parent.l = node;
-    }
-    if ('r' in parent && parent.r == target) {
-        parent.r = node;
-    }
-    if ('chi' in parent) {
-        // @ts-ignore
-        for (let i = 0; i < parent.chi.length; i++) {
-            // @ts-ignore
-            if (parent.chi[i] == target) {
-                // @ts-ignore
-                parent.chi[i] = node;
-                break;
-            }
-        }
-    }
-}
-function transform(context) {
-    for (const { token, parent } of walkValidationToken(context)) {
-        switch (token.typ) {
-            case ValidationTokenEnum.ColumnToken:
-                toColumnArray(token, parent);
-                break;
-        }
-    }
-    return context;
-}
 function parseSyntax(syntax) {
     const root = Object.defineProperty({
         typ: ValidationTokenEnum.Root,
         chi: []
     }, 'pos', { ...objectProperties, value: { ind: 0, lin: 1, col: 0 } });
     // return minify(doParseSyntax(syntaxes, tokenize(syntaxes), root)) as ValidationRootToken;
-    return minify(transform(doParseSyntax(syntax, tokenize(syntax), root)));
+    return minify(doParseSyntax(syntax, tokenize(syntax), root));
 }
 function matchParens(syntax, iterator) {
     let item;
@@ -255,7 +191,7 @@ function matchParens(syntax, iterator) {
                 }
                 else if (match == 0) {
                     func = items.at(-1);
-                    if (func == null) {
+                    if (func == null || func.val == null || func.val === '') {
                         func = Object.defineProperty({
                             typ: ValidationTokenEnum.Parens,
                             val: '',
@@ -372,6 +308,10 @@ function matchCurlBraces(syntax, iterator) {
                 else {
                     items.push(item.value);
                 }
+                if ('chi' in item.value) {
+                    // @ts-ignore
+                    item.value.chi = matchCurlBraces(syntax, item.value.chi[Symbol.iterator]());
+                }
                 break;
         }
     }
@@ -382,7 +322,7 @@ function matchCurlBraces(syntax, iterator) {
         if (i > 0 && it.typ == ValidationTokenEnum.Block && it.chi[0]?.typ == ValidationTokenEnum.Number) {
             items[i - 1].occurence = {
                 min: +it.chi[0].val,
-                max: +(it.chi[2] ?? it.chi[0]).val
+                max: it.chi[2]?.typ == ValidationTokenEnum.InfinityToken ? Number.POSITIVE_INFINITY : +(it.chi[2] ?? it.chi[0]).val
             };
             items.splice(i--, 1);
             continue;
@@ -506,8 +446,17 @@ function matchAtRule(syntax, iterator) {
     return children;
 }
 function matchToken(syntax, iterator, validationToken) {
+    if (iterator.length == 0) {
+        return [];
+    }
+    if (Array.isArray(iterator[0])) {
+        const result = [];
+        for (let i = 0; i < iterator.length; i++) {
+            result.push(matchToken(syntax, iterator[i], validationToken));
+        }
+        return result;
+    }
     let children = [];
-    let item;
     let token = null;
     let i;
     if (validationToken == ValidationTokenEnum.Ampersand) {
@@ -538,42 +487,44 @@ function matchToken(syntax, iterator, validationToken) {
             }
             else if ('chi' in children[i]) {
                 // @ts-ignore
-                children[i].chi = matchToken(syntax, children[i].chi[Symbol.iterator](), validationToken);
+                children[i].chi = matchToken(syntax, children[i].chi, validationToken);
             }
             else if ('l' in children[i]) {
                 // @ts-ignore
-                children[i].l = matchToken(syntax, children[i].l[Symbol.iterator](), validationToken);
+                children[i].l = matchToken(syntax, children[i].l, validationToken);
                 // @ts-ignore
-                children[i].r = matchToken(syntax, children[i].r[Symbol.iterator](), validationToken);
+                children[i].r = matchToken(syntax, children[i].r, validationToken);
             }
         }
         return children;
     }
-    while ((item = iterator.next()) && !item.done) {
-        if (item.value.typ == validationToken) {
-            if (item.value.typ == ValidationTokenEnum.Pipe) {
+    let item;
+    for (i = 0; i < iterator.length; i++) {
+        item = iterator[i];
+        if (item.typ == validationToken) {
+            if (item.typ == ValidationTokenEnum.Pipe) {
                 token = Object.defineProperty({
                     typ: ValidationTokenEnum.PipeToken,
-                    chi: [matchToken(syntax, children.slice()[Symbol.iterator](), validationToken)], //.concat(matchToken(syntaxes, children.slice()[Symbol.iterator]() as Iterator<ValidationTokenIteratorValue>, validationToken), matchToken(syntaxes, iterator, validationToken)),
+                    chi: [matchToken(syntax, children.slice(), validationToken)], //.concat(matchToken(syntaxes, children.slice()[Symbol.iterator]() as Iterator<ValidationTokenIteratorValue>, validationToken), matchToken(syntaxes, iterator, validationToken)),
                     // @ts-ignore
                     // l: matchToken(syntaxes, children.slice()[Symbol.iterator](), validationToken),
                     // r: matchToken(syntaxes, iterator, validationToken)
                 }, 'pos', {
                     ...objectProperties,
-                    value: item.value.pos
+                    value: item.pos
                 });
                 children.length = 0;
-                while ((item = iterator.next()) && !item.done) {
-                    if (item.value.typ == ValidationTokenEnum.Pipe) {
-                        token.chi.push(matchToken(syntax, children.slice()[Symbol.iterator](), validationToken));
+                while ((item = iterator[++i]) != null) {
+                    if (item.typ == ValidationTokenEnum.Pipe) {
+                        token.chi.push(matchToken(syntax, children.slice(), validationToken));
                         children.length = 0;
                     }
                     else {
-                        children.push(item.value);
+                        children.push(item);
                     }
                 }
                 if (children.length > 0) {
-                    token.chi.push(matchToken(syntax, children.slice()[Symbol.iterator](), validationToken));
+                    token.chi.push(matchToken(syntax, children.slice(), validationToken));
                 }
                 token.chi.sort((a, b) => {
                     if (a.some((t) => t.isList)) {
@@ -613,55 +564,56 @@ function matchToken(syntax, iterator, validationToken) {
             else {
                 token = Object.defineProperty({
                     typ: ValidationTokenEnum.ColumnToken,
-                    l: matchToken(syntax, children.slice()[Symbol.iterator](), validationToken),
-                    r: matchToken(syntax, iterator, validationToken)
+                    l: matchToken(syntax, children.slice(), validationToken),
+                    r: matchToken(syntax, iterator.slice(i + 1), validationToken)
                 }, 'pos', {
                     ...objectProperties,
-                    value: item.value.pos
+                    value: item.pos
                 });
+                i = iterator.length;
             }
             children.length = 0;
             children.push(token);
-            while ((item = iterator.next()) && !item.done) {
-                children.push(item.value);
-                if ('chi' in item.value) {
+            while ((item = iterator[++i]) != null) {
+                children.push(item);
+                if ('chi' in item) {
                     // @ts-ignore
-                    item.value.chi = matchToken(syntax, item.value.chi[Symbol.iterator](), validationToken);
+                    item.chi = matchToken(syntax, item.chi, validationToken);
                 }
-                else if ('l' in item.value) {
+                else if ('l' in item) {
                     // @ts-ignore
-                    item.value.l = matchToken(syntax, item.value.l[Symbol.iterator](), validationToken);
+                    item.l = matchToken(syntax, item.l, validationToken);
                     // @ts-ignore
-                    item.value.r = matchToken(syntax, item.value.r[Symbol.iterator](), validationToken);
+                    item.r = matchToken(syntax, item.r, validationToken);
                 }
             }
             // @ts-ignore
             return children;
         }
         else {
-            children.push(item.value);
-            if ('chi' in item.value) {
+            // @ts-ignore
+            children.push(item);
+            if ('chi' in item) {
                 // @ts-ignore
-                item.value.chi = matchToken(syntax, item.value.chi[Symbol.iterator](), validationToken);
+                item.chi = matchToken(syntax, item.chi, validationToken);
             }
-            else if ('l' in item.value) {
+            else if ('l' in item) {
+                item.l = matchToken(syntax, item.l, validationToken);
                 // @ts-ignore
-                item.value.l = matchToken(syntax, item.value.l[Symbol.iterator](), validationToken);
-                // @ts-ignore
-                item.value.r = matchToken(syntax, item.value.r[Symbol.iterator](), validationToken);
+                item.r = matchToken(syntax, item.r, validationToken);
             }
         }
     }
     return children;
 }
-function parseTokens(syntax, iterator) {
+function parseSyntaxTokens(syntax, iterator) {
     const items = [];
     let item;
     let i;
     while ((item = iterator.next()) && !item.done) {
         if (Array.isArray(item.value)) {
             // @ts-ignore
-            item.value = parseTokens(syntax, item.value[Symbol.iterator]());
+            item.value = parseSyntaxTokens(syntax, item.value[Symbol.iterator]());
         }
         switch (item.value.typ) {
             case ValidationTokenEnum.Star:
@@ -694,14 +646,14 @@ function parseTokens(syntax, iterator) {
                 else if (item.value.typ == ValidationTokenEnum.OpenCurlyBrace) {
                     items[i].occurence = {
                         min: 0,
-                        max: 0
+                        max: null
                     };
                     while ((item = iterator.next()) && !item.done) {
                         if (item.value.typ == ValidationTokenEnum.Number) {
                             // @ts-ignore
                             if (items[i].occurence.min == 0) {
                                 // @ts-ignore
-                                items[i].occurence.min = +item.value.val;
+                                items[i].occurence.min = items[i].occurence.max = +item.value.val;
                             }
                             else {
                                 // @ts-ignore
@@ -715,7 +667,7 @@ function parseTokens(syntax, iterator) {
                 }
                 break;
             case ValidationTokenEnum.Pipe:
-                item.value.chi = item.value.chi.map((t) => parseTokens(syntax, t[Symbol.iterator]()));
+                item.value.chi = item.value.chi.map((t) => parseSyntaxTokens(syntax, t[Symbol.iterator]()));
                 items.push(item.value);
                 break;
             default:
@@ -726,46 +678,39 @@ function parseTokens(syntax, iterator) {
     for (i = 0; i < items.length; i++) {
         if ('chi' in items[i]) {
             // @ts-ignore
-            items[i].chi = parseTokens(syntax, items[i].chi[Symbol.iterator]());
+            items[i].chi = parseSyntaxTokens(syntax, items[i].chi[Symbol.iterator]());
         }
         else if ('l' in items[i]) {
             // @ts-ignore
-            items[i].l = parseTokens(syntax, items[i].l[Symbol.iterator]());
+            items[i].l = parseSyntaxTokens(syntax, items[i].l[Symbol.iterator]());
             // @ts-ignore
-            items[i].r = parseTokens(syntax, items[i].r[Symbol.iterator]());
+            items[i].r = parseSyntaxTokens(syntax, items[i].r[Symbol.iterator]());
         }
-        if (items[i].isOptional || items[i].isRepeatable) {
-            if (i <= 1) {
-                let k = i;
-                while (++k < items.length) {
-                    if (items[k].typ == ValidationTokenEnum.Whitespace) {
-                        continue;
-                    }
-                    if (items[k].typ == ValidationTokenEnum.Comma) {
-                        items.splice(i, k - i + 1, Object.defineProperty({
-                            typ: ValidationTokenEnum.Bracket,
-                            chi: items.slice(i, k + 1)
-                        }, 'pos', { ...objectProperties, value: items[i].pos }));
-                    }
-                    break;
+        if (items[i].typ != ValidationTokenEnum.Bracket && (items[i].isOptional || items[i].isRepeatable)) {
+            let k = i;
+            while (--k > 0) {
+                if (items[k].typ == ValidationTokenEnum.Whitespace) {
+                    continue;
                 }
-            }
-            else {
-                let k = i;
-                while (--k > 0) {
-                    if (items[k].typ == ValidationTokenEnum.Whitespace) {
-                        continue;
+                if (items[k].typ == ValidationTokenEnum.Comma) {
+                    const wrapper = Object.defineProperty({
+                        typ: ValidationTokenEnum.Bracket,
+                        chi: items.slice(k, i + 1)
+                    }, 'pos', { ...objectProperties, value: items[k].pos });
+                    if (items[i].isOptional) {
+                        wrapper.isOptional = true;
+                        delete items[i].isOptional;
                     }
-                    if (items[k].typ == ValidationTokenEnum.Comma) {
-                        items.splice(k, i - k + 1, Object.defineProperty({
-                            typ: ValidationTokenEnum.Bracket,
-                            chi: items.slice(k, i + 1)
-                        }, 'pos', { ...objectProperties, value: items[k].pos }));
-                        i = k - 1;
+                    if (items[i].isRepeatable) {
+                        wrapper.isRepeatable = true;
+                        delete items[i].isRepeatable;
                     }
-                    break;
+                    items.splice(k, i - k + 1, wrapper);
+                    i = k - 1;
                 }
+                break;
             }
+            // }
         }
     }
     return items;
@@ -779,18 +724,24 @@ function doParseSyntax(syntax, iterator, context) {
     // @ts-ignore
     context.chi = matchCurlBraces(syntax, context.chi[Symbol.iterator]());
     // @ts-ignore
-    context.chi = matchToken(syntax, context.chi[Symbol.iterator](), ValidationTokenEnum.Column);
+    context.chi = matchToken(syntax, context.chi, ValidationTokenEnum.Pipe);
     // @ts-ignore
-    context.chi = matchToken(syntax, context.chi[Symbol.iterator](), ValidationTokenEnum.Pipe);
+    context.chi = matchToken(syntax, context.chi, ValidationTokenEnum.Column);
     // @ts-ignore
-    context.chi = parseTokens(syntax, context.chi[Symbol.iterator]());
+    context.chi = matchToken(syntax, context.chi, ValidationTokenEnum.Ampersand);
     // @ts-ignore
-    context.chi = matchToken(syntax, context.chi[Symbol.iterator](), ValidationTokenEnum.Ampersand);
+    context.chi = parseSyntaxTokens(syntax, context.chi[Symbol.iterator]());
     return context;
 }
 function getTokenType(token, position, currentPosition) {
     const pos = { ...position };
     Object.assign(position, currentPosition);
+    // '∞'
+    if (token == '\u221e') {
+        return Object.defineProperty({
+            typ: ValidationTokenEnum.InfinityToken,
+        }, 'pos', { ...objectProperties, value: pos });
+    }
     if (token.charAt(0) == '"' || token.charAt(0) == "'") {
         return Object.defineProperty({
             typ: ValidationTokenEnum.StringToken,
@@ -908,7 +859,7 @@ function getTokenType(token, position, currentPosition) {
     if (token.startsWith('<')) {
         // <number [1,1000]>
         // <length [0,∞]>
-        let match = token.match(/<([a-z0-9-]+)(\s+\[([0-9]+),(([0-9]+)|∞)\])?>/);
+        let match = token.match(/<([a-z0-9-]+)(\s+\[([0-9]+[a-zA-Z]*),(([0-9]+[a-zA-Z]*)|∞)\])?>/);
         if (match == null) {
             let match = token.match(/<([a-zA-Z0-9-]+)\(\)>/);
             if (match != null) {
@@ -920,10 +871,12 @@ function getTokenType(token, position, currentPosition) {
             throw new Error('invalid token at position: ' + position.lin + ':' + position.col + ' ' + token);
         }
         if (match[2] != null) {
+            const type = getTokenType$1(match[3]);
             return Object.defineProperty({
                 typ: ValidationTokenEnum.PropertyType,
                 val: match[1],
-                range: [+match[3], match[4] == '∞' ? Infinity : +match[4]]
+                unit: EnumToken[type.typ],
+                range: [+type.val, match[4] == '\u221e' ? null : +match[4]]
             }, 'pos', { ...objectProperties, value: pos });
         }
         return Object.defineProperty({
@@ -949,6 +902,104 @@ function move(position, chr) {
     }
     return position;
 }
+function renderSyntax(token, parent) {
+    let glue;
+    switch (token.typ) {
+        case ValidationTokenEnum.InfinityToken:
+            // '∞'
+            return '\u221e';
+        case ValidationTokenEnum.Root:
+            return token.chi.reduce((acc, curr) => acc + renderSyntax(curr), '');
+        case ValidationTokenEnum.Whitespace:
+            return ' ';
+        case ValidationTokenEnum.ValidationFunctionDefinition:
+            return '<' + token.val + '()>';
+        case ValidationTokenEnum.HashMark:
+            return '#';
+        case ValidationTokenEnum.Pipe:
+            return '|';
+        case ValidationTokenEnum.Column:
+            return '||';
+        case ValidationTokenEnum.PipeToken:
+            return token.chi.reduce((acc, curr) => acc + (acc.trim().length > 0 ? '|' : '') + curr.reduce((acc, curr) => acc + renderSyntax(curr), ''), '');
+        case ValidationTokenEnum.ColumnToken:
+        case ValidationTokenEnum.AmpersandToken:
+            glue = token.typ == ValidationTokenEnum.ColumnToken ? '||' : '&&';
+            return token.l.reduce((acc, curr) => acc + renderSyntax(curr), '') +
+                glue +
+                token.r.reduce((acc, curr) => acc + renderSyntax(curr), '');
+        case ValidationTokenEnum.Function:
+        case ValidationTokenEnum.PseudoClassFunctionToken:
+        case ValidationTokenEnum.Parens:
+            return token.val + '(' + token.chi.reduce((acc, curr) => acc + renderSyntax(curr), '') + ')' + renderAttributes(token);
+        case ValidationTokenEnum.Comma:
+            return ',';
+        case ValidationTokenEnum.Keyword:
+            return token.val + renderAttributes(token);
+        case ValidationTokenEnum.OpenBracket:
+            return '[';
+        case ValidationTokenEnum.Ampersand:
+            return '&&';
+        case ValidationTokenEnum.QuestionMark:
+            return '?';
+        case ValidationTokenEnum.Separator:
+            return '/';
+        case ValidationTokenEnum.Bracket:
+            return '[' + token.chi.reduce((acc, curr) => acc + renderSyntax(curr), '') + ']' + renderAttributes(token);
+        case ValidationTokenEnum.PropertyType:
+            return '<' + token.val + (Array.isArray(token.range) ? `[${token?.range?.[0]}, ${token?.range?.[1] ?? '\u221e'}]` : '') + '>' + renderAttributes(token);
+        case ValidationTokenEnum.DeclarationType:
+            return "<'" + token.val + "'>" + renderAttributes(token);
+        case ValidationTokenEnum.Number:
+        case ValidationTokenEnum.PseudoClassToken:
+        case ValidationTokenEnum.StringToken:
+            return token.val + '';
+        case ValidationTokenEnum.SemiColon:
+            return ';';
+        case ValidationTokenEnum.AtRule:
+            return '@' + token.val;
+        case ValidationTokenEnum.AtRuleDefinition:
+            return '@' + token.val +
+                (token.prelude == null ? '' : ' ' + token.prelude.reduce((acc, curr) => acc + renderSyntax(curr), '')) +
+                (token.chi == null ? '' : ' {\n' + token.chi.reduce((acc, curr) => acc + renderSyntax(curr), '')).slice(1, -1) + '\n}';
+        case ValidationTokenEnum.Block:
+            return '{' + token.chi.reduce((acc, t) => acc + renderSyntax(t), '') + '}';
+        case ValidationTokenEnum.DeclarationDefinitionToken:
+            return token.nam + ': ' + renderSyntax(token.val);
+        // case ValidationTokenEnum.ColumnArrayToken:
+        //
+        //     return (token as ValidationColumnArrayToken).chi.reduce((acc: string, curr: ValidationToken) => acc + (acc.trim().length > 0 ? '||' : '') + renderSyntax(curr), '');
+        default:
+            throw new Error('Unhandled token: ' + JSON.stringify({ token }, null, 1));
+    }
+}
+function renderAttributes(token) {
+    let result = '';
+    if (token.isList) {
+        result += '#';
+    }
+    if (token.isOptional) {
+        result += '?';
+    }
+    if (token.isRepeatableGroup) {
+        result += '!';
+    }
+    if (token.isRepeatable) {
+        result += '*';
+    }
+    if (token.atLeastOnce) {
+        result += '+';
+    }
+    if (token.occurence != null) {
+        if (token.occurence.max == null || token.occurence.max == token.occurence.min || Number.isNaN(token.occurence.max)) {
+            result += '{' + token.occurence.min + '}';
+        }
+        else {
+            result += '{' + token.occurence.min + ',' + (Number.isFinite(token.occurence.max) ? token.occurence.max : '\u221e') + '}';
+        }
+    }
+    return result;
+}
 function minify(ast) {
     if (Array.isArray(ast)) {
         // @ts-ignore
@@ -960,20 +1011,7 @@ function minify(ast) {
             ast.pop();
         }
         for (let i = 0; i < ast.length; i++) {
-            // if ([ValidationTokenEnum.ColumnToken, ValidationTokenEnum.PipeToken, ValidationTokenEnum.AmpersandToken].includes(ast[i].typ)) {
-            // for (const j of (ast[i] as ValidationPipeToken | ValidationColumnToken | ValidationAmpersandToken).l) {
             minify(ast[i]);
-            // }
-            // for (const j of (ast[i] as ValidationPipeToken | ValidationColumnToken | ValidationAmpersandToken).r) {
-            //
-            //     minify(j);
-            // }
-            // } else
-            //     if ('chi' in ast[i]) {
-            //
-            //     minify((ast[i] as ValidationFunctionToken | ValidationBracketToken).chi as ValidationToken[]);
-            //
-            // } else
             if (ast[i].typ == ValidationTokenEnum.Whitespace && ast[i + 1]?.typ == ValidationTokenEnum.Whitespace) {
                 ast.splice(i + 1, 1);
                 i--;
@@ -990,14 +1028,9 @@ function minify(ast) {
         }
         return ast;
     }
-    // else {
-    // if ([ValidationTokenEnum.ColumnToken, ValidationTokenEnum.PipeToken, ValidationTokenEnum.AmpersandToken].includes(ast.typ)) {
-    // for (const j of (ast as ValidationPipeToken | ValidationColumnToken | ValidationAmpersandToken).l) {
     if ('l' in ast) {
         minify(ast.l);
     }
-    // }
-    // for (const j of (ast as ValidationPipeToken | ValidationColumnToken | ValidationAmpersandToken).r) {
     if ('r' in ast) {
         minify(ast.r);
     }
@@ -1009,44 +1042,5 @@ function minify(ast) {
     }
     return ast;
 }
-function* walkValidationToken(token, parent, callback, key) {
-    if (Array.isArray(token)) {
-        for (const child of token) {
-            yield* walkValidationToken(child, parent, callback, WalkValidationTokenKeyTypeEnum.Array);
-        }
-        return;
-    }
-    let action = null;
-    if (callback != null) {
-        // @ts-ignore
-        action = callback(token, parent, key);
-    }
-    if (action != WalkValidationTokenEnum.IgnoreNode && action != WalkValidationTokenEnum.IgnoreAll) {
-        yield { token, parent };
-    }
-    if (action != WalkValidationTokenEnum.IgnoreChildren && action != WalkValidationTokenEnum.IgnoreAll && 'prelude' in token) {
-        for (const child of token.prelude) {
-            yield* walkValidationToken(child, token, callback, WalkValidationTokenKeyTypeEnum.Prelude);
-        }
-    }
-    if (action != WalkValidationTokenEnum.IgnoreChildren && 'chi' in token) {
-        // @ts-ignore
-        for (const child of token.chi) {
-            yield* walkValidationToken(child, token, callback, WalkValidationTokenKeyTypeEnum.Children);
-        }
-    }
-    if (action != WalkValidationTokenEnum.IgnoreChildren && action != WalkValidationTokenEnum.IgnoreAll && 'l' in token) {
-        // @ts-ignore
-        for (const child of token.l) {
-            yield* walkValidationToken(child, token, callback, WalkValidationTokenKeyTypeEnum.Left);
-        }
-    }
-    if (action != WalkValidationTokenEnum.IgnoreChildren && action != WalkValidationTokenEnum.IgnoreAll && 'r' in token) {
-        // @ts-ignore
-        for (const child of token.r) {
-            yield* walkValidationToken(child, token, callback, WalkValidationTokenKeyTypeEnum.Right);
-        }
-    }
-}
 
-export { WalkValidationTokenEnum, WalkValidationTokenKeyTypeEnum, parseSyntax, walkValidationToken };
+export { parseSyntax, renderSyntax };

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

@@ -40,7 +40,7 @@ var ValidationTokenEnum;
     ValidationTokenEnum[ValidationTokenEnum["DeclarationDefinitionToken"] = 37] = "DeclarationDefinitionToken";
     ValidationTokenEnum[ValidationTokenEnum["SemiColon"] = 38] = "SemiColon";
     ValidationTokenEnum[ValidationTokenEnum["Character"] = 39] = "Character";
-    ValidationTokenEnum[ValidationTokenEnum["ColumnArrayToken"] = 40] = "ColumnArrayToken";
+    ValidationTokenEnum[ValidationTokenEnum["InfinityToken"] = 40] = "InfinityToken";
 })(ValidationTokenEnum || (ValidationTokenEnum = {}));
 var ValidationSyntaxGroupEnum;
 (function (ValidationSyntaxGroupEnum) {

package/dist/lib/validation/selector.js

@@ -2,14 +2,14 @@ import { EnumToken } from '../ast/types.js';
 import '../ast/minify.js';
 import '../ast/walk.js';
 import '../parser/parse.js';
+import '../parser/tokenize.js';
+import '../parser/utils/config.js';
 import '../renderer/color/utils/constants.js';
 import '../renderer/sourcemap/lib/encode.js';
-import '../parser/utils/config.js';
 import { validateRelativeSelectorList } from './syntaxes/relative-selector-list.js';
 import './syntaxes/complex-selector.js';
 import { validateKeyframeBlockList } from './syntaxes/keyframe-block-list.js';
-import './parser/types.js';
-import './parser/parse.js';
+import './syntax.js';
 import './config.js';
 import { validateSelectorList } from './syntaxes/selector-list.js';