@tbela99/css-parser 1.4.1 → 1.4.3

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

@@ -1,342 +0,0 @@
-import { SyntaxValidationResult, EnumToken } from '../../ast/types.js';
-import '../../ast/minify.js';
-import '../../ast/walk.js';
-import '../../parser/parse.js';
-import '../../parser/tokenize.js';
-import '../../parser/utils/config.js';
-import '../../syntax/color/utils/constants.js';
-import '../../renderer/sourcemap/lib/encode.js';
-import { consumeWhitespace } from '../utils/whitespace.js';
-import { splitTokenList } from '../utils/list.js';
-
-const validateContainerScrollStateFeature = validateContainerSizeFeature;
-function validateAtRuleContainer(atRule, options, root) {
-    if (!Array.isArray(atRule.chi)) {
-        // @ts-ignore
-        return {
-            valid: SyntaxValidationResult.Drop,
-            matches: [],
-            node: atRule,
-            syntax: '@' + atRule.nam,
-            error: 'expected supports body',
-            tokens: []
-        };
-    }
-    // media-query-list
-    if (!Array.isArray(atRule.tokens) || atRule.tokens.length == 0) {
-        // @ts-ignore
-        return {
-            valid: SyntaxValidationResult.Drop,
-            context: [],
-            node: atRule,
-            syntax: '@' + atRule.nam,
-            error: 'expected supports query list'
-        };
-    }
-    const result = validateAtRuleContainerQueryList(atRule.tokens, atRule);
-    if (result.valid == SyntaxValidationResult.Drop) {
-        return result;
-    }
-    if (!('chi' in atRule)) {
-        // @ts-ignore
-        return {
-            valid: SyntaxValidationResult.Drop,
-            context: [],
-            node: atRule,
-            syntax: '@' + atRule.nam,
-            error: 'expected at-rule body'
-        };
-    }
-    return {
-        valid: SyntaxValidationResult.Valid,
-        context: [],
-        node: atRule,
-        syntax: '@' + atRule.nam,
-        error: '',
-    };
-}
-function validateAtRuleContainerQueryList(tokens, atRule) {
-    if (tokens.length == 0) {
-        // @ts-ignore
-        return {
-            valid: SyntaxValidationResult.Drop,
-            context: [],
-            node: atRule,
-            syntax: '@' + atRule.nam,
-            error: 'expected container query list'
-        };
-    }
-    let result = null;
-    let tokenType = null;
-    for (const queries of splitTokenList(tokens)) {
-        consumeWhitespace(queries);
-        if (queries.length == 0) {
-            return {
-                valid: SyntaxValidationResult.Drop,
-                context: [],
-                node: atRule,
-                syntax: '@' + atRule.nam,
-                error: 'expected container query list'
-            };
-        }
-        result = null;
-        const match = [];
-        let token = null;
-        tokenType = null;
-        while (queries.length > 0) {
-            if (queries.length == 0) {
-                return {
-                    valid: SyntaxValidationResult.Drop,
-                    context: [],
-                    node: atRule,
-                    syntax: '@' + atRule.nam,
-                    error: 'expected container query list'
-                };
-            }
-            if (queries[0].typ == EnumToken.IdenTokenType) {
-                match.push(queries.shift());
-                consumeWhitespace(queries);
-            }
-            if (queries.length == 0) {
-                break;
-            }
-            token = queries[0];
-            if (token?.typ == EnumToken.MediaFeatureNotTokenType) {
-                token = token.val;
-            }
-            if (token?.typ != EnumToken.ParensTokenType && (token?.typ != EnumToken.FunctionTokenType || !['scroll-state', 'style'].includes(token.val))) {
-                return {
-                    valid: SyntaxValidationResult.Drop,
-                    context: [],
-                    node: queries[0],
-                    syntax: '@' + atRule.nam,
-                    error: 'expected container query-in-parens'
-                };
-            }
-            if (token?.typ == EnumToken.ParensTokenType) {
-                result = validateContainerSizeFeature(token.chi, atRule);
-            }
-            else if (token.val == 'scroll-state') {
-                result = validateContainerScrollStateFeature(token.chi, atRule);
-            }
-            else {
-                result = validateContainerStyleFeature(token.chi, atRule);
-            }
-            if (result.valid == SyntaxValidationResult.Drop) {
-                return result;
-            }
-            queries.shift();
-            consumeWhitespace(queries);
-            if (queries.length == 0) {
-                break;
-            }
-            token = queries[0];
-            if (token?.typ != EnumToken.MediaFeatureAndTokenType && token?.typ != EnumToken.MediaFeatureOrTokenType) {
-                return {
-                    valid: SyntaxValidationResult.Drop,
-                    context: [],
-                    node: queries[0],
-                    syntax: '@' + atRule.nam,
-                    error: 'expecting and/or container query token'
-                };
-            }
-            if (tokenType == null) {
-                tokenType = token?.typ;
-            }
-            if (tokenType == null || tokenType != token?.typ) {
-                return {
-                    valid: SyntaxValidationResult.Drop,
-                    context: [],
-                    node: queries[0],
-                    syntax: '@' + atRule.nam,
-                    error: 'mixing and/or not allowed at the same level'
-                };
-            }
-            queries.shift();
-            consumeWhitespace(queries);
-            if (queries.length == 0) {
-                return {
-                    valid: SyntaxValidationResult.Drop,
-                    context: [],
-                    node: queries[0],
-                    syntax: '@' + atRule.nam,
-                    error: 'expected container query-in-parens'
-                };
-            }
-        }
-    }
-    return {
-        valid: SyntaxValidationResult.Valid,
-        context: [],
-        node: atRule,
-        syntax: '@' + atRule.nam,
-        error: ''
-    };
-}
-function validateContainerStyleFeature(tokens, atRule) {
-    tokens = tokens.slice();
-    consumeWhitespace(tokens);
-    if (tokens.length == 1) {
-        if (tokens[0].typ == EnumToken.ParensTokenType) {
-            return validateContainerStyleFeature(tokens[0].chi, atRule);
-        }
-        if ([EnumToken.DashedIdenTokenType, EnumToken.IdenTokenType].includes(tokens[0].typ) ||
-            (tokens[0].typ == EnumToken.MediaQueryConditionTokenType && tokens[0].op.typ == EnumToken.ColonTokenType)) {
-            return {
-                valid: SyntaxValidationResult.Valid,
-                context: [],
-                node: atRule,
-                syntax: '@' + atRule.nam,
-                error: ''
-            };
-        }
-    }
-    return {
-        valid: SyntaxValidationResult.Drop,
-        context: [],
-        node: atRule,
-        syntax: '@' + atRule.nam,
-        error: 'expected container query features'
-    };
-}
-function validateContainerSizeFeature(tokens, atRule) {
-    tokens = tokens.slice();
-    consumeWhitespace(tokens);
-    if (tokens.length == 0) {
-        return {
-            valid: SyntaxValidationResult.Drop,
-            context: [],
-            node: atRule,
-            syntax: '@' + atRule.nam,
-            error: 'expected container query features'
-        };
-    }
-    if (tokens.length == 1) {
-        const token = tokens[0];
-        if (token.typ == EnumToken.MediaFeatureNotTokenType) {
-            return validateContainerSizeFeature([token.val], atRule);
-        }
-        if (token.typ == EnumToken.ParensTokenType) {
-            return validateAtRuleContainerQueryStyleInParams(token.chi, atRule);
-        }
-        if (![EnumToken.DashedIdenTokenType, EnumToken.MediaQueryConditionTokenType].includes(tokens[0].typ)) {
-            return {
-                valid: SyntaxValidationResult.Drop,
-                context: [],
-                node: atRule,
-                syntax: '@' + atRule.nam,
-                error: 'expected container query features'
-            };
-        }
-        return {
-            valid: SyntaxValidationResult.Valid,
-            context: [],
-            node: atRule,
-            syntax: '@' + atRule.nam,
-            error: ''
-        };
-    }
-    return validateAtRuleContainerQueryStyleInParams(tokens, atRule);
-}
-function validateAtRuleContainerQueryStyleInParams(tokens, atRule) {
-    tokens = tokens.slice();
-    consumeWhitespace(tokens);
-    if (tokens.length == 0) {
-        return {
-            valid: SyntaxValidationResult.Drop,
-            context: [],
-            node: atRule,
-            syntax: '@' + atRule.nam,
-            error: 'expected container query features'
-        };
-    }
-    let token = tokens[0];
-    let tokenType = null;
-    let result = null;
-    while (tokens.length > 0) {
-        token = tokens[0];
-        if (token.typ == EnumToken.MediaFeatureNotTokenType) {
-            token = token.val;
-        }
-        if (tokens[0].typ != EnumToken.ParensTokenType) {
-            return {
-                valid: SyntaxValidationResult.Drop,
-                context: [],
-                node: atRule,
-                syntax: '@' + atRule.nam,
-                error: 'expected container query-in-parens'
-            };
-        }
-        const slices = tokens[0].chi.slice();
-        consumeWhitespace(slices);
-        if (slices.length == 1) {
-            if ([EnumToken.MediaFeatureNotTokenType, EnumToken.ParensTokenType].includes(slices[0].typ)) {
-                result = validateAtRuleContainerQueryStyleInParams(slices, atRule);
-                if (result.valid == SyntaxValidationResult.Drop) {
-                    return result;
-                }
-            }
-            else if (![EnumToken.DashedIdenTokenType, EnumToken.MediaQueryConditionTokenType].includes(slices[0].typ)) {
-                result = {
-                    valid: SyntaxValidationResult.Drop,
-                    context: [],
-                    node: atRule,
-                    syntax: '@' + atRule.nam,
-                    error: 'expected container query features'
-                };
-            }
-        }
-        else {
-            result = validateAtRuleContainerQueryStyleInParams(slices, atRule);
-            if (result.valid == SyntaxValidationResult.Drop) {
-                return result;
-            }
-        }
-        tokens.shift();
-        consumeWhitespace(tokens);
-        if (tokens.length == 0) {
-            break;
-        }
-        if (![EnumToken.MediaFeatureAndTokenType, EnumToken.MediaFeatureOrTokenType].includes(tokens[0].typ)) {
-            return {
-                valid: SyntaxValidationResult.Drop,
-                context: [],
-                node: tokens[0],
-                syntax: '@' + atRule.nam,
-                error: 'expecting and/or container query token'
-            };
-        }
-        if (tokenType == null) {
-            tokenType = tokens[0].typ;
-        }
-        if (tokenType != tokens[0].typ) {
-            return {
-                valid: SyntaxValidationResult.Drop,
-                context: [],
-                node: tokens[0],
-                syntax: '@' + atRule.nam,
-                error: 'mixing and/or not allowed at the same level'
-            };
-        }
-        tokens.shift();
-        consumeWhitespace(tokens);
-        if (tokens.length == 0) {
-            return {
-                valid: SyntaxValidationResult.Drop,
-                context: [],
-                node: tokens[0],
-                syntax: '@' + atRule.nam,
-                error: 'expected container query-in-parens'
-            };
-        }
-    }
-    return {
-        valid: SyntaxValidationResult.Valid,
-        context: [],
-        node: atRule,
-        syntax: '@' + atRule.nam,
-        error: ''
-    };
-}
-
-export { validateAtRuleContainer };

