@tbela99/css-parser 1.4.1 → 1.4.3

package/dist/lib/parser/utils/at-rule-container.d.ts

@@ -0,0 +1,5 @@
+import type { AstAtRule, AtRuleToken, ErrorDescription, ParserOptions, Token } from "../../../@types/index.d.ts";
+export declare function parseAtRuleContainerQueryList(stream: Token[], context: AstAtRule | AtRuleToken, options?: ParserOptions): {
+    success: boolean;
+    errors: ErrorDescription[];
+};

package/dist/lib/parser/utils/at-rule-container.js

@@ -0,0 +1,486 @@
+import { EnumToken } from '../../ast/types.js';
+import { tokensfuncDefMap, mFLT, mFGT, definedPropertySettings } from '../../syntax/constants.js';
+import { matchAllSyntax, createValidationContext, trimArray, isStyleRangeValue } from '../../validation/match.js';
+import { ValidationSyntaxGroupEnum } from '../../validation/parser/typedef.js';
+import { getSyntaxRule } from '../../validation/config.js';
+import { parseColor } from '../../syntax/syntax.js';
+
+function parseAtRuleContainerQueryList(stream, context, options = {}) {
+    let matchCount = 0;
+    const errors = [];
+    const syntaxRules = getSyntaxRule(ValidationSyntaxGroupEnum.AtRules, "@" + context.nam);
+    const syntax = syntaxRules?.getPreludeRules()?.slice?.(1);
+    const parts = stream.reduce((acc, t) => {
+        if (t.typ === EnumToken.CommaTokenType && matchCount === 0) {
+            acc.push([]);
+        }
+        else {
+            acc[acc.length - 1].push(t);
+            if (t.typ === EnumToken.StartParensTokenType || tokensfuncDefMap.has(t.typ)) {
+                matchCount++;
+            }
+            else if (t.typ === EnumToken.EndParensTokenType) {
+                if (matchCount > 0) {
+                    matchCount--;
+                }
+            }
+        }
+        return acc;
+    }, [[]]);
+    const result = matchAllSyntax(syntax, createValidationContext(stream), options);
+    if (!result.success) {
+        errors.push(...result.errors);
+        return {
+            success: false,
+            errors,
+        };
+    }
+    {
+        for (const stream of parts.slice()) {
+            let success = true;
+            let i;
+            let currentScope = new Set();
+            const scopes = [currentScope];
+            const stack = [];
+            const tokens = [];
+            let expectAndOr = false;
+            i = 0;
+            while (i < stream.length &&
+                (stream[i]?.typ === EnumToken.WhitespaceTokenType || stream[i]?.typ === EnumToken.CommentTokenType)) {
+                tokens.push(stream[i++]);
+            }
+            if (i >= stream.length) {
+                return {
+                    success: false,
+                    errors: [
+                        {
+                            action: "drop",
+                            node: context,
+                            location: context.loc,
+                            message: `expecting <container-condition> at ${context.loc?.src}:${context?.loc?.sta.lin}:${context.loc?.sta.col}`,
+                        },
+                    ],
+                };
+            }
+            if (stream[i].typ === EnumToken.IdenTokenType) {
+                tokens.push(stream[i++]);
+            }
+            while (stream[i]?.typ === EnumToken.WhitespaceTokenType || stream[i]?.typ === EnumToken.CommentTokenType) {
+                tokens.push(stream[i++]);
+            }
+            if (i < stream.length &&
+                stream[i]?.typ !== EnumToken.StartParensTokenType &&
+                stream[i]?.typ !== EnumToken.ContainerFunctionTokenDefType) {
+                return {
+                    success: false,
+                    errors: [
+                        {
+                            action: "drop",
+                            node: stream[i],
+                            location: stream[i]?.loc ?? context.loc,
+                            message: `expecting <container-condition> at ${(stream[i] ?? context)?.loc?.src}:${(stream[i] ?? context)?.loc?.sta.lin}:${(stream[i] ?? context)?.loc?.sta.col}`,
+                        },
+                    ],
+                };
+            }
+            if (stream[i]?.typ === EnumToken.IdenTokenType) {
+                const val = stream[i].val.toLowerCase();
+                if ("not" === val) {
+                    tokens.push(stream[i]);
+                    stack.push(Object.assign(stream[i], { typ: EnumToken.NotTokenType }));
+                    i++;
+                }
+                else if ("and" === val || "or" === val) {
+                    return {
+                        success: false,
+                        errors: [
+                            {
+                                action: "drop",
+                                node: stream[i],
+                                location: stream[i]?.loc,
+                                message: `unexpected token at ${stream[i]?.loc?.src}:${stream[i]?.loc?.sta.lin}:${stream[i]?.loc?.sta.col}`,
+                            },
+                        ],
+                    };
+                }
+                else {
+                    tokens.push(stream[i++]);
+                }
+            }
+            for (; i < stream.length; i++) {
+                tokens.push(stream[i]);
+                if (stream[i].typ === EnumToken.WhitespaceTokenType || stream[i].typ === EnumToken.CommentTokenType) {
+                    continue;
+                }
+                if (expectAndOr) {
+                    let valid = true;
+                    if (stream[i].typ === EnumToken.IdenTokenType) {
+                        const val = stream[i].val.toLowerCase();
+                        valid = val === "and" || val === "or";
+                    }
+                    else {
+                        valid = stream[i].typ !== EnumToken.CommaTokenType;
+                    }
+                    if (!valid) {
+                        success = false;
+                        errors.push({
+                            action: "drop",
+                            node: stream[i],
+                            message: `expecting <and>, <or> or comma  at ${stream[i]?.loc?.src}:${stream[i]?.loc?.sta.lin}:${stream[i]?.loc?.sta.col}`,
+                        });
+                        break;
+                    }
+                    expectAndOr = false;
+                }
+                if (stream[i].typ === EnumToken.StartParensTokenType || tokensfuncDefMap.has(stream[i].typ)) {
+                    scopes.push((currentScope = new Set()));
+                    stack.push(stream[i]);
+                    continue;
+                }
+                switch (stream[i].typ) {
+                    case EnumToken.LiteralTokenType:
+                        if (stream[i].val === "<") {
+                            stack.push(Object.assign(stream[i], { typ: EnumToken.LtTokenType }));
+                        }
+                        if (stream[i].val === ">") {
+                            stack.push(Object.assign(stream[i], { typ: EnumToken.GtTokenType }));
+                        }
+                        break;
+                    case EnumToken.ColonTokenType:
+                    case EnumToken.LtTokenType:
+                    case EnumToken.LteTokenType:
+                    case EnumToken.GtTokenType:
+                    case EnumToken.GteTokenType:
+                    case EnumToken.DelimTokenType:
+                        stack.push(stream[i]);
+                        break;
+                    case EnumToken.IdenTokenType:
+                        {
+                            const val = stream[i].val.toLowerCase();
+                            if (val === "not") {
+                                Object.assign(stream[i], {
+                                    typ: EnumToken.NotTokenType,
+                                });
+                                stack.push(stream[i]);
+                            }
+                            else if (val === "and" || val === "or") {
+                                Object.assign(stream[i], {
+                                    typ: val === "and" ? EnumToken.AndTokenType : EnumToken.OrTokenType,
+                                });
+                                if (val === "or" && scopes.length <= 1) {
+                                    success = false;
+                                    errors.push({
+                                        action: "drop",
+                                        node: stream[i],
+                                        message: `<or> is not allowed outside of parentheses ${stream[i]?.loc?.src}:${stream[i]?.loc?.sta.lin}:${stream[i]?.loc?.sta.col}`,
+                                    });
+                                    break;
+                                }
+                                if (currentScope.has(val === "or" ? EnumToken.AndTokenType : EnumToken.OrTokenType)) {
+                                    success = false;
+                                    errors.push({
+                                        action: "drop",
+                                        node: stream[i],
+                                        message: `cannot mix <and> and <or> at the same level at ${stream[i]?.loc?.src}:${stream[i]?.loc?.sta.lin}:${stream[i]?.loc?.sta.col}`,
+                                    });
+                                    break;
+                                }
+                                currentScope.add(stream[i].typ);
+                                stack.push(stream[i]);
+                            }
+                            else if (scopes.length === 0) {
+                                success = false;
+                                errors.push({
+                                    action: "drop",
+                                    node: stream[i],
+                                    location: stream[i]?.loc,
+                                    message: `unexpected <ident> at ${stream[i]?.loc?.src}:${stream[i]?.loc?.sta.lin}:${stream[i]?.loc?.sta.col}`,
+                                });
+                                return {
+                                    success,
+                                    errors,
+                                };
+                            }
+                        }
+                        break;
+                    case EnumToken.EndParensTokenType:
+                        // feature
+                        if (mFLT.has(stack.at(-1)?.typ) || mFGT.has(stack.at(-1)?.typ)) {
+                            // <mf-lt> | <mf-gt>
+                            const index = tokens.indexOf(stack.at(-1));
+                            const prevToken = stack[stack.length - 2];
+                            if (mFLT.has(prevToken?.typ) || mFGT.has(prevToken?.typ)) {
+                                if (stack[stack.length - 3]?.typ !== EnumToken.StartParensTokenType) {
+                                    success = false;
+                                    errors.push({
+                                        action: "drop",
+                                        node: stream[i],
+                                        message: `unmatched '(' at ${stream[i]?.loc?.src}:${stream[i]?.loc?.sta.lin}:${stream[i]?.loc?.sta.col}`,
+                                    });
+                                    break;
+                                }
+                                if (!mFLT.has(stack.at(-1)?.typ) && mFLT.has(prevToken?.typ)) {
+                                    success = false;
+                                    errors.push({
+                                        action: "drop",
+                                        node: stack.at(-1),
+                                        message: `expected <mf-lt> at ${stack.at(-1)?.loc?.src}:${stack.at(-1)?.loc?.sta.lin}:${stack.at(-1)?.loc?.sta.col}`,
+                                    });
+                                    break;
+                                }
+                                else if (!mFGT.has(stack.at(-1)?.typ) && mFGT.has(prevToken?.typ)) {
+                                    success = false;
+                                    errors.push({
+                                        action: "drop",
+                                        node: stream[i],
+                                        message: `expected <mf-gt> at ${stack.at(-1)?.loc?.src}:${stack.at(-1)?.loc?.sta.lin}:${stack.at(-1)?.loc?.sta.col}`,
+                                    });
+                                    break;
+                                }
+                                // <style-range>
+                                // const index: number = tokens.indexOf(stack.at(-1)!);
+                                // <mf-lt> | <mf-gt>
+                                const index2 = tokens.indexOf(prevToken);
+                                // '('
+                                const index3 = tokens.indexOf(stack.at(-3));
+                                const left = trimArray(tokens.slice(index3 + 1, index2));
+                                const right = trimArray(tokens.slice(index + 1, tokens.length - 1));
+                                const names = trimArray(tokens.slice(index2 + 1, index));
+                                if (!isStyleRangeValue(left)) {
+                                    success = false;
+                                    errors.push({
+                                        action: "drop",
+                                        node: left[0],
+                                        message: `expected <style-feature-value> at ${left[0]?.loc?.src}:${left[0]?.loc?.sta.lin}:${left[0]?.loc?.sta.col}`,
+                                    });
+                                    break;
+                                }
+                                if (!isStyleRangeValue(right)) {
+                                    success = false;
+                                    errors.push({
+                                        action: "drop",
+                                        node: right[0],
+                                        message: `expected <style-feature-value> at ${right[0]?.loc?.src}:${right[0]?.loc?.sta.lin}:${right[0]?.loc?.sta.col}`,
+                                    });
+                                    break;
+                                }
+                                if (!isStyleRangeValue(names)) {
+                                    success = false;
+                                    errors.push({
+                                        action: "drop",
+                                        node: names[0],
+                                        message: `expected <style-feature-value> at ${names[0]?.loc?.src}:${names[0]?.loc?.sta.lin}:${names[0]?.loc?.sta.col}`,
+                                    });
+                                    break;
+                                }
+                                tokens.splice(index3 + 1, tokens.length - index3 - 2, Object.defineProperty({
+                                    typ: EnumToken.ContainerStyleRangeTokenType,
+                                    l: left,
+                                    op: names,
+                                    r: right,
+                                }, "loc", {
+                                    ...definedPropertySettings,
+                                    value: { ...left[0].loc, end: right.at(-1).loc.end },
+                                }));
+                                // check <style()> or <scroll-state()>
+                                stack.pop();
+                                stack.pop();
+                            }
+                            else if (stack[stack.length - 2]?.typ !== EnumToken.StartParensTokenType) {
+                                success = false;
+                                errors.push({
+                                    action: "drop",
+                                    node: stream[i],
+                                    location: stream[i]?.loc,
+                                    message: `expected '(' at ${stream[i]?.loc?.src}:${stream[i]?.loc?.sta.lin}:${stream[i]?.loc?.sta.col}`,
+                                });
+                                break;
+                            }
+                        }
+                        if (mFGT.has(stack.at(-1)?.typ) ||
+                            mFLT.has(stack.at(-1)?.typ) ||
+                            stack.at(-1)?.typ === EnumToken.DelimTokenType ||
+                            stack.at(-1)?.typ === EnumToken.ColonTokenType) {
+                            const funcName = stack[stack.length - 2].val?.toLowerCase?.();
+                            if (stack[stack.length - 2]?.typ !== EnumToken.StartParensTokenType &&
+                                !(stack[stack.length - 2]?.typ === EnumToken.ContainerFunctionTokenDefType &&
+                                    ("style" === funcName || "scroll-state" === funcName))) {
+                                success = false;
+                                errors.push({
+                                    action: "drop",
+                                    node: stream[i],
+                                    location: stream[i]?.loc,
+                                    message: `unmatched2 ')' at ${stream[i]?.loc?.src}:${stream[i]?.loc?.sta.lin}:${stream[i]?.loc?.sta.col}`,
+                                });
+                                break;
+                            }
+                            const index2 = tokens.indexOf(stack.at(-1));
+                            const index3 = tokens.indexOf(stack.at(-2));
+                            let names = trimArray(tokens.slice(index3 + 1, index2));
+                            let values = trimArray(tokens.slice(index2 + 1, tokens.length - 1));
+                            if (stack.at(-1)?.typ !== EnumToken.ColonTokenType &&
+                                stack.at(-1)?.typ !== EnumToken.DelimTokenType) {
+                                names.filter((n) => n.typ !== EnumToken.WhitespaceTokenType && n.typ !== EnumToken.CommentTokenType);
+                            }
+                            tokens.splice(index3 + 1, tokens.length - index3 - 2, Object.defineProperty({
+                                typ: EnumToken.MediaQueryConditionTokenType,
+                                l: names,
+                                op: stack.pop(),
+                                r: values,
+                            }, "loc", {
+                                ...definedPropertySettings,
+                                value: { ...names[0].loc, end: values.at(-1).loc.end },
+                            }));
+                            // check <style()> or <scroll-state()>
+                        }
+                        if (tokensfuncDefMap.has(stack.at(-1)?.typ)) {
+                            const index = tokens.indexOf(stack.at(-1));
+                            Object.defineProperty(Object.assign(tokens[index], {
+                                typ: tokensfuncDefMap.get(stack.at(-1)?.typ),
+                                chi: trimArray(tokens.slice(index + 1, tokens.length - 1)),
+                            }), "loc", {
+                                ...definedPropertySettings,
+                                value: { ...tokens[index].loc, end: stream[i].loc.end },
+                            });
+                            if (tokens[index].chi.every((t) => t.typ === EnumToken.WhitespaceTokenType || t.typ === EnumToken.CommentTokenType)) {
+                                success = false;
+                                errors.push({
+                                    action: "drop",
+                                    node: stream[i],
+                                    location: stream[i]?.loc,
+                                    message: `expecting '<${tokens[index].val}-query>' at ${stream[i]?.loc?.src}:${stream[i]?.loc?.sta.lin}:${stream[i]?.loc?.sta.col}`,
+                                });
+                                break;
+                            }
+                            tokens.length = index + 1;
+                            if (EnumToken.ColorTokenType === tokens[index].typ) {
+                                parseColor(tokens[index]);
+                            }
+                            stack.pop();
+                            scopes.pop();
+                            currentScope = scopes.at(-1);
+                        }
+                        else {
+                            const index = tokens.indexOf(stack.at(-1));
+                            tokens[index] = Object.defineProperty({
+                                typ: EnumToken.ParensTokenType,
+                                chi: tokens.slice(index + 1, tokens.length - 1),
+                            }, "loc", {
+                                ...definedPropertySettings,
+                                value: { ...tokens[index].loc, end: stream[i].loc.end },
+                            });
+                            if (tokens[index].chi.every((t) => t.typ === EnumToken.WhitespaceTokenType || t.typ === EnumToken.CommentTokenType)) {
+                                success = false;
+                                errors.push({
+                                    action: "drop",
+                                    node: stream[i],
+                                    location: stream[i]?.loc,
+                                    message: `expecting '<query-in-parens>' at ${stream[i]?.loc?.src}:${stream[i]?.loc?.sta.lin}:${stream[i]?.loc?.sta.col}`,
+                                });
+                                break;
+                            }
+                            tokens.length = index + 1;
+                            scopes.pop();
+                            currentScope = scopes.at(-1);
+                            stack.pop();
+                        }
+                        if (stack.at(-1)?.typ === EnumToken.NotTokenType) {
+                            let j = tokens.indexOf(stack.at(-1));
+                            let k = j;
+                            while (j-- &&
+                                (tokens[j]?.typ === EnumToken.WhitespaceTokenType ||
+                                    tokens[j]?.typ === EnumToken.CommentTokenType)) { }
+                            if (j >= 0) {
+                                if (tokens[j]?.typ !== EnumToken.StartParensTokenType) {
+                                    success = false;
+                                    errors.push({
+                                        action: "drop",
+                                        node: tokens[k],
+                                        location: tokens[k]?.loc,
+                                        message: `unexpected token 'not' at ${tokens[k]?.loc?.src}:${tokens[k]?.loc?.sta.lin}:${tokens[k]?.loc?.sta.col}`,
+                                    });
+                                    break;
+                                }
+                            }
+                            const index = tokens.indexOf(stack.at(-1));
+                            const slice = trimArray(tokens.slice(index + 1));
+                            tokens[index] = Object.defineProperty({
+                                typ: EnumToken.MediaQueryUnaryFeatureTokenType,
+                                l: stack.pop(),
+                                r: slice,
+                            }, "loc", {
+                                ...definedPropertySettings,
+                                value: { ...tokens[index].loc, end: slice.at(-1).loc.end },
+                            });
+                            tokens.length = index + 1;
+                        }
+                        if (stack.at(-1)?.typ === EnumToken.AndTokenType ||
+                            stack.at(-1)?.typ === EnumToken.OrTokenType) {
+                            const index = tokens.indexOf(stack.at(-1));
+                            let l = index - 1;
+                            while (l > 0 &&
+                                (tokens[l].typ === EnumToken.WhitespaceTokenType ||
+                                    tokens[l].typ === EnumToken.CommentTokenType)) {
+                                l--;
+                            }
+                            const left = trimArray(tokens.slice(l, index));
+                            const right = trimArray(tokens.slice(index + 1));
+                            tokens[l] = Object.defineProperty({
+                                typ: EnumToken.MediaQueryConditionTokenType,
+                                op: stack.pop(),
+                                l: left,
+                                r: right,
+                            }, "loc", {
+                                ...definedPropertySettings,
+                                value: { ...left[0].loc, end: right.at(-1).loc.end },
+                            });
+                            tokens.length = l + 1;
+                            expectAndOr = true;
+                        }
+                        break;
+                    default:
+                        if (tokensfuncDefMap.has(stream[i]?.typ)) {
+                            stack.push(stream[i]);
+                            scopes.push((currentScope = new Set()));
+                        }
+                        break;
+                }
+                if (!success) {
+                    break;
+                }
+            }
+            if (success && stack.length > 0) {
+                success = false;
+                errors.push({
+                    action: "drop",
+                    node: stack.at(-1),
+                    message: `unmatched token '${EnumToken[stack.at(-1)?.typ]}' at ${stack.at(-1)?.loc?.src}:${stack.at(-1)?.loc?.sta.lin}:${stack.at(-1)?.loc?.sta.col}`,
+                });
+            }
+            if (!success) {
+                return {
+                    success,
+                    errors,
+                };
+            }
+            stream.length = 0;
+            stream.push(...trimArray(tokens));
+        }
+    }
+    stream.length = 0;
+    stream.push(...parts
+        .filter((p) => p.length > 0 && p[0].typ !== EnumToken.InvalidMediaQueryTokenType)
+        .reduce((acc, b) => {
+        if (acc.length > 0) {
+            acc.push({ typ: EnumToken.CommaTokenType });
+        }
+        acc.push(...b);
+        return acc;
+    }, []));
+    return {
+        success: true,
+        errors,
+    };
+}
+
+export { parseAtRuleContainerQueryList };

