@tbela99/css-parser 0.7.0 → 0.8.0

package/dist/lib/validation/at-rules/namespace.js

@@ -0,0 +1,85 @@
+import { ValidationLevel, EnumToken } from '../../ast/types.js';
+import '../../ast/minify.js';
+import '../../ast/walk.js';
+import '../../parser/parse.js';
+import '../../renderer/color/utils/constants.js';
+import '../../renderer/sourcemap/lib/encode.js';
+import '../../parser/utils/config.js';
+import { consumeWhitespace } from '../utils/whitespace.js';
+import { validateURL } from '../syntaxes/url.js';
+
+function validateAtRuleNamespace(atRule, options, root) {
+    if (!Array.isArray(atRule.tokens) || atRule.tokens.length == 0) {
+        // @ts-ignore
+        return {
+            valid: ValidationLevel.Drop,
+            matches: [],
+            node: atRule,
+            syntax: '@namespace',
+            error: 'expected at-rule prelude',
+            tokens: []
+        };
+    }
+    if ('chi' in atRule) {
+        // @ts-ignore
+        return {
+            valid: ValidationLevel.Drop,
+            matches: [],
+            node: atRule,
+            syntax: '@namespace',
+            error: 'unexpected at-rule body',
+            tokens: []
+        };
+    }
+    const tokens = atRule.tokens.slice();
+    consumeWhitespace(tokens);
+    if (tokens[0].typ == EnumToken.IdenTokenType) {
+        tokens.shift();
+        consumeWhitespace(tokens);
+    }
+    if (tokens.length == 0) {
+        // @ts-ignore
+        return {
+            valid: ValidationLevel.Drop,
+            matches: [],
+            node: atRule,
+            syntax: '@namespace',
+            error: 'expected string or url()',
+            tokens
+        };
+    }
+    if (tokens[0].typ != EnumToken.StringTokenType) {
+        const result = validateURL(tokens[0]);
+        if (result.valid != ValidationLevel.Valid) {
+            return result;
+        }
+        tokens.shift();
+        consumeWhitespace(tokens);
+    }
+    else {
+        tokens.shift();
+        consumeWhitespace(tokens);
+    }
+    if (tokens.length > 0) {
+        // @ts-ignore
+        return {
+            valid: ValidationLevel.Drop,
+            matches: [],
+            node: tokens[0],
+            syntax: '@namespace',
+            error: 'unexpected token',
+            tokens
+        };
+    }
+    // @ts-ignore
+    return {
+        valid: ValidationLevel.Valid,
+        matches: [],
+        node: atRule,
+        syntax: '@namespace',
+        error: '',
+        tokens
+    };
+}
+
+export { validateAtRuleNamespace };

package/dist/lib/validation/at-rules/page-margin-box.js

@@ -0,0 +1,56 @@
+import { ValidationLevel, EnumToken } from '../../ast/types.js';
+import '../../ast/minify.js';
+import '../../ast/walk.js';
+import '../../parser/parse.js';
+import '../../renderer/color/utils/constants.js';
+import '../../renderer/sourcemap/lib/encode.js';
+import '../../parser/utils/config.js';
+
+function validateAtRulePageMarginBox(atRule, options, root) {
+    if (Array.isArray(atRule.tokens) && atRule.tokens.length > 0) {
+        // @ts-ignore
+        return {
+            valid: ValidationLevel.Valid,
+            matches: [],
+            node: null,
+            syntax: '@' + atRule.nam,
+            error: '',
+            tokens: []
+        };
+    }
+    if (!('chi' in atRule)) {
+        // @ts-ignore
+        return {
+            valid: ValidationLevel.Drop,
+            matches: [],
+            node: atRule,
+            syntax: '@' + atRule.nam,
+            error: 'expected margin-box body',
+            tokens: []
+        };
+    }
+    for (const token of atRule.chi) {
+        if (![EnumToken.DeclarationNodeType, EnumToken.CommentNodeType, EnumToken.WhitespaceTokenType].includes(token.typ)) {
+            // @ts-ignore
+            return {
+                valid: ValidationLevel.Drop,
+                matches: [],
+                node: token,
+                syntax: 'declaration-list',
+                error: 'expected margin-box body',
+                tokens: []
+            };
+        }
+    }
+    // @ts-ignore
+    return {
+        valid: ValidationLevel.Valid,
+        matches: [],
+        node: null,
+        syntax: '@' + atRule.nam,
+        error: '',
+        tokens: []
+    };
+}
+
+export { validateAtRulePageMarginBox };

package/dist/lib/validation/at-rules/page.js

