@tbela99/css-parser 1.4.2 → 1.4.3

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

@@ -1,100 +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 { splitTokenList } from '../utils/list.js';
-
-function validateAtRulePage(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.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: SyntaxValidationResult.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: SyntaxValidationResult.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: SyntaxValidationResult.Drop,
-                        matches: [],
-                        node: tokens[0] ?? atRule,
-                        syntax: '@page',
-                        error: 'unexpected token',
-                        tokens: []
-                    };
-                }
-            }
-        }
-    }
-    // @ts-ignore
-    return {
-        valid: SyntaxValidationResult.Valid,
-        matches: [],
-        node: atRule,
-        syntax: '@page',
-        error: '',
-        tokens: []
-    };
-}
-
-export { validateAtRulePage };

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

@@ -1,295 +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 { colorFontTech, fontFeaturesTech, fontFormat } from '../../syntax/syntax.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';
-
-function validateAtRuleSupports(atRule, options, root) {
-    // media-query-list
-    if (!Array.isArray(atRule.tokens) || atRule.tokens.length == 0) {
-        // @ts-ignore
-        return {
-            valid: SyntaxValidationResult.Drop,
-            matches: [],
-            node: atRule,
-            syntax: '@' + atRule.nam,
-            error: 'expected supports query list',
-            tokens: []
-        };
-    }
-    if (!Array.isArray(atRule.chi)) {
-        // @ts-ignore
-        return {
-            valid: SyntaxValidationResult.Drop,
-            matches: [],
-            node: atRule,
-            syntax: '@' + atRule.nam,
-            error: 'expected supports body',
-            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: SyntaxValidationResult.Drop,
-            context: [],
-            node: atRule,
-            syntax: '@' + atRule.nam,
-            error: 'expected at-rule body'
-        };
-    }
-    // @ts-ignore
-    return {
-        valid: SyntaxValidationResult.Valid,
-        context: [],
-        node: atRule,
-        syntax: '@' + atRule.nam,
-        error: ''
-    };
-}
-function validateAtRuleSupportsConditions(atRule, tokenList) {
-    let result = null;
-    for (const tokens of splitTokenList(tokenList)) {
-        if (tokens.length == 0) {
-            // @ts-ignore
-            return {
-                valid: SyntaxValidationResult.Drop,
-                context: [],
-                node: tokens[0] ?? atRule,
-                syntax: '@' + atRule.nam,
-                error: 'unexpected token',
-                tokens: []
-            };
-        }
-        let previousToken = null;
-        while (tokens.length > 0) {
-            result = validateSupportCondition(atRule, tokens[0]);
-            // supports-condition
-            if (result.valid == SyntaxValidationResult.Valid) {
-                previousToken = tokens[0];
-                tokens.shift();
-            }
-            else {
-                result = validateSupportFeature(tokens[0]);
-                if ( /*result == null || */result.valid == SyntaxValidationResult.Valid) {
-                    previousToken = tokens[0];
-                    tokens.shift();
-                }
-                else {
-                    if (tokens[0].typ == EnumToken.ParensTokenType) {
-                        result = validateAtRuleSupportsConditions(atRule, tokens[0].chi);
-                        if ( /* result == null || */result.valid == SyntaxValidationResult.Valid) {
-                            previousToken = tokens[0];
-                            tokens.shift();
-                            // continue;
-                        }
-                        else {
-                            return result;
-                        }
-                    }
-                    else {
-                        return result;
-                    }
-                    // if (result!= null && result.valid == ValidationLevel.Drop) {
-                    //
-                    //     return  {
-                    //         valid: ValidationLevel.Drop,
-                    //         context: [],
-                    //         node: tokens[0] ?? atRule,
-                    //         syntax: '@' + atRule.nam,
-                    //         // @ts-ignore
-                    //         error: result.error as string ?? 'unexpected token',
-                    //         tokens: []
-                    //     };
-                    // }
-                }
-            }
-            if (tokens.length == 0) {
-                break;
-            }
-            if (!consumeWhitespace(tokens)) {
-                if (previousToken?.typ != EnumToken.ParensTokenType) {
-                    // @ts-ignore
-                    return {
-                        valid: SyntaxValidationResult.Drop,
-                        context: [],
-                        node: tokens[0] ?? previousToken ?? atRule,
-                        syntax: '@' + atRule.nam,
-                        error: 'expected whitespace'
-                    };
-                }
-            }
-            if (![EnumToken.MediaFeatureOrTokenType, EnumToken.MediaFeatureAndTokenType].includes(tokens[0].typ)) {
-                // @ts-ignore
-                return {
-                    valid: SyntaxValidationResult.Drop,
-                    context: [],
-                    node: tokens[0] ?? atRule,
-                    syntax: '@' + atRule.nam,
-                    error: 'expected and/or'
-                };
-            }
-            if (tokens.length == 1) {
-                // @ts-ignore
-                return {
-                    valid: SyntaxValidationResult.Drop,
-                    context: [],
-                    node: tokens[0] ?? atRule,
-                    syntax: '@' + atRule.nam,
-                    error: 'expected supports-condition'
-                };
-            }
-            tokens.shift();
-            if (!consumeWhitespace(tokens)) {
-                // @ts-ignore
-                return {
-                    valid: SyntaxValidationResult.Drop,
-                    context: [],
-                    node: tokens[0] ?? atRule,
-                    syntax: '@' + atRule.nam,
-                    error: 'expected whitespace'
-                };
-            }
-        }
-    }
-    return {
-        valid: SyntaxValidationResult.Valid,
-        context: [],
-        node: atRule,
-        syntax: '@' + atRule.nam,
-        error: ''
-    };
-}
-function validateSupportCondition(atRule, token) {
-    if (token.typ == EnumToken.MediaFeatureNotTokenType) {
-        return validateSupportCondition(atRule, token.val);
-    }
-    if (token.typ == EnumToken.FunctionTokenType && 'selector' === token.val.toLowerCase()) {
-        return {
-            valid: SyntaxValidationResult.Valid,
-            context: [],
-            node: token,
-            syntax: '@' + atRule.nam,
-            error: ''
-        };
-    }
-    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: SyntaxValidationResult.Valid,
-            context: [],
-            node: null,
-            syntax: '@' + atRule.nam,
-            error: ''
-        };
-    }
-    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: SyntaxValidationResult.Valid,
-                context: [],
-                node: null,
-                syntax: 'supports-condition',
-                error: ''
-            } : {
-            valid: SyntaxValidationResult.Drop,
-            context: [],
-            node: token,
-            syntax: 'supports-condition',
-            error: 'expected supports condition-in-parens'
-        };
-    }
-    // @ts-ignore
-    return {
-        valid: SyntaxValidationResult.Drop,
-        context: [],
-        node: token,
-        syntax: 'supports-condition',
-        error: 'expected supports condition-in-parens'
-    };
-}
-function validateSupportFeature(token) {
-    if (token.typ == EnumToken.MediaFeatureNotTokenType) {
-        return validateSupportFeature(token.val);
-    }
-    if (token.typ == EnumToken.FunctionTokenType) {
-        if ('selector' === token.val.toLowerCase()) {
-            return {
-                valid: SyntaxValidationResult.Valid,
-                context: [],
-                node: token,
-                syntax: 'selector',
-                error: ''
-            };
-        }
-        if ('font-tech' === token.val.toLowerCase()) {
-            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).includes(chi[0].val.toLowerCase()) ?
-                {
-                    valid: SyntaxValidationResult.Valid,
-                    context: [],
-                    node: token,
-                    syntax: 'font-tech',
-                    error: ''
-                } :
-                {
-                    valid: SyntaxValidationResult.Drop,
-                    context: [],
-                    node: token,
-                    syntax: 'font-tech',
-                    error: 'expected font-tech'
-                };
-        }
-        if ('font-format' === token.val.toLowerCase()) {
-            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.includes(chi[0].val, toLowerCase()) ?
-                {
-                    valid: SyntaxValidationResult.Valid,
-                    context: [],
-                    node: token,
-                    syntax: 'font-format',
-                    error: ''
-                } :
-                {
-                    valid: SyntaxValidationResult.Drop,
-                    context: [],
-                    node: token,
-                    syntax: 'font-format',
-                    error: 'expected font-format'
-                };
-        }
-    }
-    // @ts-ignore
-    return {
-        valid: SyntaxValidationResult.Drop,
-        context: [],
-        node: token,
-        syntax: '@supports',
-        error: 'expected feature'
-    };
-}
-
-export { validateAtRuleSupports, validateAtRuleSupportsConditions, validateSupportCondition };

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

