@tbela99/css-parser 0.7.1 → 0.9.0

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

@@ -0,0 +1,45 @@
+import { ValidationLevel } 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 { validateSelector } from './selector.js';
+import { consumeWhitespace } from '../utils/whitespace.js';
+import { splitTokenList } from '../utils/list.js';
+
+function validateComplexSelectorList(tokens, root, options) {
+    tokens = tokens.slice();
+    consumeWhitespace(tokens);
+    if (tokens.length == 0) {
+        return {
+            valid: ValidationLevel.Drop,
+            matches: [],
+            // @ts-ignore
+            node: root,
+            syntax: null,
+            error: 'expecting complex selector list',
+            tokens
+        };
+    }
+    let result = null;
+    for (const t of splitTokenList(tokens)) {
+        result = validateSelector(t, root, options);
+        if (result.valid == ValidationLevel.Drop) {
+            return result;
+        }
+    }
+    // @ts-ignore
+    return result ?? {
+        valid: ValidationLevel.Drop,
+        matches: [],
+        // @ts-ignore
+        node: root,
+        syntax: null,
+        error: 'expecting complex selector list',
+        tokens
+    };
+}
+
+export { validateComplexSelectorList };

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

@@ -0,0 +1,53 @@
+import { consumeWhitespace } from '../utils/whitespace.js';
+import { splitTokenList } from '../utils/list.js';
+import { EnumToken, ValidationLevel } 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 { validateCompoundSelector } from './compound-selector.js';
+
+const combinatorsTokens = [EnumToken.ChildCombinatorTokenType, EnumToken.ColumnCombinatorTokenType,
+    // EnumToken.DescendantCombinatorTokenType,
+    EnumToken.NextSiblingCombinatorTokenType, EnumToken.SubsequentSiblingCombinatorTokenType];
+// <compound-selector> [ <combinator>? <compound-selector> ]*
+function validateComplexSelector(tokens, root, options) {
+    // [ <type-selector>? <subclass-selector>* [ <pseudo-element-selector> <pseudo-class-selector>* ]* ]!
+    tokens = tokens.slice();
+    consumeWhitespace(tokens);
+    if (tokens.length == 0) {
+        return {
+            valid: ValidationLevel.Drop,
+            matches: [],
+            // @ts-ignore
+            node: root,
+            syntax: null,
+            error: 'expected selector',
+            tokens
+        };
+    }
+    // const config = getSyntaxConfig();
+    //
+    // let match: number = 0;
+    let result = null;
+    // const combinators: EnumToken[] = combinatorsTokens.filter((t: EnumToken) => t != EnumToken.DescendantCombinatorTokenType);
+    for (const t of splitTokenList(tokens, combinatorsTokens)) {
+        result = validateCompoundSelector(t, root, options);
+        if (result.valid == ValidationLevel.Drop) {
+            return result;
+        }
+    }
+    // @ts-ignore
+    return result ?? {
+        valid: ValidationLevel.Drop,
+        matches: [],
+        node: root,
+        syntax: null,
+        error: 'expecting compound-selector',
+        tokens
+    };
+}
+
+export { combinatorsTokens, validateComplexSelector };

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

