@tbela99/css-parser 0.7.1 → 0.9.0

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

@@ -0,0 +1,199 @@
+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 { validateAtRuleSupports } from './supports.js';
+import { validateAtRuleMediaQueryList } from './media.js';
+import { consumeWhitespace } from '../utils/whitespace.js';
+import { validateLayerName } from '../syntaxes/layer-name.js';
+import '../syntaxes/complex-selector.js';
+import '../parser/types.js';
+import '../parser/parse.js';
+import '../config.js';
+
+function validateAtRuleImport(atRule, options, root) {
+    if (!Array.isArray(atRule.tokens) || atRule.tokens.length == 0) {
+        // @ts-ignore
+        return {
+            valid: ValidationLevel.Drop,
+            matches: [],
+            node: null,
+            syntax: '@' + atRule.nam,
+            error: 'expected @import media query list',
+            tokens: []
+        };
+    }
+    if ('chi' in atRule) {
+        // @ts-ignore
+        return {
+            valid: ValidationLevel.Drop,
+            matches: [],
+            node: null,
+            syntax: '@' + atRule.nam,
+            error: 'unexpected at-rule body',
+            tokens: []
+        };
+    }
+    const tokens = atRule.tokens.filter((t) => ![EnumToken.CommentTokenType].includes(t.typ));
+    if (tokens.length == 0) {
+        // @ts-ignore
+        return {
+            valid: ValidationLevel.Drop,
+            matches: [],
+            node: null,
+            syntax: '@' + atRule.nam,
+            error: 'expected @import media query list',
+            tokens: []
+        };
+    }
+    if (tokens[0].typ == EnumToken.StringTokenType) {
+        tokens.shift();
+        // @ts-ignore
+        consumeWhitespace(tokens);
+    }
+    else if (tokens[0].typ == EnumToken.UrlFunctionTokenType) {
+        const slice = tokens[0].chi.filter((t) => t.typ != EnumToken.CommentTokenType && t.typ != EnumToken.WhitespaceTokenType);
+        if (slice.length != 1 || ![EnumToken.StringTokenType, EnumToken.UrlTokenTokenType].includes(slice[0].typ)) {
+            // @ts-ignore
+            return {
+                valid: ValidationLevel.Drop,
+                matches: [],
+                node: tokens[0],
+                syntax: '@' + atRule.nam,
+                error: 'invalid url()',
+                tokens
+            };
+        }
+        else {
+            tokens.shift();
+            // @ts-ignore
+            if (!consumeWhitespace(tokens)) {
+                // @ts-ignore
+                return {
+                    valid: ValidationLevel.Drop,
+                    matches: [],
+                    node: tokens[0],
+                    syntax: '@' + atRule.nam,
+                    error: 'expecting whitespace',
+                    tokens
+                };
+            }
+        }
+    }
+    else {
+        // @ts-ignore
+        return {
+            valid: ValidationLevel.Drop,
+            matches: [],
+            node: tokens[0],
+            syntax: '@' + atRule.nam,
+            error: 'expecting url() or string',
+            tokens
+        };
+    }
+    if (tokens.length > 0) {
+        // @ts-ignore
+        if (tokens[0].typ == EnumToken.IdenTokenType) {
+            // @ts-ignore
+            if ('layer'.localeCompare(tokens[0].val, undefined, { sensitivity: 'base' }) == 0) {
+                tokens.shift();
+                // @ts-ignore
+                if (!consumeWhitespace(tokens)) {
+                    // @ts-ignore
+                    return {
+                        valid: ValidationLevel.Drop,
+                        matches: [],
+                        node: tokens[0],
+                        syntax: '@' + atRule.nam,
+                        error: 'expecting whitespace',
+                        tokens
+                    };
+                }
+            }
+        }
+        // @ts-ignore
+        else if (tokens[0].typ == EnumToken.FunctionTokenType) {
+            // @ts-ignore
+            if ('layer'.localeCompare(tokens[0].val, undefined, { sensitivity: 'base' }) != 0) {
+                // @ts-ignore
+                return {
+                    valid: ValidationLevel.Drop,
+                    matches: [],
+                    node: tokens[0],
+                    syntax: '@' + atRule.nam,
+                    error: 'expecting layer()',
+                    tokens
+                };
+            }
+            // @ts-ignore
+            const result = validateLayerName(tokens[0].chi);
+            if (result.valid == ValidationLevel.Drop) {
+                return result;
+            }
+            tokens.shift();
+            // @ts-ignore
+            if (!consumeWhitespace(tokens)) {
+                // @ts-ignore
+                return {
+                    valid: ValidationLevel.Drop,
+                    matches: [],
+                    node: tokens[0],
+                    syntax: '@' + atRule.nam,
+                    error: 'expecting whitespace',
+                    tokens
+                };
+            }
+        }
+    }
+    if (tokens.length > 0) {
+        // @ts-ignore
+        if (tokens[0].typ == EnumToken.AtRuleTokenType) {
+            if (tokens[0].nam != 'supports') {
+                // @ts-ignore
+                return {
+                    valid: ValidationLevel.Drop,
+                    matches: [],
+                    node: tokens[0],
+                    syntax: '@' + atRule.nam,
+                    error: 'expecting @supports or media query list',
+                    tokens
+                };
+            }
+            // @ts-ignore
+            const result = validateAtRuleSupports(tokens[0]);
+            if (result.valid == ValidationLevel.Drop) {
+                return result;
+            }
+            tokens.shift();
+            // @ts-ignore
+            if (!consumeWhitespace(tokens)) {
+                // @ts-ignore
+                return {
+                    valid: ValidationLevel.Drop,
+                    matches: [],
+                    node: tokens[0],
+                    syntax: '@' + atRule.nam,
+                    error: 'expecting whitespace',
+                    tokens
+                };
+            }
+        }
+    }
+    if (tokens.length > 0) {
+        return validateAtRuleMediaQueryList(tokens, atRule);
+    }
+    // @ts-ignore
+    return {
+        valid: ValidationLevel.Valid,
+        matches: [],
+        node: null,
+        syntax: '@' + atRule.nam,
+        error: '',
+        tokens: []
+    };
+}
+
+export { validateAtRuleImport };

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

