@tbela99/css-parser 0.7.1 → 0.8.0

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

@@ -0,0 +1,41 @@
+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 { validateSelector } from './selector.js';
+import { consumeWhitespace } from '../utils/whitespace.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 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;
+        }
+    }
+    return validateSelector(i == j ? tokens.slice(i) : tokens.slice(j, i + 1), root, options);
+}
+
+export { validateComplexSelectorList };

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

@@ -0,0 +1,283 @@
+import { consumeWhitespace } from '../utils/whitespace.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';
+
+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
+        };
+    }
+    while (tokens.length > 0) {
+        if (combinatorsTokens.includes(tokens[0].typ)) {
+            // @ts-ignore
+            return {
+                valid: ValidationLevel.Drop,
+                matches: [],
+                // @ts-ignore
+                node: tokens[0],
+                syntax: null,
+                error: 'unexpected combinator',
+                tokens
+            };
+        }
+        if (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
+                };
+            }
+            while (tokens.length > 0 && tokens[0].typ == EnumToken.NestingSelectorTokenType) {
+                tokens.shift();
+                consumeWhitespace(tokens);
+            }
+            if (tokens.length == 0) {
+                break;
+            }
+        }
+        if (EnumToken.IdenTokenType == tokens[0].typ) {
+            tokens.shift();
+            consumeWhitespace(tokens);
+            if (tokens.length == 0) {
+                break;
+            }
+        }
+        if (EnumToken.UniversalSelectorTokenType == tokens[0].typ) {
+            tokens.shift();
+            consumeWhitespace(tokens);
+        }
+        while (tokens.length > 0) {
+            if (tokens[0].typ == EnumToken.PseudoClassFuncTokenType) {
+                if (tokens[0].val.startsWith(':-webkit-')) {
+                    // @ts-ignore
+                    return {
+                        valid: ValidationLevel.Drop,
+                        matches: [],
+                        // @ts-ignore
+                        node: tokens[0],
+                        syntax: null,
+                        error: 'invalid pseudo-class',
+                        tokens
+                    };
+                }
+            }
+            if ([
+                EnumToken.ClassSelectorTokenType,
+                EnumToken.HashTokenType,
+                EnumToken.PseudoClassTokenType,
+                EnumToken.PseudoClassFuncTokenType
+            ].includes(tokens[0].typ)) {
+                tokens.shift();
+                consumeWhitespace(tokens);
+                continue;
+            }
+            if (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
+                    };
+                }
+                tokens.shift();
+                consumeWhitespace(tokens);
+                continue;
+            }
+            // validate namespace
+            if (tokens[0].typ == EnumToken.NameSpaceAttributeTokenType) {
+                if (!((tokens[0].l == null || tokens[0].l.typ == EnumToken.IdenTokenType || (tokens[0].l.typ == EnumToken.LiteralTokenType && tokens[0].l.val == '*')) &&
+                    tokens[0].r.typ == EnumToken.IdenTokenType)) {
+                    // @ts-ignore
+                    return {
+                        valid: ValidationLevel.Drop,
+                        matches: [],
+                        node: tokens[0],
+                        syntax: null,
+                        error: 'expecting wq-name',
+                        tokens
+                    };
+                }
+                tokens.shift();
+                consumeWhitespace(tokens);
+                continue;
+            }
+            // validate attribute
+            else if (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 (![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
+                        };
+                    }
+                }
+                children.shift();
+                consumeWhitespace(children);
+                if (children.length > 0) {
+                    // @ts-ignore
+                    return {
+                        valid: ValidationLevel.Drop,
+                        matches: [],
+                        node: children[0],
+                        syntax: null,
+                        error: 'unexpected token',
+                        tokens
+                    };
+                }
+                tokens.shift();
+                consumeWhitespace(tokens);
+                continue;
+            }
+            break;
+        }
+        if (tokens.length == 0) {
+            break;
+        }
+        // combinator
+        if (!combinatorsTokens.includes(tokens[0].typ)) {
+            if (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
+                    };
+                }
+                tokens.shift();
+                consumeWhitespace(tokens);
+                continue;
+            }
+            if (tokens.length > 0 &&
+                [
+                    EnumToken.IdenTokenType,
+                    EnumToken.AttrTokenType,
+                    EnumToken.NameSpaceAttributeTokenType,
+                    EnumToken.ClassSelectorTokenType,
+                    EnumToken.HashTokenType,
+                    EnumToken.PseudoClassTokenType,
+                    EnumToken.PseudoClassFuncTokenType
+                ].includes(tokens[0].typ)) {
+                continue;
+            }
+            // @ts-ignore
+            return {
+                valid: ValidationLevel.Drop,
+                matches: [],
+                node: tokens[0],
+                syntax: null,
+                error: 'expecting combinator or subclass-selector',
+                tokens
+            };
+        }
+        const token = tokens.shift();
+        consumeWhitespace(tokens);
+        if (tokens.length == 0) {
+            // @ts-ignore
+            return {
+                valid: ValidationLevel.Drop,
+                matches: [],
+                node: token,
+                syntax: null,
+                error: 'expected compound-selector',
+                tokens
+            };
+        }
+    }
+    // @ts-ignore
+    return {
+        valid: ValidationLevel.Valid,
+        matches: [],
+        node: null,
+        syntax: null,
+        error: '',
+        tokens
+    };
+}
+
+export { combinatorsTokens, validateComplexSelector };

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/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) {
+    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) {
+    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 };

package/dist/lib/validation/syntaxes/relative-selector-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 { validateRelativeSelector } from './relative-selector.js';
+
+function validateRelativeSelectorList(tokens, root, options) {
+    let i = 0;
+    let j = 0;
+    let result = null;
+    while (i + 1 < tokens.length) {
+        if (tokens[++i].typ == EnumToken.CommaTokenType) {
+            result = validateRelativeSelector(tokens.slice(j, i), root, options);
+            if (result.valid == ValidationLevel.Drop) {
+                return result;
+            }
+            j = i + 1;
+            i = j;
+        }
+    }
+    return validateRelativeSelector(i == j ? tokens.slice(i) : tokens.slice(j, i + 1), root, options);
+}
+
+export { validateRelativeSelectorList };