@@ -0,0 +1,226 @@
+import { ValidationLevel, EnumToken } from '../../ast/types.js';
+import '../../ast/minify.js';
+import '../../ast/walk.js';
+import '../../parser/parse.js';
+import { mozExtensions, webkitExtensions } 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 { getSyntaxConfig } from '../config.js';
+
+function validateCompoundSelector(tokens, root, options) {
+    if (tokens.length == 0) {
+        // @ts-ignore
+        return {
+            valid: ValidationLevel.Drop,
+            matches: [],
+            // @ts-ignore
+            node: root,
+            // @ts-ignore
+            syntax: null,
+            error: 'expected selector',
+            tokens
+        };
+    }
+    tokens = tokens.slice();
+    consumeWhitespace(tokens);
+    const config = getSyntaxConfig();
+    let match = 0;
+    let length = tokens.length;
+    while (tokens.length > 0) {
+        while (tokens.length > 0 && tokens[0].typ == EnumToken.NestingSelectorTokenType) {
+            if (!options?.nestedSelector) {
+                // @ts-ignore
+                return {
+                    valid: ValidationLevel.Drop,
+                    matches: [],
+                    // @ts-ignore
+                    node: tokens[0],
+                    syntax: null,
+                    error: 'nested selector not allowed',
+                    tokens
+                };
+            }
+            match++;
+            tokens.shift();
+            consumeWhitespace(tokens);
+        }
+        // <type-selector>
+        while (tokens.length > 0 &&
+            [
+                EnumToken.IdenTokenType,
+                EnumToken.NameSpaceAttributeTokenType,
+                EnumToken.ClassSelectorTokenType,
+                EnumToken.HashTokenType,
+                EnumToken.UniversalSelectorTokenType
+            ].includes(tokens[0].typ)) {
+            match++;
+            tokens.shift();
+            consumeWhitespace(tokens);
+        }
+        while (tokens.length > 0 && tokens[0].typ == EnumToken.PseudoClassFuncTokenType) {
+            if (!mozExtensions.has(tokens[0].val + '()') &&
+                !webkitExtensions.has(tokens[0].val + '()') &&
+                !((tokens[0].val + '()') in config.selectors)) {
+                if (!options?.lenient || /^(:?)-webkit-/.test(tokens[0].val)) {
+                    // @ts-ignore
+                    return {
+                        valid: ValidationLevel.Drop,
+                        matches: [],
+                        // @ts-ignore
+                        node: tokens[0],
+                        syntax: null,
+                        error: 'unknown pseudo-class: ' + tokens[0].val + '()',
+                        tokens
+                    };
+                }
+            }
+            match++;
+            tokens.shift();
+            consumeWhitespace(tokens);
+        }
+        while (tokens.length > 0 && tokens[0].typ == EnumToken.PseudoClassTokenType) {
+            const isPseudoElement = tokens[0].val.startsWith('::');
+            if (
+            // https://developer.mozilla.org/en-US/docs/Web/CSS/WebKit_Extensions#pseudo-elements
+            !(isPseudoElement && tokens[0].val.startsWith('::-webkit-')) &&
+                !mozExtensions.has(tokens[0].val) &&
+                !webkitExtensions.has(tokens[0].val) &&
+                !(tokens[0].val in config.selectors) &&
+                !(!isPseudoElement &&
+                    (':' + tokens[0].val) in config.selectors)) {
+                if (!options?.lenient || /^(:?)-webkit-/.test(tokens[0].val)) {
+                    // @ts-ignore
+                    return {
+                        valid: ValidationLevel.Drop,
+                        matches: [],
+                        // @ts-ignore
+                        node: tokens[0],
+                        syntax: null,
+                        error: 'unknown pseudo-class: ' + tokens[0].val,
+                        tokens
+                    };
+                }
+            }
+            match++;
+            tokens.shift();
+            consumeWhitespace(tokens);
+        }
+        while (tokens.length > 0 && tokens[0].typ == EnumToken.AttrTokenType) {
+            const children = tokens[0].chi.slice();
+            consumeWhitespace(children);
+            if (children.length == 0) {
+                // @ts-ignore
+                return {
+                    valid: ValidationLevel.Drop,
+                    matches: [],
+                    node: tokens[0],
+                    syntax: null,
+                    error: 'invalid attribute selector',
+                    tokens
+                };
+            }
+            if (![
+                EnumToken.IdenTokenType,
+                EnumToken.NameSpaceAttributeTokenType,
+                EnumToken.MatchExpressionTokenType
+            ].includes(children[0].typ)) {
+                // @ts-ignore
+                return {
+                    valid: ValidationLevel.Drop,
+                    matches: [],
+                    node: tokens[0],
+                    syntax: null,
+                    error: 'invalid attribute selector',
+                    tokens
+                };
+            }
+            if (children[0].typ == EnumToken.MatchExpressionTokenType) {
+                if (children.length != 1) {
+                    return {
+                        valid: ValidationLevel.Drop,
+                        matches: [],
+                        node: tokens[0],
+                        syntax: null,
+                        error: 'invalid <attribute-selector>',
+                        tokens
+                    };
+                }
+                if (![
+                    EnumToken.IdenTokenType,
+                    EnumToken.NameSpaceAttributeTokenType
+                ].includes(children[0].l.typ) ||
+                    ![
+                        EnumToken.EqualMatchTokenType, EnumToken.DashMatchTokenType,
+                        EnumToken.StartMatchTokenType, EnumToken.ContainMatchTokenType,
+                        EnumToken.EndMatchTokenType, EnumToken.IncludeMatchTokenType
+                    ].includes(children[0].op.typ) ||
+                    ![
+                        EnumToken.StringTokenType,
+                        EnumToken.IdenTokenType
+                    ].includes(children[0].r.typ)) {
+                    // @ts-ignore
+                    return {
+                        valid: ValidationLevel.Drop,
+                        matches: [],
+                        node: tokens[0],
+                        syntax: null,
+                        error: 'invalid attribute selector',
+                        tokens
+                    };
+                }
+                if (children[0].attr != null && !['i', 's'].includes(children[0].attr)) {
+                    // @ts-ignore
+                    return {
+                        valid: ValidationLevel.Drop,
+                        matches: [],
+                        node: tokens[0],
+                        syntax: null,
+                        error: 'invalid attribute selector',
+                        tokens
+                    };
+                }
+            }
+            match++;
+            tokens.shift();
+            consumeWhitespace(tokens);
+        }
+        if (length == tokens.length) {
+            return {
+                valid: ValidationLevel.Drop,
+                matches: [],
+                // @ts-ignore
+                node: tokens[0],
+                // @ts-ignore
+                syntax: null,
+                error: 'expected compound selector',
+                tokens
+            };
+        }
+        length = tokens.length;
+    }
+    return match == 0 ? {
+        valid: ValidationLevel.Drop,
+        matches: [],
+        // @ts-ignore
+        node: root,
+        // @ts-ignore
+        syntax: null,
+        error: 'expected compound selector',
+        tokens
+    } :
+        // @ts-ignore
+        {
+            valid: ValidationLevel.Valid,
+            matches: [],
+            // @ts-ignore
+            node: root,
+            // @ts-ignore
+            syntax: null,
+            error: null,
+            tokens
+        };
+}
+
+export { validateCompoundSelector };