package/dist/lib/validation/at-rules/counter-style.js

@@ -1,90 +0,0 @@
-import { SyntaxValidationResult, EnumToken } from '../../ast/types.js';
-import '../../ast/minify.js';
-import '../../ast/walk.js';
-import '../../parser/parse.js';
-import '../../parser/tokenize.js';
-import '../../parser/utils/config.js';
-import '../../syntax/color/utils/constants.js';
-import '../../renderer/sourcemap/lib/encode.js';
-
-function validateAtRuleCounterStyle(atRule, options, root) {
-    if (!Array.isArray(atRule.chi)) {
-        // @ts-ignore
-        return {
-            valid: SyntaxValidationResult.Drop,
-            matches: [],
-            node: atRule,
-            syntax: '@' + atRule.nam,
-            error: 'expected supports body',
-            tokens: []
-        };
-    }
-    // media-query-list
-    if (!Array.isArray(atRule.tokens) || atRule.tokens.length == 0) {
-        // @ts-ignore
-        return {
-            valid: SyntaxValidationResult.Drop,
-            matches: [],
-            node: atRule,
-            syntax: '@counter-style',
-            error: 'expected counter style name',
-            tokens: []
-        };
-    }
-    const tokens = atRule.tokens.filter((t) => ![EnumToken.WhitespaceTokenType, EnumToken.CommentTokenType].includes(t.typ));
-    if (tokens.length == 0) {
-        // @ts-ignore
-        return {
-            valid: SyntaxValidationResult.Drop,
-            matches: [],
-            node: atRule,
-            syntax: '@counter-style',
-            error: 'expected counter style name',
-            tokens
-        };
-    }
-    if (tokens.length > 1) {
-        // @ts-ignore
-        return {
-            valid: SyntaxValidationResult.Drop,
-            matches: [],
-            node: tokens[1] ?? atRule,
-            syntax: '@counter-style',
-            error: 'unexpected token',
-            tokens
-        };
-    }
-    if (![EnumToken.IdenTokenType, EnumToken.DashedIdenTokenType].includes(tokens[0].typ)) {
-        // @ts-ignore
-        return {
-            valid: SyntaxValidationResult.Drop,
-            matches: [],
-            node: tokens[0],
-            syntax: '@counter-style',
-            error: 'expected counter style name',
-            tokens
-        };
-    }
-    if (!('chi' in atRule)) {
-        // @ts-ignore
-        return {
-            valid: SyntaxValidationResult.Drop,
-            matches: [],
-            node: atRule,
-            syntax: '@counter-style',
-            error: 'expected counter style body',
-            tokens
-        };
-    }
-    // @ts-ignore
-    return {
-        valid: SyntaxValidationResult.Valid,
-        matches: [],
-        node: atRule,
-        syntax: '@counter-style',
-        error: '',
-        tokens
-    };
-}
-
-export { validateAtRuleCounterStyle };