package/dist/lib/parser/utils/at-rule-font-feature-values.d.ts

@@ -0,0 +1,5 @@
+import type { ParserOptions, Token, AstAtRule, AtRuleToken } from "../../../@types/index.d.ts";
+export declare function parseAtRuleFontFeatureValues(stream: Token[], context: AstAtRule | AtRuleToken, options?: ParserOptions): {
+    success: boolean;
+    errors: import("../../../@types/index.d.ts").ErrorDescription[];
+};

package/dist/lib/parser/utils/at-rule-font-feature-values.js

@@ -0,0 +1,13 @@
+import { getSyntaxRule } from '../../validation/config.js';
+import { trimArray, matchAllSyntax, createValidationContext } from '../../validation/match.js';
+import { ValidationSyntaxGroupEnum } from '../../validation/parser/typedef.js';
+
+function parseAtRuleFontFeatureValues(stream, context, options = {}) {
+    const syntaxRules = getSyntaxRule(ValidationSyntaxGroupEnum.AtRules, "@" + context.nam);
+    const syntax = syntaxRules?.getPreludeRules()?.slice?.(1);
+    trimArray(stream);
+    const { success, errors} = matchAllSyntax(syntax, createValidationContext(stream), options);
+    return { success, errors };
+}
+
+export { parseAtRuleFontFeatureValues };

