@tbela99/css-parser 1.4.1 → 1.4.3

package/dist/lib/ast/features/if.js

@@ -0,0 +1,215 @@
+import { EnumToken } from '../types.js';
+import { renderToken } from '../../renderer/render.js';
+import { FeatureWalkMode } from './type.js';
+import { definedPropertySettings } from '../../syntax/constants.js';
+import { equalsIgnoreCase } from '../../parser/utils/text.js';
+import { replaceToken } from '../../parser/utils/token.js';
+import { cloneNode } from '../clone.js';
+import { trimArray } from '../../validation/match.js';
+import { findByValue } from '../find.js';
+import { walk } from '../walk.js';
+import { eq } from '../../parser/utils/eq.js';
+
+const nodeMatcher = (value) => value.typ === EnumToken.IfConditionTokenType ||
+    (value.typ === EnumToken.WildCardFunctionTokenType && equalsIgnoreCase("if", value.val));
+function substituteIfElseNode(declaration, node, wrapper, parentWrapper, cache) {
+    const result = [];
+    let nodeMap = new Map();
+    let clonedDeclaration;
+    let targetParentWrapper = parentWrapper;
+    let targetWrapper = wrapper;
+    if (node.typ === EnumToken.IfElseConditionTokenType) {
+        //
+        clonedDeclaration = cloneNode(declaration, true, nodeMap);
+        let replaceRight = true;
+        // replace else: ... with the actual value
+        if (node.r.typ === EnumToken.IfConditionTokenType) {
+            const target = node.r.l.find((t) => t.typ != EnumToken.CommentTokenType && t.typ != EnumToken.WhitespaceTokenType);
+            if (target == null) {
+                return result;
+            }
+            //
+            if (target.typ === EnumToken.IdenTokenType && equalsIgnoreCase("else", target.val)) {
+                replaceToken(nodeMap.get(targetParentWrapper), nodeMap.get(targetWrapper), node.r.r.at(-1)?.typ ===
+                    EnumToken.SemiColonTokenType
+                    ? trimArray(node.r.r.slice(0, -1))
+                    : node.r.r);
+                if (targetParentWrapper.typ != EnumToken.DeclarationNodeType) {
+                    let index = targetParentWrapper.chi.indexOf(targetWrapper);
+                    if (index != -1) {
+                        let i;
+                        let k;
+                        let siblingWrapper;
+                        let left = node.l.l.find((t) => t.typ != EnumToken.CommentTokenType && t.typ != EnumToken.WhitespaceTokenType);
+                        for (i = index + 1; i < targetParentWrapper.chi.length; i++) {
+                            if (targetParentWrapper.chi[i].typ === targetWrapper.typ) {
+                                siblingWrapper = targetParentWrapper.chi[i];
+                                for (k = 0; k < siblingWrapper.chi.length; k++) {
+                                    if (siblingWrapper.chi[k].typ === EnumToken.IfElseConditionTokenType) {
+                                        let leftSide = siblingWrapper.chi[k].l.l.find((t) => t.typ != EnumToken.CommentTokenType &&
+                                            t.typ != EnumToken.WhitespaceTokenType);
+                                        if (eq(left, leftSide)) {
+                                            replaceToken(nodeMap.get(targetParentWrapper), nodeMap.get(targetParentWrapper.chi[i]), siblingWrapper.chi[k]
+                                                .r.r.at(-1)?.typ === EnumToken.SemiColonTokenType
+                                                ? trimArray(siblingWrapper.chi[k]
+                                                    .r.r.slice(0, -1))
+                                                : siblingWrapper.chi[k]
+                                                    .r.r);
+                                            cache.add(siblingWrapper.chi[k].l);
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+                replaceRight = false;
+            }
+        }
+        if (replaceRight) {
+            replaceToken(nodeMap.get(targetParentWrapper), nodeMap.get(targetWrapper), node.r);
+        }
+        result.push(clonedDeclaration);
+        nodeMap.clear();
+        clonedDeclaration = cloneNode(declaration, true, nodeMap);
+        replaceToken(nodeMap.get(targetParentWrapper), nodeMap.get(targetWrapper), node.l);
+        result.push(clonedDeclaration);
+    }
+    else if (node.typ === EnumToken.IfConditionTokenType) {
+        const left = node.l.find((t) => t.typ != EnumToken.CommentTokenType && t.typ != EnumToken.WhitespaceTokenType);
+        if (left == null) {
+            return result;
+        }
+        if (left.typ === EnumToken.IdenTokenType && equalsIgnoreCase("else", left.val)) {
+            clonedDeclaration = cloneNode(declaration, true, nodeMap);
+            replaceToken(nodeMap.get(parentWrapper), nodeMap.get(targetWrapper.typ === EnumToken.DeclarationNodeType ? node : targetWrapper), node.r.at(-1)?.typ === EnumToken.SemiColonTokenType ? trimArray(node.r.slice(0, -1)) : node.r);
+            result.push(clonedDeclaration);
+        }
+        else if (left?.typ === EnumToken.WhenElseFunctionTokenType) {
+            const atRule = Object.assign(cloneNode(declaration), {
+                typ: EnumToken.AtRuleNodeType,
+                nam: left.val,
+                chi: [],
+            });
+            Object.defineProperty(atRule, "tokens", {
+                ...definedPropertySettings,
+                value: [{ typ: EnumToken.ParensTokenType, chi: left.chi.slice() }],
+            });
+            atRule.val = atRule.tokens.reduce((acc, curr) => acc + renderToken(curr), "");
+            clonedDeclaration = cloneNode(declaration, true, nodeMap);
+            replaceToken(nodeMap.get(targetWrapper), nodeMap.get(node), node.r.at(-1)?.typ === EnumToken.SemiColonTokenType ? trimArray(node.r.slice(0, -1)) : node.r);
+            clonedDeclaration.parent = atRule;
+            atRule.chi.push(clonedDeclaration);
+            result.push(atRule);
+            processNode(clonedDeclaration, cache);
+            // nodeMap.clear();
+        }
+        else if (left.typ === EnumToken.ContainerFunctionTokenType) {
+            const atRule = Object.assign(cloneNode(declaration), {
+                typ: EnumToken.AtRuleNodeType,
+                nam: "container",
+                chi: [],
+            });
+            Object.defineProperty(atRule, "tokens", { ...definedPropertySettings, value: [left] });
+            atRule.val = atRule.tokens.reduce((acc, curr) => acc + renderToken(curr), "");
+            clonedDeclaration = cloneNode(declaration, true, nodeMap);
+            replaceToken(nodeMap.get(targetWrapper.typ === EnumToken.WildCardFunctionTokenType ? targetParentWrapper : targetWrapper), nodeMap.get(targetWrapper.typ === EnumToken.WildCardFunctionTokenType ? targetWrapper : node), node.r.at(-1)?.typ === EnumToken.SemiColonTokenType
+                ? trimArray(node.r.slice(0, -1))
+                : node.r);
+            clonedDeclaration.parent = atRule;
+            atRule.chi.push(clonedDeclaration);
+            result.push(atRule);
+            processNode(clonedDeclaration, cache);
+        }
+    }
+    else if (wrapper.typ === EnumToken.WildCardFunctionTokenType) {
+        clonedDeclaration = cloneNode(declaration, true, nodeMap);
+        replaceToken(nodeMap.get(parentWrapper), nodeMap.get(wrapper), node);
+        result.push(clonedDeclaration);
+    }
+    return result;
+}
+function processNode(declarationNode, cache) {
+    let i;
+    let k = -1;
+    let astNode;
+    const result = [];
+    const stack = [declarationNode];
+    while (++k < stack.length) {
+        astNode = stack[k];
+        const { node: declaration, value: node } = findByValue(astNode, nodeMatcher) ?? {};
+        if (node != null && cache.has(node.node)) {
+            continue;
+        }
+        if (declaration == null || node == null) {
+            while (astNode.parent != null && astNode.parent != declarationNode.parent) {
+                astNode = astNode.parent;
+            }
+            result.push(astNode);
+            continue;
+        }
+        // @ts-expect-error
+        const parents = [...node.parents?.()];
+        const parentWrapper = node.parent ?? parents.find((node) => !nodeMatcher(node));
+        if (node.node.typ === EnumToken.WildCardFunctionTokenType) {
+            for (i = 0; i < node.node.chi.length; i++) {
+                if (cache.has(node.node.chi[i])) {
+                    continue;
+                }
+                stack.push(...substituteIfElseNode(declaration, node.node.chi[i], node.node, parentWrapper, cache));
+            }
+        }
+        else {
+            stack.push(...substituteIfElseNode(declaration, node.node, parentWrapper, parents[parents.indexOf(parentWrapper) + 1] ?? declaration, cache));
+        }
+    }
+    if (result.length > 0) {
+        replaceToken(declarationNode.parent, declarationNode, result);
+    }
+    // else remove node?
+    return result;
+}
+class ExpandIfFeature {
+    accept = new Set([EnumToken.DeclarationNodeType]);
+    get ordering() {
+        return 5;
+    }
+    get processMode() {
+        return FeatureWalkMode.Pre;
+    }
+    static register(options) {
+        if (options.expandIfSyntax) {
+            // @ts-ignore
+            options.features.push(new ExpandIfFeature());
+        }
+    }
+    run(declaration) {
+        const cache = new Set();
+        const result = processNode(declaration, cache);
+        let i;
+        for (const n of result) {
+            for (const { node } of walk(n)) {
+                if (node.typ === EnumToken.AtRuleNodeType && Array.isArray(node.chi)) {
+                    for (i = 0; i < node.chi.length; i++) {
+                        if (node.chi[i].typ === EnumToken.AtRuleNodeType &&
+                            node.chi[i + 1]?.typ === EnumToken.AtRuleNodeType &&
+                            node.chi[i].nam === node.chi[i + 1].nam &&
+                            node.chi[i].val === node.chi[i + 1].val) {
+                            node.chi[i].chi.push(...node.chi[i + 1].chi);
+                            node.chi.splice(i + 1, 1);
+                        }
+                    }
+                    for (i = 0; i < node.chi.length; i++) {
+                        if (node.chi[i].typ === EnumToken.AtRuleNodeType &&
+                            node.chi[i].nam === node.nam &&
+                            node.chi[i].val === node.val) {
+                            node.chi.splice(i, 1, ...node.chi[i].chi);
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+export { ExpandIfFeature };

package/dist/lib/ast/features/index.d.ts

@@ -0,0 +1,6 @@
+export * from './prefix.ts';
+export * from './inlinecssvariables.ts';
+export * from './shorthand.ts';
+export * from './calc.ts';
+export * from './transform.ts';
+export * from './if.ts';

package/dist/lib/ast/features/index.js

@@ -3,3 +3,4 @@ export { InlineCssVariablesFeature } from './inlinecssvariables.js';
 export { ComputeShorthandFeature } from './shorthand.js';
 export { ComputeCalcExpressionFeature } from './calc.js';
 export { TransformCssFeature } from './transform.js';
+export { ExpandIfFeature } from './if.js';

package/dist/lib/ast/features/inlinecssvariables.d.ts

@@ -0,0 +1,15 @@
+import type { AstAtRule, AstNode, AstRule, AstStyleSheet, ParserOptions } from "../../../@types/index.d.ts";
+import { EnumToken } from "../types.ts";
+import { FeatureWalkMode } from "./type.ts";
+export declare class InlineCssVariablesFeature {
+    accept: Set<EnumToken>;
+    get ordering(): number;
+    get processMode(): FeatureWalkMode;
+    static register(options: ParserOptions): void;
+    run(ast: AstRule | AstAtRule, options: ParserOptions | undefined, parent: AstRule | AstAtRule | AstStyleSheet, context: {
+        [key: string]: any;
+    }): AstNode | null;
+    cleanup(ast: AstStyleSheet, options: ParserOptions | undefined, context: {
+        [key: string]: any;
+    }): void;
+}

package/dist/lib/ast/features/inlinecssvariables.js

@@ -1,20 +1,20 @@
 import { EnumToken } from '../types.js';
 import { walkValues } from '../walk.js';
 import { renderToken } from '../../renderer/render.js';
-import '../../renderer/sourcemap/lib/encode.js';
-import { mathFuncs } from '../../syntax/syntax.js';
 import { splitRule } from '../minify.js';
-import '../../parser/parse.js';
-import '../../parser/tokenize.js';
-import '../../parser/utils/config.js';
 import { FeatureWalkMode } from './type.js';
+import { mathFuncs } from '../../syntax/constants.js';
 
 function inlineExpression(token) {
     const result = [];
     if (token.typ == EnumToken.BinaryExpressionTokenType) {
         result.push({
             typ: EnumToken.ParensTokenType,
-            chi: [...inlineExpression(token.l), { typ: token.op }, ...inlineExpression(token.r)]
+            chi: [
+                ...inlineExpression(token.l),
+                { typ: token.op },
+                ...inlineExpression(token.r),
+            ],
         });
     }
     else {
@@ -24,15 +24,17 @@ function inlineExpression(token) {
 }
 function replace(node, variableScope) {
     for (const { value, parent: parentValue } of walkValues(node.val)) {
-        if (value.typ == EnumToken.BinaryExpressionTokenType && parentValue != null && 'chi' in parentValue) {
+        if (value.typ == EnumToken.BinaryExpressionTokenType && parentValue != null && "chi" in parentValue) {
             // @ts-ignore
             parentValue.chi.splice(parentValue.chi.indexOf(value), 1, ...inlineExpression(value));
         }
     }
     for (const { value, parent: parentValue } of walkValues(node.val)) {
-        if (value.typ == EnumToken.FunctionTokenType && value.val == 'var') {
-            if (value.chi.length == 1 && value.chi[0].typ == EnumToken.DashedIdenTokenType) {
-                const info = variableScope.get(value.chi[0].val);
+        if (value.typ == EnumToken.MathFunctionTokenDefType ||
+            (value.typ == EnumToken.WildCardFunctionTokenType && value.val == "var")) {
+            if (value.chi.length == 1 &&
+                value.chi[0].typ == EnumToken.DashedIdenTokenType) {
+                const info = (variableScope.get(value.chi[0].val));
                 if (info?.replaceable) {
                     if (parentValue != null) {
                         let i = 0;
@@ -66,24 +68,25 @@ class InlineCssVariablesFeature {
         }
     }
     run(ast, options = {}, parent, context) {
-        // if (!('chi' in ast)) {
-        //
-        //     return null;
-        // }
-        if (!('variableScope' in context)) {
-            context.variableScope = new Map;
+        if (!("chi" in ast)) {
+            return null;
+        }
+        if (!("variableScope" in context)) {
+            context.variableScope = new Map();
         }
         // [':root', 'html']
-        const isRoot = parent.typ == EnumToken.StyleSheetNodeType && ast.typ == EnumToken.RuleNodeType && (ast.raw ?? splitRule(ast.sel)).some(segment => segment.some(s => s == ':root' || s == 'html'));
+        const isRoot = parent.typ == EnumToken.StyleSheetNodeType &&
+            ast.typ == EnumToken.RuleNodeType &&
+            (ast.raw ?? splitRule(ast.sel)).some((segment) => segment.some((s) => s == ":root" || s == "html"));
         const variableScope = context.variableScope;
         // @ts-ignore
         for (const node of ast.chi) {
-            if (node.typ != EnumToken.DeclarationNodeType) {
+            if (node.typ !== EnumToken.DeclarationNodeType) {
                 continue;
             }
             // css variable
-            if (node.nam.startsWith('--')) {
-                if (!variableScope.has(node.nam)) {
+            if (node.nam.startsWith("--")) {
+                if (!variableScope.has(node.val)) {
                     const info = {
                         globalScope: isRoot,
                         // @ts-ignore
@@ -91,13 +94,16 @@ class InlineCssVariablesFeature {
                         declarationCount: 1,
                         replaceable: isRoot,
                         node: node,
-                        values: structuredClone(node.val)
+                        values: structuredClone(node.val),
                     };
                     info.parent.add(ast);
                     variableScope.set(node.nam, info);
                     let recursive = false;
                     for (const { value } of walkValues(node.val)) {
-                        if (value?.typ == EnumToken.FunctionTokenType && (mathFuncs.includes(value.val) || value.val == 'var')) {
+                        if (value?.typ == EnumToken.MathFunctionTokenDefType ||
+                            (value?.typ == EnumToken.WildCardFunctionTokenType &&
+                                (mathFuncs.includes(value.val) ||
+                                    value.val === "var"))) {
                             recursive = true;
                             break;
                         }
@@ -115,10 +121,9 @@ class InlineCssVariablesFeature {
     }
     cleanup(ast, options = {}, context) {
         const variableScope = context.variableScope;
-        // if (variableScope == null) {
-        //
-        //     return;
-        // }
+        if (variableScope == null) {
+            return;
+        }
         for (const info of variableScope.values()) {
             if (info.replaceable) {
                 let i;
@@ -130,7 +135,7 @@ class InlineCssVariablesFeature {
                             // @ts-ignore
                             parent.chi.splice(i, 1, {
                                 typ: EnumToken.CommentTokenType,
-                                val: `/* ${info.node.nam}: ${info.values.reduce((acc, curr) => acc + renderToken(curr, { convertColor: false }), '')} */`
+                                val: `/* ${info.node.nam}: ${info.values.reduce((acc, curr) => acc + renderToken(curr, { convertColor: false }), "")} */`,
                             });
                             break;
                         }

package/dist/lib/ast/features/prefix.d.ts

@@ -0,0 +1,8 @@
+import type { AstNode, ParserOptions } from "../../../@types/index.d.ts";
+import { FeatureWalkMode } from "./type.ts";
+export declare class ComputePrefixFeature {
+    get ordering(): number;
+    get processMode(): FeatureWalkMode;
+    static register(options: ParserOptions): void;
+    run(node: AstNode): AstNode | null;
+}

package/dist/lib/ast/features/prefix.js

@@ -1,48 +1,65 @@
-import { EnumToken, SyntaxValidationResult } from '../types.js';
-import { getSyntaxConfig } from '../../validation/config.js';
-import '../../validation/parser/parse.js';
-import { splitRule } from '../minify.js';
+import { EnumToken } from '../types.js';
 import { walkValues } from '../walk.js';
-import '../../parser/parse.js';
-import '../../parser/tokenize.js';
-import '../../parser/utils/config.js';
 import { pseudoAliasMap } from '../../syntax/syntax.js';
+import { splitRule } from '../minify.js';
 import { renderToken } from '../../renderer/render.js';
-import '../../renderer/sourcemap/lib/encode.js';
-import '../../validation/syntaxes/complex-selector.js';
-import { evaluateSyntax } from '../../validation/syntax.js';
-import { funcLike } from '../../syntax/color/utils/constants.js';
+import { funcLike } from '../../syntax/constants.js';
 import { FeatureWalkMode } from './type.js';
+import { ValidationSyntaxGroupEnum } from '../../validation/parser/typedef.js';
+import { getSyntaxConfig } from '../../validation/config.js';
+import { splitTokenList } from '../../validation/utils/list.js';
 
 const config = getSyntaxConfig();
 function replacePseudo(tokens) {
-    return tokens.map((raw) => raw.map(r => {
-        if (r.includes('(')) {
-            const index = r.indexOf('(');
-            const name = r.slice(0, index) + '()';
+    return tokens.map((raw) => raw.map((r) => {
+        if (r.includes("(")) {
+            const index = r.indexOf("(");
+            const name = r.slice(0, index) + "()";
             if (name in pseudoAliasMap) {
                 return pseudoAliasMap[name] + r.slice(index);
             }
             return r;
         }
-        return r in pseudoAliasMap && pseudoAliasMap[r] in config["selectors" /* ValidationSyntaxGroupEnum.Selectors */] ? pseudoAliasMap[r] : r;
+        return r in pseudoAliasMap && pseudoAliasMap[r] in config[ValidationSyntaxGroupEnum.Selectors]
+            ? pseudoAliasMap[r]
+            : r;
     }));
 }
 function replaceAstNodes(tokens, root) {
     let result = false;
     for (const { value, parent } of walkValues(tokens, root)) {
-        if (value.typ == EnumToken.IdenTokenType || value.typ == EnumToken.PseudoClassFuncTokenType || value.typ == EnumToken.PseudoClassTokenType || value.typ == EnumToken.PseudoElementTokenType) {
-            let key = value.val + (value.typ == EnumToken.PseudoClassFuncTokenType ? '()' : '');
+        if (value.typ == EnumToken.MediaQueryConditionTokenType) {
+            const token = value.l.find((t) => t.typ == EnumToken.IdenTokenType);
+            if (token != null) {
+                if (token.val in pseudoAliasMap) {
+                    token.val = pseudoAliasMap[token.val];
+                    if (["min-resolution", "max-resolution"].includes(token.val) &&
+                        value.r?.[0]?.typ == EnumToken.NumberTokenType) {
+                        Object.assign(value.r?.[0], {
+                            typ: EnumToken.ResolutionTokenType,
+                            unit: "x",
+                        });
+                        result = true;
+                    }
+                }
+            }
+        }
+        else if (value.typ == EnumToken.IdenTokenType ||
+            value.typ == EnumToken.PseudoClassFuncTokenType ||
+            value.typ == EnumToken.PseudoClassTokenType ||
+            value.typ == EnumToken.PseudoElementTokenType) {
+            let key = value.val +
+                (value.typ == EnumToken.PseudoClassFuncTokenType ? "()" : "");
             if (key in pseudoAliasMap) {
-                const isPseudClass = pseudoAliasMap[key].startsWith('::');
+                const isPseudClass = pseudoAliasMap[key].startsWith("::");
                 value.val = pseudoAliasMap[key];
                 if (value.typ == EnumToken.IdenTokenType &&
-                    ['min-resolution', 'max-resolution'].includes(value.val) &&
+                    ["min-resolution", "max-resolution"].includes(value.val) &&
                     parent?.typ == EnumToken.MediaQueryConditionTokenType &&
                     parent.r?.[0]?.typ == EnumToken.NumberTokenType) {
                     Object.assign(parent.r?.[0], {
                         typ: EnumToken.ResolutionTokenType,
-                        unit: 'x',
+                        unit: "x",
                     });
                 }
                 else if (isPseudClass && value.typ == EnumToken.PseudoElementTokenType) {
@@ -53,6 +70,24 @@ function replaceAstNodes(tokens, root) {
             }
         }
     }
+    if (tokens.find((t) => t.typ == EnumToken.CommaTokenType) != null) {
+        const set = new Set();
+        const split = splitTokenList(tokens, [EnumToken.CommaTokenType]);
+        tokens.length = 0;
+        tokens.push(...split.reduce((acc, curr) => {
+            const str = curr.reduce((acc, curr) => acc + renderToken(curr), "");
+            if (set.has(str)) {
+                return acc;
+            }
+            set.add(str);
+            if (acc.length > 0) {
+                tokens.push({
+                    typ: EnumToken.CommaTokenType,
+                });
+            }
+            return acc.concat(curr);
+        }, []));
+    }
     return result;
 }
 class ComputePrefixFeature {
@@ -70,22 +105,13 @@ class ComputePrefixFeature {
     }
     run(node) {
         if (node.typ == EnumToken.RuleNodeType) {
-            node.sel = replacePseudo(splitRule(node.sel)).reduce((acc, curr, index) => acc + (index > 0 ? ',' : '') + curr.join(''), '');
-            // if ((node as AstRule).raw != null) {
-            //
-            //     (node as AstRule).raw = replacePseudo((node as AstRule).raw as string[][]);
-            // }
-            //
-            // if ((node as AstRule).optimized != null) {
-            //
-            //     (node as AstRule).optimized!.selector = replacePseudo((node as AstRule).optimized!.selector as string[][]);
-            // }
+            node.sel = replacePseudo(splitRule(node.sel)).reduce((acc, curr, index) => acc + (index > 0 ? "," : "") + curr.join(""), "");
             if (node.tokens != null) {
                 replaceAstNodes(node.tokens);
             }
         }
         else if (node.typ == EnumToken.DeclarationNodeType) {
-            if (node.nam.charAt(0) == '-') {
+            if (node.nam.charAt(0) == "-") {
                 const match = node.nam.match(/^-([^-]+)-(.+)$/);
                 if (match != null) {
                     let nam = match[2];
@@ -101,8 +127,10 @@ class ComputePrefixFeature {
             }
             let hasPrefix = false;
             for (const { value } of walkValues(node.val)) {
-                if ((value.typ == EnumToken.IdenTokenType || (value.typ != EnumToken.ParensTokenType && funcLike.includes(value.typ))) && value.val.match(/^-([^-]+)-(.+)$/) != null) {
-                    if (value.val.endsWith('-gradient')) {
+                if ((value.typ == EnumToken.IdenTokenType ||
+                    (value.typ != EnumToken.ParensTokenType && funcLike.includes(value.typ))) &&
+                    value.val.match(/^-([^-]+)-(.+)$/) != null) {
+                    if (value.val.endsWith("-gradient")) {
                         // not supported yet
                         break;
                     }
@@ -113,29 +141,26 @@ class ComputePrefixFeature {
             if (hasPrefix) {
                 const nodes = structuredClone(node.val);
                 for (const { value } of walkValues(nodes)) {
-                    if ((value.typ == EnumToken.IdenTokenType || funcLike.includes(value.typ))) {
+                    if (value.typ == EnumToken.IdenTokenType || funcLike.includes(value.typ)) {
                         const match = value.val.match(/^-([^-]+)-(.+)$/);
                         if (match != null) {
                             value.val = match[2];
                         }
                     }
                 }
-                // @ts-ignore
-                if (SyntaxValidationResult.Valid == evaluateSyntax({ ...node, val: nodes }, {}).valid) {
-                    node.val = nodes;
-                }
+                node.val = nodes;
             }
         }
         else if (node.typ == EnumToken.AtRuleNodeType || node.typ == EnumToken.KeyframesAtRuleNodeType) {
-            if (node.nam.startsWith('-')) {
+            if (node.nam.startsWith("-")) {
                 const match = node.nam.match(/^-([^-]+)-(.+)$/);
-                if (match != null && '@' + match[2] in config.atRules) {
+                if (match != null && "@" + match[2] in config.atRules) {
                     node.nam = match[2];
                 }
             }
-            if (node.typ == EnumToken.AtRuleNodeType && node.val !== '') {
+            if (node.typ == EnumToken.AtRuleNodeType && node.val !== "") {
                 if (replaceAstNodes(node.tokens)) {
-                    node.val = node.tokens.reduce((acc, curr) => acc + renderToken(curr), '');
+                    node.val = node.tokens.reduce((acc, curr) => acc + renderToken(curr), "");
                 }
             }
         }

package/dist/lib/ast/features/shorthand.d.ts

@@ -0,0 +1,12 @@
+import { EnumToken } from "../types.ts";
+import type { AstAtRule, AstNode, AstRule, AstStyleSheet, ParserOptions, PropertyListOptions } from "../../../@types/index.d.ts";
+import { FeatureWalkMode } from "./type.ts";
+export declare class ComputeShorthandFeature {
+    accept: Set<EnumToken>;
+    get ordering(): number;
+    get processMode(): FeatureWalkMode;
+    static register(options: ParserOptions): void;
+    run(ast: AstRule | AstAtRule, options: PropertyListOptions | undefined, parent: AstRule | AstAtRule | AstStyleSheet, context: {
+        [key: string]: any;
+    }): AstNode | null;
+}

package/dist/lib/ast/features/shorthand.js

@@ -1,16 +1,13 @@
 import { PropertyList } from '../../parser/declaration/list.js';
 import { EnumToken } from '../types.js';
-import '../minify.js';
-import '../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 { FeatureWalkMode } from './type.js';
 
 class ComputeShorthandFeature {
-    accept = new Set([EnumToken.RuleNodeType, EnumToken.AtRuleNodeType, EnumToken.KeyFramesRuleNodeType]);
+    accept = new Set([
+        EnumToken.RuleNodeType,
+        EnumToken.AtRuleNodeType,
+        EnumToken.KeyFramesRuleNodeType,
+    ]);
     get ordering() {
         return 3;
     }
@@ -24,7 +21,7 @@ class ComputeShorthandFeature {
         }
     }
     run(ast, options = {}, parent, context) {
-        if (!('chi' in ast)) {
+        if (!("chi" in ast)) {
             return null;
         }
         // @ts-ignore

package/dist/lib/ast/features/transform.d.ts

@@ -0,0 +1,10 @@
+import type { AstAtRule, AstNode, AstRule, ParserOptions } from "../../../@types/index.d.ts";
+import { EnumToken } from "../types.ts";
+import { FeatureWalkMode } from "./type.ts";
+export declare class TransformCssFeature {
+    accept: Set<EnumToken>;
+    get ordering(): number;
+    get processMode(): FeatureWalkMode;
+    static register(options: ParserOptions): void;
+    run(ast: AstRule | AstAtRule): AstNode | null;
+}