package/dist/lib/validation/at-rules/custom-media.js

@@ -1,50 +0,0 @@
-import { SyntaxValidationResult, EnumToken } from '../../ast/types.js';
-import '../../ast/minify.js';
-import '../../ast/walk.js';
-import '../../parser/parse.js';
-import '../../parser/tokenize.js';
-import '../../parser/utils/config.js';
-import '../../syntax/color/utils/constants.js';
-import '../../renderer/sourcemap/lib/encode.js';
-import { consumeWhitespace } from '../utils/whitespace.js';
-import { validateAtRuleMediaQueryList } from './media.js';
-
-function validateAtRuleCustomMedia(atRule, options, root) {
-    // media-query-list
-    if (!Array.isArray(atRule.tokens) || atRule.tokens.length == 0) {
-        // @ts-ignore
-        return {
-            valid: SyntaxValidationResult.Valid,
-            context: [],
-            node: null,
-            syntax: null,
-            error: ''
-        };
-    }
-    const queries = atRule.tokens.slice();
-    consumeWhitespace(queries);
-    if (queries.length == 0 || queries[0].typ != EnumToken.DashedIdenTokenType) {
-        return {
-            valid: SyntaxValidationResult.Drop,
-            context: [],
-            node: atRule,
-            syntax: '@custom-media',
-            error: 'expecting dashed identifier'
-        };
-    }
-    queries.shift();
-    const result = validateAtRuleMediaQueryList(queries, atRule);
-    if (result.valid == SyntaxValidationResult.Drop) {
-        atRule.tokens = [];
-        return {
-            valid: SyntaxValidationResult.Valid,
-            context: [],
-            node: atRule,
-            syntax: '@custom-media',
-            error: ''
-        };
-    }
-    return result;
-}
-
-export { validateAtRuleCustomMedia };

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