@@ -0,0 +1,70 @@
+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 validateAtRuleKeyframes(atRule, options, root) {
+    if (!Array.isArray(atRule.tokens) || atRule.tokens.length == 0) {
+        // @ts-ignore
+        return {
+            valid: ValidationLevel.Drop,
+            matches: [],
+            node: atRule,
+            syntax: '@document',
+            error: 'expecting at-rule prelude',
+            tokens: []
+        };
+    }
+    const tokens = atRule.tokens.slice();
+    consumeWhitespace(tokens);
+    if (tokens.length == 0) {
+        // @ts-ignore
+        return {
+            valid: ValidationLevel.Drop,
+            matches: [],
+            node: atRule,
+            syntax: '@keyframes',
+            error: 'expecting at-rule prelude',
+            tokens
+        };
+    }
+    if (![EnumToken.StringTokenType, EnumToken.IdenTokenType].includes(tokens[0].typ)) {
+        // @ts-ignore
+        return {
+            valid: ValidationLevel.Drop,
+            matches: [],
+            node: atRule,
+            syntax: '@keyframes',
+            error: 'expecting ident or string token',
+            tokens
+        };
+    }
+    tokens.shift();
+    consumeWhitespace(tokens);
+    if (tokens.length > 0) {
+        // @ts-ignore
+        return {
+            valid: ValidationLevel.Drop,
+            matches: [],
+            node: tokens[0],
+            syntax: '@keyframes',
+            error: 'unexpected token',
+            tokens
+        };
+    }
+    // @ts-ignore
+    return {
+        valid: ValidationLevel.Valid,
+        matches: [],
+        node: atRule,
+        syntax: '@keyframes',
+        error: '',
+        tokens
+    };
+}
+
+export { validateAtRuleKeyframes };

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

@@ -0,0 +1,30 @@
+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 { validateLayerName } from '../syntaxes/layer-name.js';
+import '../syntaxes/complex-selector.js';
+import '../parser/types.js';
+import '../parser/parse.js';
+import '../config.js';
+
+function validateAtRuleLayer(atRule, options, root) {
+    // media-query-list
+    if (!Array.isArray(atRule.tokens) || atRule.tokens.length == 0) {
+        // @ts-ignore
+        return {
+            valid: ValidationLevel.Valid,
+            matches: [],
+            node: atRule,
+            syntax: '@layer',
+            error: '',
+            tokens: []
+        };
+    }
+    return validateLayerName(atRule.tokens);
+}
+
+export { validateAtRuleLayer };

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