package/dist/lib/validation/syntaxes/family-name.js

@@ -0,0 +1,91 @@
+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';
+
+function validateFamilyName(tokens, atRule) {
+    let node;
+    tokens = tokens.slice();
+    consumeWhitespace(tokens);
+    if (tokens.length == 0) {
+        // @ts-ignore
+        return {
+            valid: ValidationLevel.Drop,
+            matches: [],
+            node: atRule,
+            syntax: null,
+            error: 'expected at-rule prelude',
+            tokens
+        };
+    }
+    if (tokens[0].typ == EnumToken.CommaTokenType) {
+        // @ts-ignore
+        return {
+            valid: ValidationLevel.Drop,
+            matches: [],
+            node: tokens[0],
+            syntax: null,
+            error: 'unexpected token',
+            tokens
+        };
+    }
+    while (tokens.length > 0) {
+        // @ts-ignore
+        if (tokens[0].typ == EnumToken.CommaTokenType) {
+            node = tokens.shift();
+            consumeWhitespace(tokens);
+            if (tokens.length == 0) {
+                // @ts-ignore
+                return {
+                    valid: ValidationLevel.Drop,
+                    matches: [],
+                    node,
+                    syntax: null,
+                    error: 'unexpected token',
+                    tokens
+                };
+            }
+        }
+        node = tokens[0];
+        if (![EnumToken.IdenTokenType, EnumToken.StringTokenType].includes(node.typ)) {
+            // @ts-ignore
+            return {
+                valid: ValidationLevel.Drop,
+                matches: [],
+                node,
+                syntax: null,
+                error: 'unexpected token',
+                tokens
+            };
+        }
+        tokens.shift();
+        consumeWhitespace(tokens);
+        // @ts-ignore
+        if (tokens.length > 0 && node.typ == EnumToken.BadStringTokenType && tokens[0].typ != EnumToken.CommaTokenType) {
+            // @ts-ignore
+            return {
+                valid: ValidationLevel.Drop,
+                matches: [],
+                node: tokens[0],
+                syntax: null,
+                error: 'expected comma token',
+                tokens
+            };
+        }
+    }
+    // @ts-ignore
+    return {
+        valid: ValidationLevel.Valid,
+        matches: [],
+        node: null,
+        syntax: null,
+        error: '',
+        tokens
+    };
+}
+
+export { validateFamilyName };