@@ -1,89 +0,0 @@
-import { SyntaxValidationResult, EnumToken } from '../../ast/types.js';
-import '../../ast/minify.js';
-import '../../ast/walk.js';
-import '../../parser/parse.js';
-import '../../parser/tokenize.js';
-import '../../parser/utils/config.js';
-import '../../syntax/color/utils/constants.js';
-import '../../renderer/sourcemap/lib/encode.js';
-import { consumeWhitespace } from '../utils/whitespace.js';
-import { splitTokenList } from '../utils/list.js';
-import { validateURL } from '../syntaxes/url.js';
-
-function validateAtRuleDocument(atRule, options, root) {
-    if (!Array.isArray(atRule.tokens) || atRule.tokens.length == 0) {
-        // @ts-ignore
-        return {
-            valid: SyntaxValidationResult.Drop,
-            context: [],
-            node: atRule,
-            syntax: '@document',
-            error: 'expecting at-rule prelude'
-        };
-    }
-    const tokens = atRule.tokens.slice();
-    let result = null;
-    consumeWhitespace(tokens);
-    if (tokens.length == 0) {
-        // @ts-ignore
-        return {
-            valid: SyntaxValidationResult.Drop,
-            context: [],
-            node: atRule,
-            syntax: '@document',
-            error: 'expecting at-rule prelude'
-        };
-    }
-    for (const t of splitTokenList(tokens)) {
-        if (t.length != 1) {
-            return {
-                valid: SyntaxValidationResult.Drop,
-                context: [],
-                node: t[0] ?? atRule,
-                syntax: '@document',
-                error: 'unexpected token'
-            };
-        }
-        // @ts-ignore
-        if ((t[0].typ != EnumToken.FunctionTokenType && t[0].typ != EnumToken.UrlFunctionTokenType) || !['url', 'url-prefix', 'domain', 'media-document', 'regexp'].includes(t[0].val?.toLowerCase?.())) {
-            return {
-                valid: SyntaxValidationResult.Drop,
-                context: [],
-                node: t[0] ?? atRule,
-                syntax: '@document',
-                error: 'expecting any of url-prefix(), domain(), media-document(), regexp() but found ' + t[0].val
-            };
-        }
-        if (t[0].typ == EnumToken.UrlFunctionTokenType) {
-            result = validateURL(t[0]);
-            if (result?.valid == SyntaxValidationResult.Drop) {
-                return result;
-            }
-            continue;
-        }
-        const children = t[0].chi.slice();
-        consumeWhitespace(children);
-        if (children.length != 1 || (children[0].typ != EnumToken.StringTokenType && children[0].typ != EnumToken.UrlTokenTokenType)) {
-            // @ts-ignore
-            return {
-                valid: SyntaxValidationResult.Drop,
-                context: [],
-                node: tokens[0],
-                syntax: '@document',
-                error: 'expecting string argument'
-            };
-        }
-        tokens.shift();
-        consumeWhitespace(tokens);
-    }
-    // @ts-ignore
-    return {
-        valid: SyntaxValidationResult.Valid,
-        context: [],
-        node: atRule,
-        syntax: '@document',
-        error: ''
-    };
-}
-
-export { validateAtRuleDocument };

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