@@ -0,0 +1,88 @@
+import { ValidationLevel, EnumToken } from '../../ast/types.js';
+import '../../ast/minify.js';
+import '../../ast/walk.js';
+import '../../parser/parse.js';
+import '../../renderer/color/utils/constants.js';
+import '../../renderer/sourcemap/lib/encode.js';
+import '../../parser/utils/config.js';
+import { splitTokenList } from '../utils/list.js';
+
+function validateAtRulePage(atRule, options, root) {
+    // media-query-list
+    if (!Array.isArray(atRule.tokens) || atRule.tokens.length == 0) {
+        // @ts-ignore
+        return {
+            valid: ValidationLevel.Valid,
+            matches: [],
+            node: null,
+            syntax: '@page',
+            error: '',
+            tokens: []
+        };
+    }
+    // page-selector-list
+    for (const tokens of splitTokenList(atRule.tokens)) {
+        if (tokens.length == 0) {
+            // @ts-ignore
+            return {
+                valid: ValidationLevel.Drop,
+                matches: [],
+                node: tokens[0] ?? atRule,
+                syntax: '@page',
+                error: 'unexpected token',
+                tokens: []
+            };
+        }
+        // <pseudo-page>+ | <ident> <pseudo-page>*
+        // ident pseudo-page* | pseudo-page+
+        if (tokens[0].typ == EnumToken.IdenTokenType) {
+            tokens.shift();
+            if (tokens.length == 0) {
+                continue;
+            }
+            // @ts-ignore
+            if (tokens[0].typ != EnumToken.WhitespaceTokenType) {
+                // @ts-ignore
+                return {
+                    valid: ValidationLevel.Drop,
+                    matches: [],
+                    node: tokens[0] ?? atRule,
+                    syntax: '@page',
+                    error: 'unexpected token',
+                    tokens: []
+                };
+            }
+        }
+        while (tokens.length > 0) {
+            if (tokens[0].typ == EnumToken.PseudoPageTokenType) {
+                tokens.shift();
+                if (tokens.length == 0) {
+                    continue;
+                }
+                // @ts-ignore
+                if (tokens[0].typ != EnumToken.WhitespaceTokenType) {
+                    // @ts-ignore
+                    return {
+                        valid: ValidationLevel.Drop,
+                        matches: [],
+                        node: tokens[0] ?? atRule,
+                        syntax: '@page',
+                        error: 'unexpected token',
+                        tokens: []
+                    };
+                }
+            }
+        }
+    }
+    // @ts-ignore
+    return {
+        valid: ValidationLevel.Valid,
+        matches: [],
+        node: atRule,
+        syntax: '@page',
+        error: '',
+        tokens: []
+    };
+}
+
+export { validateAtRulePage };

package/dist/lib/validation/at-rules/supports.js