@@ -1,185 +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 { generalEnclosedFunc } from '../../syntax/color/utils/constants.js';
-import '../../renderer/sourcemap/lib/encode.js';
-import { consumeWhitespace } from '../utils/whitespace.js';
-import { splitTokenList } from '../utils/list.js';
-import { validateMediaFeature, validateMediaCondition } from './media.js';
-import { validateSupportCondition } from './supports.js';
-
-function validateAtRuleWhen(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: []
-        };
-    }
-    const slice = Array.isArray(atRule.tokens) ? atRule.tokens.slice() : [];
-    consumeWhitespace(slice);
-    if (slice.length == 0) {
-        // @ts-ignore
-        return {
-            valid: SyntaxValidationResult.Valid,
-            context: [],
-            node: atRule,
-            syntax: '@when',
-            error: '',
-            tokens: []
-        };
-    }
-    const result = validateAtRuleWhenQueryList(atRule.tokens, atRule);
-    if (result.valid == SyntaxValidationResult.Drop) {
-        return result;
-    }
-    if (!('chi' in atRule)) {
-        // @ts-ignore
-        return {
-            valid: SyntaxValidationResult.Drop,
-            context: [],
-            node: atRule,
-            syntax: '@when',
-            error: 'expected at-rule body',
-            tokens: []
-        };
-    }
-    return {
-        valid: SyntaxValidationResult.Valid,
-        context: [],
-        node: atRule,
-        syntax: '@when',
-        error: ''
-    };
-}
-// media() = media( [ <mf-plain> | <mf-boolean> | <mf-range> ] )
-// supports() = supports( <declaration> )
-function validateAtRuleWhenQueryList(tokenList, atRule) {
-    const matched = [];
-    let result = null;
-    for (const split of splitTokenList(tokenList)) {
-        const match = [];
-        result = null;
-        consumeWhitespace(split);
-        if (split.length == 0) {
-            continue;
-        }
-        while (split.length > 0) {
-            if (split[0].typ != EnumToken.FunctionTokenType || !generalEnclosedFunc.includes(split[0].val)) {
-                result = {
-                    valid: SyntaxValidationResult.Drop,
-                    context: [],
-                    node: split[0] ?? atRule,
-                    syntax: '@when',
-                    error: 'unexpected token',
-                    tokens: []
-                };
-                break;
-            }
-            const chi = split[0].chi.slice();
-            consumeWhitespace(chi);
-            if (split[0].val == 'media') {
-                // result = valida
-                if (chi.length != 1 || !(validateMediaFeature(chi[0]) || validateMediaCondition(split[0], atRule))) {
-                    result = {
-                        valid: SyntaxValidationResult.Drop,
-                        context: [],
-                        node: split[0] ?? atRule,
-                        syntax: 'media( [ <mf-plain> | <mf-boolean> | <mf-range> ] )',
-                        error: 'unexpected token'
-                    };
-                    break;
-                }
-            }
-            else if (generalEnclosedFunc.includes(split[0].val)) {
-                // result = valida
-                if (!validateSupportCondition(atRule, split[0])) {
-                    result = {
-                        valid: SyntaxValidationResult.Drop,
-                        context: [],
-                        node: split[0] ?? atRule,
-                        syntax: 'media( [ <mf-plain> | <mf-boolean> | <mf-range> ] )',
-                        error: 'unexpected token'
-                    };
-                    break;
-                }
-            }
-            if (match.length > 0) {
-                match.push({ typ: EnumToken.WhitespaceTokenType });
-            }
-            match.push(split.shift());
-            consumeWhitespace(split);
-            if (split.length == 0) {
-                break;
-            }
-            if (![EnumToken.MediaFeatureAndTokenType, EnumToken.MediaFeatureOrTokenType].includes(split[0].typ)) {
-                result = {
-                    valid: SyntaxValidationResult.Drop,
-                    context: [],
-                    node: split[0] ?? atRule,
-                    syntax: '@when',
-                    error: 'expecting and/or media-condition',
-                    tokens: []
-                };
-                break;
-            }
-            if (match.length > 0) {
-                match.push({ typ: EnumToken.WhitespaceTokenType });
-            }
-            match.push(split.shift());
-            consumeWhitespace(split);
-            if (split.length == 0) {
-                result = {
-                    valid: SyntaxValidationResult.Drop,
-                    context: [],
-                    node: split[0] ?? atRule,
-                    syntax: '@when',
-                    error: 'expecting media-condition',
-                    tokens: []
-                };
-                break;
-            }
-        }
-        if (result == null && match.length > 0) {
-            matched.push(match);
-        }
-    }
-    if (result != null) {
-        return result;
-    }
-    if (matched.length == 0) {
-        return {
-            valid: SyntaxValidationResult.Drop,
-            context: [],
-            // @ts-ignore
-            node: result?.node ?? atRule,
-            syntax: '@when',
-            error: 'invalid at-rule body'
-        };
-    }
-    tokenList.length = 0;
-    for (const match of matched) {
-        if (tokenList.length > 0) {
-            tokenList.push({
-                typ: EnumToken.CommaTokenType
-            });
-        }
-        tokenList.push(...match);
-    }
-    return {
-        valid: SyntaxValidationResult.Valid,
-        context: [],
-        node: atRule,
-        syntax: '@when',
-        error: ''
-    };
-}
-
-export { validateAtRuleWhen, validateAtRuleWhenQueryList };