@@ -1,5 +0,0 @@
-import { validateAtRuleWhen } from './when.js';
-
-const validateAtRuleElse = validateAtRuleWhen;
-
-export { validateAtRuleElse };

package/dist/lib/validation/at-rules/font-feature-values.js

@@ -1,63 +0,0 @@
-import { SyntaxValidationResult } from '../../ast/types.js';
-import '../../ast/minify.js';
-import '../../ast/walk.js';
-import '../../parser/parse.js';
-import '../../parser/tokenize.js';
-import '../../parser/utils/config.js';
-import '../../syntax/color/utils/constants.js';
-import '../../renderer/sourcemap/lib/encode.js';
-import { validateFamilyName } from '../syntaxes/family-name.js';
-import '../syntaxes/complex-selector.js';
-import '../syntax.js';
-import '../config.js';
-
-function validateAtRuleFontFeatureValues(atRule, options, root) {
-    if (!Array.isArray(atRule.chi)) {
-        // @ts-ignore
-        return {
-            valid: SyntaxValidationResult.Drop,
-            matches: [],
-            node: atRule,
-            syntax: '@' + atRule.nam,
-            error: 'expected supports body',
-            tokens: []
-        };
-    }
-    if (!Array.isArray(atRule.tokens) || atRule.tokens.length == 0) {
-        // @ts-ignore
-        return {
-            valid: SyntaxValidationResult.Drop,
-            matches: [],
-            node: null,
-            syntax: '@' + atRule.nam,
-            error: 'expected at-rule prelude',
-            tokens: []
-        };
-    }
-    const result = validateFamilyName(atRule.tokens);
-    if (result.valid == SyntaxValidationResult.Drop) {
-        return result;
-    }
-    if (!('chi' in atRule)) {
-        // @ts-ignore
-        return {
-            valid: SyntaxValidationResult.Drop,
-            matches: [],
-            node: atRule,
-            syntax: '@' + atRule.nam,
-            error: 'expected at-rule body',
-            tokens: []
-        };
-    }
-    // @ts-ignore
-    return {
-        valid: SyntaxValidationResult.Valid,
-        matches: [],
-        node: atRule,
-        syntax: '@' + atRule.nam,
-        error: '',
-        tokens: []
-    };
-}
-
-export { validateAtRuleFontFeatureValues };