@tbela99/css-parser 0.8.0 → 0.9.1

package/dist/lib/validation/declaration.js

@@ -5,7 +5,7 @@ import '../parser/parse.js';
 import '../renderer/color/utils/constants.js';
 import '../renderer/sourcemap/lib/encode.js';
 import '../parser/utils/config.js';
-import { getParsedSyntax, getSyntaxConfig } from './config.js';
+import { getSyntaxConfig, getParsedSyntax } from './config.js';
 import { validateSyntax } from './syntax.js';
 
 function validateDeclaration(declaration, options, root) {
@@ -21,6 +21,7 @@ function validateDeclaration(declaration, options, root) {
     }
     // root is at-rule - check if declaration allowed
     if (root?.typ == EnumToken.AtRuleNodeType) {
+        //
         const syntax = getParsedSyntax("atRules" /* ValidationSyntaxGroupEnum.AtRules */, '@' + root.nam)?.[0];
         if (syntax != null) {
             if (!('chi' in syntax)) {
@@ -39,15 +40,36 @@ function validateDeclaration(declaration, options, root) {
                     error: ''
                 };
             }
-            if (!(name in config.declarations) && !(name in config.syntaxes)) {
-                return {
-                    valid: ValidationLevel.Drop,
-                    node: declaration,
-                    syntax: null,
-                    error: `unknown declaration "${declaration.nam}"`
-                };
+            // console.error({syntax});
+            const config = getSyntaxConfig();
+            // @ts-ignore
+            const obj = config["atRules" /* ValidationSyntaxGroupEnum.AtRules */]['@' + root.nam];
+            if ('descriptors' in obj) {
+                const descriptors = obj.descriptors;
+                if (!(name in descriptors)) {
+                    return {
+                        valid: ValidationLevel.Drop,
+                        node: declaration,
+                        syntax: `<${declaration.nam}>`,
+                        error: `declaration <${declaration.nam}> is not allowed in <@${root.nam}>`
+                    };
+                }
+                const syntax = getParsedSyntax("atRules" /* ValidationSyntaxGroupEnum.AtRules */, ['@' + root.nam, 'descriptors', name]);
+                return validateSyntax(syntax, declaration.val, root, options);
             }
-            return validateSyntax(syntax.chi, [declaration], root, options);
+            // console.error({name});
+            //         if (!(name in config.declarations) && !(name in config.syntaxes)) {
+            //
+            //             return {
+            //
+            //                 valid: ValidationLevel.Drop,
+            //                 node: declaration,
+            //                 syntax: null,
+            //                 error: `unknown declaration "${declaration.nam}"`
+            //             }
+            //         }
+            //
+            //         return validateSyntax((syntax as ValidationAtRuleDefinitionToken).chi as ValidationToken[], [declaration], root, options);
         }
     }
     if (name.startsWith('--')) {
@@ -62,7 +84,7 @@ function validateDeclaration(declaration, options, root) {
         return {
             valid: ValidationLevel.Drop,
             node: declaration,
-            syntax: null,
+            syntax: `<${declaration.nam}>`,
             error: `unknown declaration "${declaration.nam}"`
         };
     }

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

@@ -1,6 +1,20 @@
 import { ValidationTokenEnum } from './types.js';
 import { isIdent, isPseudo } from '../../syntax/syntax.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,
@@ -167,13 +181,66 @@ 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(doParseSyntax(syntax, tokenize(syntax), root));
+    return minify(transform(doParseSyntax(syntax, tokenize(syntax), root)));
 }
 function matchParens(syntax, iterator) {
     let item;
@@ -882,96 +949,6 @@ function move(position, chr) {
     }
     return position;
 }
-function renderSyntax(token, parent) {
-    let glue;
-    switch (token.typ) {
-        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 + '>' + 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), '') + '}';
-        default:
-            throw new Error('Unhandled token: ' + JSON.stringify({ token }));
-    }
-}
-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 == 0 || token.occurence.max == token.occurence.min || Number.isNaN(token.occurence.max)) {
-            result += '{' + token.occurence.min + '}';
-        }
-        else {
-            result += '{' + token.occurence.min + ',' + token.occurence.max + '}';
-        }
-    }
-    return result;
-}
 function minify(ast) {
     if (Array.isArray(ast)) {
         // @ts-ignore
@@ -1032,37 +1009,44 @@ function minify(ast) {
     }
     return ast;
 }
-function* walkValidationToken(token, parent, callback) {
+function* walkValidationToken(token, parent, callback, key) {
     if (Array.isArray(token)) {
         for (const child of token) {
-            yield* walkValidationToken(child, parent);
+            yield* walkValidationToken(child, parent, callback, WalkValidationTokenKeyTypeEnum.Array);
         }
         return;
     }
-    yield { token, parent };
-    if ('prelude' in token) {
+    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);
+            yield* walkValidationToken(child, token, callback, WalkValidationTokenKeyTypeEnum.Prelude);
         }
     }
-    if ('chi' in token) {
+    if (action != WalkValidationTokenEnum.IgnoreChildren && 'chi' in token) {
         // @ts-ignore
         for (const child of token.chi) {
-            yield* walkValidationToken(child, token);
+            yield* walkValidationToken(child, token, callback, WalkValidationTokenKeyTypeEnum.Children);
         }
     }
-    if ('l' in token) {
+    if (action != WalkValidationTokenEnum.IgnoreChildren && action != WalkValidationTokenEnum.IgnoreAll && 'l' in token) {
         // @ts-ignore
         for (const child of token.l) {
-            yield* walkValidationToken(child, token);
+            yield* walkValidationToken(child, token, callback, WalkValidationTokenKeyTypeEnum.Left);
         }
     }
-    if ('r' in token) {
+    if (action != WalkValidationTokenEnum.IgnoreChildren && action != WalkValidationTokenEnum.IgnoreAll && 'r' in token) {
         // @ts-ignore
         for (const child of token.r) {
-            yield* walkValidationToken(child, token);
+            yield* walkValidationToken(child, token, callback, WalkValidationTokenKeyTypeEnum.Right);
         }
     }
 }
 
-export { parseSyntax, renderSyntax, walkValidationToken };
+export { WalkValidationTokenEnum, WalkValidationTokenKeyTypeEnum, parseSyntax, walkValidationToken };

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

@@ -1,4 +1,3 @@
-const specialValues = ['inherit', 'initial', 'unset', 'revert', 'revert-layer'];
 var ValidationTokenEnum;
 (function (ValidationTokenEnum) {
     ValidationTokenEnum[ValidationTokenEnum["Root"] = 0] = "Root";
@@ -41,6 +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 = {}));
 var ValidationSyntaxGroupEnum;
 (function (ValidationSyntaxGroupEnum) {
@@ -51,4 +51,4 @@ var ValidationSyntaxGroupEnum;
     ValidationSyntaxGroupEnum["AtRules"] = "atRules";
 })(ValidationSyntaxGroupEnum || (ValidationSyntaxGroupEnum = {}));
 
-export { ValidationSyntaxGroupEnum, ValidationTokenEnum, specialValues };
+export { ValidationSyntaxGroupEnum, ValidationTokenEnum };

package/dist/lib/validation/selector.js

@@ -8,11 +8,14 @@ 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 './config.js';
 import { validateSelectorList } from './syntaxes/selector-list.js';
 
 function validateSelector(selector, options, root) {
     if (root == null) {
-        return validateRelativeSelectorList(selector, root);
+        return validateSelectorList(selector, root, options);
     }
     // @ts-ignore
     if (root.typ == EnumToken.AtRuleNodeType && root.nam.match(/^(-[a-z]+-)?keyframes$/)) {
@@ -25,14 +28,14 @@ function validateSelector(selector, options, root) {
             isNested++;
             if (isNested > 0) {
                 // @ts-ignore
-                return validateRelativeSelectorList(selector, root, { nestedSelector: true });
+                return validateRelativeSelectorList(selector, root, { ...(options ?? {}), nestedSelector: true });
             }
         }
         currentRoot = currentRoot.parent;
     }
     const nestedSelector = isNested > 0;
     // @ts-ignore
-    return nestedSelector ? validateRelativeSelectorList(selector, root, { nestedSelector }) : validateSelectorList(selector, root, { nestedSelector });
+    return nestedSelector ? validateRelativeSelectorList(selector, root, { ...(options ?? {}), nestedSelector }) : validateSelectorList(selector, root, { ...(options ?? {}), nestedSelector });
 }
 
 export { validateSelector };

package/dist/lib/validation/syntax.js

@@ -1,15 +1,16 @@
 import { ValidationTokenEnum, specialValues } from './parser/types.js';
-import './parser/parse.js';
+import { renderSyntax } from './parser/parse.js';
 import { ValidationLevel, EnumToken, funcLike } from '../ast/types.js';
 import '../ast/minify.js';
 import '../ast/walk.js';
 import '../parser/parse.js';
 import { isLength } from '../syntax/syntax.js';
 import '../parser/utils/config.js';
-import '../renderer/color/utils/constants.js';
-import '../renderer/sourcemap/lib/encode.js';
-import { getParsedSyntax, getSyntaxConfig } from './config.js';
+import { renderToken } from '../renderer/render.js';
+import { getSyntaxConfig, getParsedSyntax } from './config.js';
 import { validateSelector } from './selector.js';
+import './syntaxes/complex-selector.js';
+import { validateImage } from './syntaxes/image.js';
 
 const config = getSyntaxConfig();
 function consumeToken(tokens) {
@@ -30,6 +31,12 @@ function splice(tokens, matches) {
     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 {
@@ -485,7 +492,7 @@ function validateSyntax(syntaxes, tokens, root, options, context = { level: 0 })
     return result;
 }
 function isOptionalSyntax(syntaxes) {
-    return 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 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) ?? [])));
 }
 function doValidateSyntax(syntax, token, tokens, root, options, context) {
     let valid = false;
@@ -706,7 +713,21 @@ function doValidateSyntax(syntax, token, tokens, root, options, context) {
             break;
         case ValidationTokenEnum.PropertyType:
             //
-            if (['media-feature', 'mf-plain'].includes(syntax.val)) {
+            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,
@@ -751,6 +772,18 @@ function doValidateSyntax(syntax, token, tokens, 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,
@@ -1357,6 +1390,41 @@ function doValidateSyntax(syntax, token, tokens, root, options, context) {
                 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
+                };
+            }
+            break;
         case ValidationTokenEnum.ColumnToken:
             children = [...syntax.l.slice(), ...syntax.r.slice()];
             matches = [];
@@ -1419,6 +1487,18 @@ function doValidateSyntax(syntax, token, tokens, root, options, context) {
                 tokens
             };
             break;
+        case ValidationTokenEnum.DeclarationDefinitionToken:
+            if (token.typ != EnumToken.DeclarationNodeType || token.nam != syntax.nam) {
+                return {
+                    valid: ValidationLevel.Drop,
+                    matches: [],
+                    node: token,
+                    syntax,
+                    error: '',
+                    tokens
+                };
+            }
+            return validateSyntax([syntax.val], token.val, root, options, context);
         default:
             throw new Error('not implemented: ' + JSON.stringify({ syntax, token, tokens }, null, 1));
     }

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

@@ -1,4 +1,4 @@
-import { ValidationLevel, EnumToken } from '../../ast/types.js';
+import { ValidationLevel } from '../../ast/types.js';
 import '../../ast/minify.js';
 import '../../ast/walk.js';
 import '../../parser/parse.js';
@@ -7,6 +7,7 @@ import '../../renderer/sourcemap/lib/encode.js';
 import '../../parser/utils/config.js';
 import { validateSelector } from './selector.js';
 import { consumeWhitespace } from '../utils/whitespace.js';
+import { splitTokenList } from '../utils/list.js';
 
 function validateComplexSelectorList(tokens, root, options) {
     tokens = tokens.slice();
@@ -22,20 +23,23 @@ function validateComplexSelectorList(tokens, root, options) {
             tokens
         };
     }
-    let i = -1;
-    let j = 0;
     let result = null;
-    while (i + 1 < tokens.length) {
-        if (tokens[++i].typ == EnumToken.CommaTokenType) {
-            result = validateSelector(tokens.slice(j, i), root, options);
-            if (result.valid == ValidationLevel.Drop) {
-                return result;
-            }
-            j = i + 1;
-            i = j;
+    for (const t of splitTokenList(tokens)) {
+        result = validateSelector(t, root, options);
+        if (result.valid == ValidationLevel.Drop) {
+            return result;
         }
     }
-    return validateSelector(i == j ? tokens.slice(i) : tokens.slice(j, i + 1), root, options);
+    // @ts-ignore
+    return result ?? {
+        valid: ValidationLevel.Drop,
+        matches: [],
+        // @ts-ignore
+        node: root,
+        syntax: null,
+        error: 'expecting complex selector list',
+        tokens
+    };
 }
 
 export { validateComplexSelectorList };