package/dist/lib/validation/syntaxes/image.js

@@ -0,0 +1,29 @@
+import { EnumToken, ValidationLevel } 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 { validateSyntax } from '../syntax.js';
+import { getParsedSyntax } from '../config.js';
+import { validateURL } from './url.js';
+
+function validateImage(token) {
+    if (token.typ == EnumToken.UrlFunctionTokenType) {
+        return validateURL(token);
+    }
+    if (token.typ == EnumToken.ImageFunctionTokenType) {
+        return validateSyntax(getParsedSyntax("syntaxes" /* ValidationSyntaxGroupEnum.Syntaxes */, token.val + '()'), token.chi);
+    }
+    return {
+        valid: ValidationLevel.Drop,
+        matches: [],
+        node: token,
+        syntax: 'image()',
+        error: 'expected <image> or <url>',
+        tokens: []
+    };
+}
+
+export { validateImage };

package/dist/lib/validation/syntaxes/keyframe-block-list.js

@@ -0,0 +1,27 @@
+import { EnumToken, ValidationLevel } 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 { validateKeyframeSelector } from './keyframe-selector.js';
+
+function validateKeyframeBlockList(tokens, atRule, options) {
+    let i = 0;
+    let j = 0;
+    let result = null;
+    while (i + 1 < tokens.length) {
+        if (tokens[++i].typ == EnumToken.CommaTokenType) {
+            result = validateKeyframeSelector(tokens.slice(j, i), atRule);
+            if (result.valid == ValidationLevel.Drop) {
+                return result;
+            }
+            j = i + 1;
+            i = j;
+        }
+    }
+    return validateKeyframeSelector(i == j ? tokens.slice(i) : tokens.slice(j, i + 1), atRule);
+}
+
+export { validateKeyframeBlockList };

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