@@ -0,0 +1,254 @@
+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 { splitTokenList } from '../utils/list.js';
+
+function validateAtRuleMedia(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: null,
+            error: '',
+            tokens: []
+        };
+    }
+    let result = null;
+    const slice = atRule.tokens.slice();
+    consumeWhitespace(slice);
+    if (slice.length == 0) {
+        return {
+            valid: ValidationLevel.Valid,
+            matches: [],
+            node: atRule,
+            syntax: '@media',
+            error: '',
+            tokens: []
+        };
+    }
+    result = validateAtRuleMediaQueryList(atRule.tokens, atRule);
+    if (result.valid == ValidationLevel.Drop) {
+        return result;
+    }
+    if (!('chi' in atRule)) {
+        // @ts-ignore
+        return {
+            valid: ValidationLevel.Drop,
+            matches: [],
+            node: atRule,
+            syntax: '@media',
+            error: 'expected at-rule body',
+            tokens: []
+        };
+    }
+    // @ts-ignore
+    return {
+        valid: ValidationLevel.Valid,
+        matches: [],
+        node: atRule,
+        syntax: '@media',
+        error: '',
+        tokens: []
+    };
+}
+function validateAtRuleMediaQueryList(tokenList, atRule) {
+    const split = splitTokenList(tokenList);
+    const matched = [];
+    let result = null;
+    let previousToken;
+    let mediaFeatureType;
+    for (let i = 0; i < split.length; i++) {
+        const tokens = split[i].slice();
+        const match = [];
+        result = null;
+        mediaFeatureType = null;
+        previousToken = null;
+        if (tokens.length == 0) {
+            // @ts-ignore
+            result = {
+                valid: ValidationLevel.Drop,
+                matches: [],
+                node: tokens[0] ?? atRule,
+                syntax: '@media',
+                error: 'unexpected token',
+                tokens: []
+            };
+            continue;
+        }
+        while (tokens.length > 0) {
+            previousToken = tokens[0];
+            // media-condition | media-type | custom-media
+            if (!(validateMediaCondition(tokens[0], atRule) || validateMediaFeature(tokens[0]) || validateCustomMediaCondition(tokens[0], atRule))) {
+                if (tokens[0].typ == EnumToken.ParensTokenType) {
+                    result = validateAtRuleMediaQueryList(tokens[0].chi, atRule);
+                }
+                else {
+                    result = {
+                        valid: ValidationLevel.Drop,
+                        matches: [],
+                        node: tokens[0] ?? atRule,
+                        syntax: '@media',
+                        error: 'expecting media feature or media condition',
+                        tokens: []
+                    };
+                }
+                if (result.valid == ValidationLevel.Drop) {
+                    break;
+                }
+                result = null;
+            }
+            match.push(tokens.shift());
+            if (tokens.length == 0) {
+                break;
+            }
+            if (!consumeWhitespace(tokens)) {
+                if (previousToken?.typ != EnumToken.ParensTokenType) {
+                    // @ts-ignore
+                    result = {
+                        valid: ValidationLevel.Drop,
+                        matches: [],
+                        node: tokens[0] ?? atRule,
+                        syntax: '@media',
+                        error: 'expected media query list',
+                        tokens: []
+                    };
+                    break;
+                }
+            }
+            else if (![EnumToken.MediaFeatureOrTokenType, EnumToken.MediaFeatureAndTokenType].includes(tokens[0].typ)) {
+                // @ts-ignore
+                result = {
+                    valid: ValidationLevel.Drop,
+                    matches: [],
+                    node: tokens[0] ?? atRule,
+                    syntax: '@media',
+                    error: 'expected and/or',
+                    tokens: []
+                };
+                break;
+            }
+            if (mediaFeatureType == null) {
+                mediaFeatureType = tokens[0];
+            }
+            if (mediaFeatureType.typ != tokens[0].typ) {
+                // @ts-ignore
+                result = {
+                    valid: ValidationLevel.Drop,
+                    matches: [],
+                    node: tokens[0] ?? atRule,
+                    syntax: '@media',
+                    error: 'mixing and/or not allowed at the same level',
+                    tokens: []
+                };
+                break;
+            }
+            match.push({ typ: EnumToken.WhitespaceTokenType }, tokens.shift());
+            consumeWhitespace(tokens);
+            if (tokens.length == 0) {
+                // @ts-ignore
+                result = {
+                    valid: ValidationLevel.Drop,
+                    matches: [],
+                    node: tokens[0] ?? atRule,
+                    syntax: '@media',
+                    error: 'expected media-condition',
+                    tokens: []
+                };
+                break;
+            }
+            match.push({ typ: EnumToken.WhitespaceTokenType });
+        }
+        if (result == null && match.length > 0) {
+            matched.push(match);
+        }
+    }
+    if (result != null) {
+        return result;
+    }
+    if (matched.length == 0) {
+        return {
+            valid: ValidationLevel.Drop,
+            matches: [],
+            node: atRule,
+            syntax: '@media',
+            error: 'expected media query list',
+            tokens: []
+        };
+    }
+    tokenList.length = 0;
+    let hasAll = false;
+    for (let i = 0; i < matched.length; i++) {
+        if (tokenList.length > 0) {
+            tokenList.push({ typ: EnumToken.CommaTokenType });
+        }
+        if (matched[i].length == 1 && matched.length > 1 && matched[i][0].typ == EnumToken.MediaFeatureTokenType && matched[i][0].val == 'all') {
+            hasAll = true;
+            continue;
+        }
+        tokenList.push(...matched[i]);
+    }
+    if (hasAll && tokenList.length == 0) {
+        tokenList.push({ typ: EnumToken.MediaFeatureTokenType, val: 'all' });
+    }
+    // @ts-ignore
+    return {
+        valid: ValidationLevel.Valid,
+        matches: [],
+        node: atRule,
+        syntax: '@media',
+        error: '',
+        tokens: []
+    };
+}
+function validateCustomMediaCondition(token, atRule) {
+    if (token.typ == EnumToken.MediaFeatureNotTokenType) {
+        return validateMediaCondition(token.val, atRule);
+    }
+    if (token.typ != EnumToken.ParensTokenType) {
+        return false;
+    }
+    const chi = token.chi.filter((t) => t.typ != EnumToken.CommentTokenType && t.typ != EnumToken.WhitespaceTokenType);
+    if (chi.length != 1) {
+        return false;
+    }
+    return chi[0].typ == EnumToken.DashedIdenTokenType;
+}
+function validateMediaCondition(token, atRule) {
+    if (token.typ == EnumToken.MediaFeatureNotTokenType) {
+        return validateMediaCondition(token.val, atRule);
+    }
+    if (token.typ != EnumToken.ParensTokenType && !(['when', 'else'].includes(atRule.nam) && token.typ == EnumToken.FunctionTokenType && ['media', 'supports'].includes(token.val))) {
+        return false;
+    }
+    const chi = token.chi.filter((t) => t.typ != EnumToken.CommentTokenType && t.typ != EnumToken.WhitespaceTokenType);
+    if (chi.length != 1) {
+        return false;
+    }
+    if (chi[0].typ == EnumToken.IdenTokenType) {
+        return true;
+    }
+    if (chi[0].typ == EnumToken.MediaFeatureNotTokenType) {
+        return validateMediaCondition(chi[0].val, atRule);
+    }
+    if (chi[0].typ == EnumToken.MediaQueryConditionTokenType) {
+        return chi[0].l.typ == EnumToken.IdenTokenType;
+    }
+    return false;
+}
+function validateMediaFeature(token) {
+    let val = token;
+    if (token.typ == EnumToken.MediaFeatureOnlyTokenType || token.typ == EnumToken.MediaFeatureNotTokenType) {
+        val = token.val;
+    }
+    return val.typ == EnumToken.MediaFeatureTokenType;
+}
+
+export { validateAtRuleMedia, validateAtRuleMediaQueryList, validateMediaCondition, validateMediaFeature };

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 };