package/dist/lib/parser/utils/at-rule-generic.d.ts

@@ -0,0 +1,5 @@
+import type { AtRuleToken, ErrorDescription, ParserOptions, Token, ValidationOptions } from "../../../@types/index.d.ts";
+export declare function matchGenericSyntax(atRule: AtRuleToken, stream: Token[], options: ParserOptions | ValidationOptions): {
+    success: boolean;
+    errors: ErrorDescription[];
+};

package/dist/lib/parser/utils/at-rule-generic.js

@@ -0,0 +1,118 @@
+import { EnumToken } from '../../ast/types.js';
+import { tokensfuncDefMap } from '../../syntax/constants.js';
+import { equalsIgnoreCase } from './text.js';
+
+function matchGenericSyntax(atRule, stream, options) {
+    const stack = [];
+    let i = 0;
+    let success = true;
+    let expectAndOr = false;
+    let expectComma = false;
+    const errors = [];
+    const scopes = [new Set()];
+    for (; i < stream.length; i++) {
+        const token = stream[i];
+        if (token.typ === EnumToken.WhitespaceTokenType || token.typ === EnumToken.CommentTokenType) {
+            continue;
+        }
+        if (token.typ === EnumToken.StartParensTokenType || tokensfuncDefMap.has(token.typ)) {
+            stack.push(token);
+            scopes.push(new Set());
+            expectAndOr = false;
+            continue;
+        }
+        if (token.typ === EnumToken.EndParensTokenType) {
+            if (stack.length === 0 ||
+                (stack.at(-1)?.typ !== EnumToken.ParensTokenType && !tokensfuncDefMap.has(stack.at(-1)?.typ))) {
+                errors.push({
+                    action: "drop",
+                    message: `unexpected token ${EnumToken[token.typ]} at ${token.loc.src}:${token.loc.sta.lin}:${token.loc.sta.col}`,
+                    node: token,
+                    location: token.loc,
+                });
+                success = false;
+                break;
+            }
+            stack.pop();
+            scopes.pop();
+            if (scopes.length === 0) {
+                return {
+                    success: false,
+                    errors: [
+                        {
+                            action: "drop",
+                            node: token,
+                            message: `Unexpected token ${EnumToken[token.typ]} at ${token.loc.src}:${token.loc.sta.lin}:${token.loc.sta.col}`,
+                            location: token.loc,
+                        },
+                    ],
+                };
+            }
+            continue;
+        }
+        if (token.typ === EnumToken.IdenTokenType && equalsIgnoreCase("and", token.val)) {
+            if (!expectAndOr || scopes.at(-1)?.has(EnumToken.OrTokenType)) {
+                errors.push({
+                    action: "drop",
+                    message: `unexpected token ${EnumToken[token.typ]} at ${token.loc.src}:${token.loc.sta.lin}:${token.loc.sta.col}`,
+                    node: token,
+                    location: token.loc,
+                });
+                success = false;
+                break;
+            }
+            Object.assign(token, { typ: EnumToken.AndTokenType });
+            scopes.at(-1).add(EnumToken.AndTokenType);
+            expectComma = false;
+            continue;
+        }
+        if (token.typ === EnumToken.IdenTokenType && equalsIgnoreCase("or", token.val)) {
+            if (!expectAndOr || scopes.at(-1)?.has(EnumToken.AndTokenType)) {
+                errors.push({
+                    action: "drop",
+                    message: `unexpected token ${EnumToken[token.typ]} at ${token.loc.src}:${token.loc.sta.lin}:${token.loc.sta.col}`,
+                    node: token,
+                    location: token.loc,
+                });
+                success = false;
+                break;
+            }
+            expectComma = false;
+            Object.assign(token, { typ: EnumToken.OrTokenType });
+            scopes.at(-1).add(EnumToken.OrTokenType);
+            continue;
+        }
+        if (token.typ === EnumToken.CommaTokenType) {
+            if (!expectComma) {
+                errors.push({
+                    action: "drop",
+                    message: `unexpected token ${EnumToken[token.typ]} at ${token.loc.src}:${token.loc.sta.lin}:${token.loc.sta.col}`,
+                    node: token,
+                    location: token.loc,
+                });
+                success = false;
+                break;
+            }
+            stack.push(token);
+            expectComma = false;
+            continue;
+        }
+        expectAndOr = true;
+        expectComma = true;
+        if (stack.length > 0 && stack.at(-1)?.typ === EnumToken.CommaTokenType) {
+            stack.pop();
+        }
+    }
+    if (stack.length > 0) {
+        errors.push({
+            action: "drop",
+            message: `unexpected token ${EnumToken[stack.at(-1)?.typ]} at ${stack.at(-1)?.loc?.src}:${stack.at(-1)?.loc?.sta.lin}:${stack.at(-1)?.loc?.sta.col}`,
+            node: stack.at(-1),
+            location: stack.at(-1)?.loc,
+        });
+        success = false;
+    }
+    return { success, errors };
+}
+
+export { matchGenericSyntax };

package/dist/lib/parser/utils/at-rule-import.d.ts

@@ -0,0 +1,5 @@
+import type { AstAtRule, AstRule, AstStyleSheet, AtRuleToken, ErrorDescription, ParserOptions, Token } from "../../../@types/index.d.ts";
+export declare function matchAtRuleImportSyntax(atRule: AtRuleToken, stream: Token[], context: AstRule | AstAtRule | AstStyleSheet, options: ParserOptions): {
+    success: boolean;
+    errors: ErrorDescription[];
+};