@@ -0,0 +1,137 @@
+import { consumeWhitespace } from '../utils/whitespace.js';
+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 validateKeyframeSelector(tokens, atRule, options) {
+    consumeWhitespace(tokens);
+    if (tokens.length == 0) {
+        // @ts-ignore
+        return {
+            valid: ValidationLevel.Drop,
+            matches: [],
+            node: atRule,
+            syntax: null,
+            error: 'expected keyframe selector',
+            tokens
+        };
+    }
+    if (tokens[0].typ == EnumToken.PercentageTokenType) {
+        tokens.shift();
+        consumeWhitespace(tokens);
+        if (tokens.length == 0) {
+            // @ts-ignore
+            return {
+                valid: ValidationLevel.Valid,
+                matches: [],
+                node: atRule,
+                syntax: null,
+                error: '',
+                tokens
+            };
+        }
+        // @ts-ignore
+        return {
+            valid: ValidationLevel.Drop,
+            matches: [],
+            node: tokens[0],
+            syntax: null,
+            error: 'unexpected token',
+            tokens
+        };
+    }
+    if (tokens[0].typ != EnumToken.IdenTokenType) {
+        // @ts-ignore
+        return {
+            valid: ValidationLevel.Drop,
+            matches: [],
+            node: tokens[0],
+            // @ts-ignore
+            syntax: null,
+            error: 'expected keyframe selector',
+            tokens
+        };
+    }
+    if (['from', 'to'].includes(tokens[0].val)) {
+        tokens.shift();
+        consumeWhitespace(tokens);
+        if (tokens.length > 0) {
+            // @ts-ignore
+            return {
+                valid: ValidationLevel.Drop,
+                matches: [],
+                node: tokens[0],
+                syntax: null,
+                error: 'unexpected token',
+                tokens
+            };
+        }
+        // @ts-ignore
+        return {
+            valid: ValidationLevel.Valid,
+            matches: [],
+            node: null,
+            // @ts-ignore
+            syntax: null,
+            error: '',
+            tokens
+        };
+    }
+    if (!['cover', 'contain', 'entry', 'exit', 'entry-crossing', 'exit-crossing'].includes(tokens[0].val)) {
+        // @ts-ignore
+        return {
+            valid: ValidationLevel.Drop,
+            matches: [],
+            node: tokens[0],
+            // @ts-ignore
+            syntax: null,
+            error: 'unexpected token',
+            tokens
+        };
+    }
+    tokens.shift();
+    consumeWhitespace(tokens);
+    // @ts-ignore
+    if (tokens.length == 0 || tokens[0].typ != EnumToken.PercentageTokenType) {
+        // @ts-ignore
+        return {
+            valid: ValidationLevel.Drop,
+            matches: [],
+            node: tokens[0],
+            // @ts-ignore
+            syntax: null,
+            error: 'expecting percentage token',
+            tokens
+        };
+    }
+    tokens.shift();
+    consumeWhitespace(tokens);
+    if (tokens.length > 0) {
+        // @ts-ignore
+        return {
+            valid: ValidationLevel.Drop,
+            matches: [],
+            node: tokens[0],
+            // @ts-ignore
+            syntax: null,
+            error: 'unexpected token',
+            tokens
+        };
+    }
+    // @ts-ignore
+    return {
+        valid: ValidationLevel.Valid,
+        matches: [],
+        node: null,
+        // @ts-ignore
+        syntax: null,
+        error: '',
+        tokens
+    };
+}
+
+export { validateKeyframeSelector };

package/dist/lib/validation/syntaxes/layer-name.js

@@ -0,0 +1,67 @@
+import { EnumToken, ValidationLevel } 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 validateLayerName(tokens) {
+    const slice = tokens.reduce((acc, curr) => {
+        if (curr.typ == EnumToken.CommaTokenType) {
+            acc.push([]);
+        }
+        else if (curr.typ != EnumToken.CommentTokenType) {
+            acc[acc.length - 1].push(curr);
+        }
+        return acc;
+    }, [[]]).slice(1);
+    for (let i = 0; i < slice.length; i++) {
+        if (slice[i].length == 0) {
+            // @ts-ignore
+            return {
+                valid: ValidationLevel.Drop,
+                matches: tokens,
+                node: null,
+                syntax: null,
+                error: 'Invalid ident',
+                tokens
+            };
+        }
+        if (slice[i][0].typ != EnumToken.IdenTokenType) {
+            // @ts-ignore
+            return {
+                valid: ValidationLevel.Drop,
+                matches: tokens,
+                node: slice[i][0],
+                syntax: 'ident',
+                error: 'expecting ident',
+                tokens
+            };
+        }
+        for (let j = 1; j < slice[i].length; j++) {
+            if (slice[i][j].typ != EnumToken.ClassSelectorTokenType) {
+                // @ts-ignore
+                return {
+                    valid: ValidationLevel.Drop,
+                    matches: tokens,
+                    node: slice[i][j],
+                    syntax: 'layer-name',
+                    error: 'expecting class selector',
+                    tokens
+                };
+            }
+        }
+    }
+    // @ts-ignore
+    return {
+        valid: ValidationLevel.Valid,
+        matches: tokens,
+        node: null,
+        syntax: null,
+        error: '',
+        tokens
+    };
+}
+
+export { validateLayerName };