@@ -0,0 +1,262 @@
+import { ValidationLevel, EnumToken } from '../../ast/types.js';
+import '../../ast/minify.js';
+import '../../ast/walk.js';
+import '../../parser/parse.js';
+import { colorFontTech, fontFeaturesTech, fontFormat } from '../../syntax/syntax.js';
+import '../../parser/utils/config.js';
+import '../../renderer/color/utils/constants.js';
+import '../../renderer/sourcemap/lib/encode.js';
+import { consumeWhitespace } from '../utils/whitespace.js';
+import { splitTokenList } from '../utils/list.js';
+import { validateSyntax } from '../syntax.js';
+import { getParsedSyntax } from '../config.js';
+
+function validateAtRuleSupports(atRule, options, root) {
+    // media-query-list
+    if (!Array.isArray(atRule.tokens) || atRule.tokens.length == 0) {
+        // @ts-ignore
+        return {
+            valid: ValidationLevel.Drop,
+            matches: [],
+            node: atRule,
+            syntax: '@supports',
+            error: 'expected supports query list',
+            tokens: []
+        };
+    }
+    const result = validateAtRuleSupportsConditions(atRule, atRule.tokens);
+    if (result) {
+        if (result.node == null) {
+            result.node = atRule;
+        }
+        return result;
+    }
+    if (!('chi' in atRule)) {
+        // @ts-ignore
+        return {
+            valid: ValidationLevel.Drop,
+            matches: [],
+            node: atRule,
+            syntax: '@supports',
+            error: 'expected at-rule body',
+            tokens: []
+        };
+    }
+    // @ts-ignore
+    return {
+        valid: ValidationLevel.Valid,
+        matches: [],
+        node: atRule,
+        syntax: '@supports',
+        error: '',
+        tokens: []
+    };
+}
+function validateAtRuleSupportsConditions(atRule, tokenList) {
+    for (const tokens of splitTokenList(tokenList)) {
+        if (tokens.length == 0) {
+            // @ts-ignore
+            return {
+                valid: ValidationLevel.Drop,
+                matches: [],
+                node: tokens[0] ?? atRule,
+                syntax: '@supports',
+                error: 'unexpected token',
+                tokens: []
+            };
+        }
+        let previousToken = null;
+        let result = null;
+        while (tokens.length > 0) {
+            result = validateSupportCondition(atRule, tokens[0]);
+            // supports-condition
+            if (result == null || result.valid == ValidationLevel.Valid) {
+                previousToken = tokens[0];
+                tokens.shift();
+            }
+            else {
+                result = validateSupportFeature(tokens[0]);
+                if (result == null || result.valid == ValidationLevel.Valid) {
+                    previousToken = tokens[0];
+                    tokens.shift();
+                }
+                else {
+                    return result;
+                }
+            }
+            if (tokens.length == 0) {
+                break;
+            }
+            if (!consumeWhitespace(tokens)) {
+                if (previousToken?.typ != EnumToken.ParensTokenType) {
+                    // @ts-ignore
+                    return {
+                        valid: ValidationLevel.Drop,
+                        matches: [],
+                        node: tokens[0] ?? previousToken ?? atRule,
+                        syntax: '@supports',
+                        error: 'expected whitespace',
+                        tokens: []
+                    };
+                }
+            }
+            if (![EnumToken.MediaFeatureOrTokenType, EnumToken.MediaFeatureAndTokenType].includes(tokens[0].typ)) {
+                // @ts-ignore
+                return {
+                    valid: ValidationLevel.Drop,
+                    matches: [],
+                    node: tokens[0] ?? atRule,
+                    syntax: '@supports',
+                    error: 'expected and/or',
+                    tokens: []
+                };
+            }
+            if (tokens.length == 1) {
+                // @ts-ignore
+                return {
+                    valid: ValidationLevel.Drop,
+                    matches: [],
+                    node: tokens[0] ?? atRule,
+                    syntax: '@supports',
+                    error: 'expected supports-condition',
+                    tokens: []
+                };
+            }
+            tokens.shift();
+            if (!consumeWhitespace(tokens)) {
+                // @ts-ignore
+                return {
+                    valid: ValidationLevel.Drop,
+                    matches: [],
+                    node: tokens[0] ?? atRule,
+                    syntax: '@supports',
+                    error: 'expected whitespace',
+                    tokens: []
+                };
+            }
+        }
+    }
+    return null;
+}
+function validateSupportCondition(atRule, token) {
+    if (token.typ == EnumToken.MediaFeatureNotTokenType) {
+        return validateSupportCondition(atRule, token.val);
+    }
+    if (token.typ != EnumToken.ParensTokenType) {
+        // @ts-ignore
+        return {
+            valid: ValidationLevel.Drop,
+            matches: [],
+            node: token,
+            syntax: '@supports',
+            error: 'expected supports condition-in-parens',
+            tokens: []
+        };
+    }
+    const chi = token.chi.filter((t) => t.typ != EnumToken.CommentTokenType && t.typ != EnumToken.WhitespaceTokenType);
+    if (chi.length != 1) {
+        return validateAtRuleSupportsConditions(atRule, token.chi);
+    }
+    if (chi[0].typ == EnumToken.IdenTokenType) {
+        // @ts-ignore
+        return {
+            valid: ValidationLevel.Valid,
+            matches: [],
+            node: null,
+            syntax: '@supports',
+            error: '',
+            tokens: []
+        };
+    }
+    if (chi[0].typ == EnumToken.MediaFeatureNotTokenType) {
+        return validateSupportCondition(atRule, chi[0].val);
+    }
+    if (chi[0].typ == EnumToken.MediaQueryConditionTokenType) {
+        // @ts-ignore
+        return chi[0].l.typ == EnumToken.IdenTokenType && chi[0].op.typ == EnumToken.ColonTokenType ?
+            {
+                valid: ValidationLevel.Valid,
+                matches: [],
+                node: null,
+                syntax: 'supports-condition',
+                error: '',
+                tokens: []
+            } : {
+            valid: ValidationLevel.Drop,
+            matches: [],
+            node: token,
+            syntax: 'supports-condition',
+            error: 'expected supports condition-in-parens',
+            tokens: []
+        };
+    }
+    // @ts-ignore
+    return {
+        valid: ValidationLevel.Drop,
+        matches: [],
+        node: token,
+        syntax: 'supports-condition',
+        error: 'expected supports condition-in-parens',
+        tokens: []
+    };
+}
+function validateSupportFeature(token) {
+    if (token.typ == EnumToken.FunctionTokenType) {
+        if (token.val.localeCompare('selector', undefined, { sensitivity: 'base' }) == 0) {
+            return validateSyntax(getParsedSyntax("syntaxes" /* ValidationSyntaxGroupEnum.Syntaxes */, 'complex-selector'), token.chi);
+        }
+        if (token.val.localeCompare('font-tech', undefined, { sensitivity: 'base' }) == 0) {
+            const chi = token.chi.filter((t) => ![EnumToken.WhitespaceTokenType, EnumToken.CommentTokenType].includes(t.typ));
+            // @ts-ignore
+            return chi.length == 1 && chi[0].typ == EnumToken.IdenTokenType && colorFontTech.concat(fontFeaturesTech).some((t) => t.localeCompare(chi[0].val, undefined, { sensitivity: 'base' }) == 0) ?
+                {
+                    valid: ValidationLevel.Valid,
+                    matches: [],
+                    node: token,
+                    syntax: 'font-tech',
+                    error: '',
+                    tokens: []
+                } :
+                {
+                    valid: ValidationLevel.Drop,
+                    matches: [],
+                    node: token,
+                    syntax: 'font-tech',
+                    error: 'expected font-tech',
+                    tokens: []
+                };
+        }
+        if (token.val.localeCompare('font-format', undefined, { sensitivity: 'base' }) == 0) {
+            const chi = token.chi.filter((t) => ![EnumToken.WhitespaceTokenType, EnumToken.CommentTokenType].includes(t.typ));
+            // @ts-ignore
+            return chi.length == 1 && chi[0].typ == EnumToken.IdenTokenType && fontFormat.some((t) => t.localeCompare(chi[0].val, undefined, { sensitivity: 'base' }) == 0) ?
+                {
+                    valid: ValidationLevel.Valid,
+                    matches: [],
+                    node: token,
+                    syntax: 'font-format',
+                    error: '',
+                    tokens: []
+                } :
+                {
+                    valid: ValidationLevel.Drop,
+                    matches: [],
+                    node: token,
+                    syntax: 'font-format',
+                    error: 'expected font-format',
+                    tokens: []
+                };
+        }
+    }
+    // @ts-ignore
+    return {
+        valid: ValidationLevel.Drop,
+        matches: [],
+        node: token,
+        syntax: '@supports',
+        error: 'expected feature',
+        tokens: []
+    };
+}
+
+export { validateAtRuleSupports, validateAtRuleSupportsConditions, validateSupportCondition };

package/dist/lib/validation/atrule.js

@@ -0,0 +1,172 @@
+import { ValidationLevel, EnumToken } from '../ast/types.js';
+import '../ast/minify.js';
+import '../ast/walk.js';
+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 { validateAtRuleMedia } from './at-rules/media.js';
+import { validateAtRuleCounterStyle } from './at-rules/counter-style.js';
+import { validateAtRulePage } from './at-rules/page.js';
+import { validateAtRulePageMarginBox } from './at-rules/page-margin-box.js';
+import { validateAtRuleSupports } from './at-rules/supports.js';
+import { validateAtRuleImport } from './at-rules/import.js';
+import { validateAtRuleLayer } from './at-rules/layer.js';
+import { validateAtRuleFontFeatureValues } from './at-rules/font-feature-values.js';
+import { validateAtRuleNamespace } from './at-rules/namespace.js';
+import { validateAtRuleDocument } from './at-rules/document.js';
+import { validateAtRuleKeyframes } from './at-rules/keyframes.js';
+
+function validateAtRule(atRule, options, root) {
+    if (atRule.nam == 'charset') {
+        const valid = atRule.val.match(/^"[a-zA-Z][a-zA-Z0-9_-]+"$/i) != null;
+        return {
+            valid: valid ? ValidationLevel.Valid : ValidationLevel.Drop,
+            node: atRule,
+            syntax: null,
+            error: ''
+        };
+    }
+    if (atRule.nam == 'keyframes') {
+        return validateAtRuleKeyframes(atRule);
+    }
+    if (['font-face', 'view-transition', 'starting-style'].includes(atRule.nam)) {
+        return {
+            valid: ValidationLevel.Valid,
+            node: atRule,
+            syntax: '@' + atRule.nam,
+            error: ''
+        };
+    }
+    if (atRule.nam == 'media') {
+        return validateAtRuleMedia(atRule);
+    }
+    if (atRule.nam == 'import') {
+        return validateAtRuleImport(atRule);
+    }
+    if (atRule.nam == 'supports') {
+        return validateAtRuleSupports(atRule);
+    }
+    if (atRule.nam == 'counter-style') {
+        return validateAtRuleCounterStyle(atRule);
+    }
+    if (atRule.nam == 'layer') {
+        return validateAtRuleLayer(atRule);
+    }
+    if (atRule.nam == 'font-feature-values') {
+        return validateAtRuleFontFeatureValues(atRule);
+    }
+    if (atRule.nam == 'namespace') {
+        return validateAtRuleNamespace(atRule);
+    }
+    if (atRule.nam == 'document') {
+        return validateAtRuleDocument(atRule);
+    }
+    if (['position-try', 'property', 'font-palette-values'].includes(atRule.nam)) {
+        if (!('tokens' in atRule)) {
+            return {
+                valid: ValidationLevel.Drop,
+                node: atRule,
+                syntax: '@' + atRule.nam,
+                error: 'expected prelude'
+            };
+        }
+        if (!('chi' in atRule)) {
+            return {
+                valid: ValidationLevel.Drop,
+                node: atRule,
+                syntax: '@' + atRule.nam,
+                error: 'expected body'
+            };
+        }
+        const chi = atRule.tokens.filter((t) => t.typ != EnumToken.WhitespaceTokenType && t.typ != EnumToken.CommentTokenType);
+        if (chi.length != 1) {
+            return {
+                valid: ValidationLevel.Drop,
+                node: atRule,
+                syntax: '@' + atRule.nam,
+                error: 'expected ' + (atRule.nam == 'property' ? 'custom-property-name' : 'dashed-ident')
+            };
+        }
+        if (chi[0].typ != EnumToken.DashedIdenTokenType) {
+            // @ts-ignore
+            return {
+                valid: ValidationLevel.Drop,
+                node: atRule,
+                syntax: '@' + atRule.nam,
+                error: 'expected ' + (atRule.nam == 'property' ? 'custom-property-name' : 'dashed-ident')
+            };
+        }
+        // @ts-ignore
+        return {
+            valid: ValidationLevel.Valid,
+            node: atRule,
+            syntax: '@' + atRule.nam,
+            error: ''
+        };
+    }
+    // scope
+    if (atRule.nam == 'page') {
+        return validateAtRulePage(atRule);
+    }
+    if (['top-left-corner', 'top-left', 'top-center', 'top-right', 'top-right-corner', 'bottom-left-corner', 'bottom-left', 'bottom-center', 'bottom-right', 'bottom-right-corner', 'left-top', 'left-middle', 'left-bottom', 'right-top', 'right-middle', 'right-bottom'].includes(atRule.nam)) {
+        if (!(root == null || (root.typ == EnumToken.AtRuleNodeType && root.nam == 'page'))) {
+            // @ts-ignore
+            return {
+                valid: ValidationLevel.Drop,
+                node: atRule,
+                syntax: '@page',
+                error: 'not allowed here'
+            };
+        }
+        return validateAtRulePageMarginBox(atRule);
+    }
+    // handle keyframe as special case
+    // check if the node exists
+    const config = getSyntaxConfig();
+    let name = '@' + atRule.nam;
+    if (!(name in config.atRules)) {
+        if (name.charAt(1) == '-') {
+            name = name.replace(/@-[a-zA-Z]+-([a-zA-Z][a-zA-Z0-9_-]*)/, '@$1');
+        }
+    }
+    if (!(name in config.atRules)) {
+        //     if (root?.typ == EnumToken.AtRuleNodeType) {
+        //
+        //         const syntaxes: ValidationToken = (getParsedSyntax(ValidationSyntaxGroupEnum.AtRules, '@' + (root as AstAtRule).nam) as ValidationToken[])?.[0];
+        //
+        //         if ('chi' in syntaxes) {
+        //
+        //             return validateSyntax(syntaxes.chi as ValidationToken[], [atRule], root, options);
+        //         }
+        //     }
+        return {
+            valid: ValidationLevel.Drop,
+            node: atRule,
+            syntax: null,
+            error: 'unknown at-rule'
+        };
+    }
+    const syntax = getParsedSyntax("atRules" /* ValidationSyntaxGroupEnum.AtRules */, name)?.[0];
+    if ('chi' in syntax && !('chi' in atRule)) {
+        return {
+            valid: ValidationLevel.Drop,
+            node: atRule,
+            syntax,
+            error: 'missing at-rule body'
+        };
+    }
+    // if ('prelude' in syntax) {
+    //
+    //     return validateSyntax(syntax.prelude as ValidationToken[], atRule.tokens as Token[], root, options);
+    // }
+    return {
+        valid: ValidationLevel.Valid,
+        node: null,
+        syntax,
+        error: ''
+    };
+}
+
+export { validateAtRule };