@tbela99/css-parser 1.4.1 → 1.4.3

package/dist/lib/ast/clone.d.ts

@@ -0,0 +1,10 @@
+import type { AstNode } from "../../@types/index.d.ts";
+import type { Token } from "../../@types/token.d.ts";
+/**
+ *
+ * @param node he nod to clone
+ * @param cloneChildren deep clone
+ * @param cloneMap a map of existing children as keys and their clones as values
+ * @returns
+ */
+export declare function cloneNode(node: AstNode, cloneChildren?: boolean, cloneMap?: Map<Token | AstNode, Token | AstNode> | null): AstNode;

package/dist/lib/ast/clone.js

@@ -0,0 +1,45 @@
+import { EnumToken } from './types.js';
+
+/**
+ *
+ * @param node he nod to clone
+ * @param cloneChildren deep clone
+ * @param cloneMap a map of existing children as keys and their clones as values
+ * @returns
+ */
+function cloneNode(node, cloneChildren = false, cloneMap = null) {
+    const checkNode = node.typ == EnumToken.DeclarationNodeType ? "val" : "chi";
+    const clone = {};
+    const properties = {};
+    cloneMap?.set?.(node, clone);
+    for (const [name, value] of Object.entries(Object.getOwnPropertyDescriptors(node))) {
+        // @ts-expect-error
+        if (value.value == null || typeof value.value != "object" || name == "parent") {
+            // @ts-expect-error
+            properties[name] = { ...value };
+            // @ts-expect-error
+        }
+        else if (Array.isArray(value.value)) {
+            // @ts-expect-error
+            properties[name] = {
+                // @ts-expect-error
+                ...value,
+                value: !cloneChildren && name == checkNode
+                    ? []
+                    : // @ts-expect-error
+                        value.value.map((c) => {
+                            const newObj = cloneNode(c, cloneChildren, cloneMap);
+                            cloneMap?.set?.(c, newObj);
+                            return newObj;
+                        }),
+            };
+        }
+        else {
+            // @ts-expect-error
+            properties[name] = { ...value, value: cloneNode(value.value, clone) };
+        }
+    }
+    return Object.defineProperties(clone, properties);
+}
+
+export { cloneNode };

package/dist/lib/ast/expand.d.ts

@@ -0,0 +1,14 @@
+import type { AstAtRule, AstNode, AstRule, AstStyleSheet } from "../../@types/index.d.ts";
+/**
+ * expand css nesting ast nodes
+ * @param ast
+ *
+ * @private
+ */
+export declare function expand(ast: AstStyleSheet | AstAtRule | AstRule): AstNode;
+/**
+ * replace compound selector
+ * @param input
+ * @param replace
+ */
+export declare function replaceCompound(input: string, replace: string): string;

package/dist/lib/ast/expand.js

@@ -1,12 +1,9 @@
-import { splitRule, combinators } from './minify.js';
+import { splitRule } from './minify.js';
+import { combinators } from '../syntax/constants.js';
 import { parseString } from '../parser/parse.js';
-import '../parser/tokenize.js';
-import '../parser/utils/config.js';
-import { EnumToken } from './types.js';
 import { walkValues } from './walk.js';
 import { renderToken } from '../renderer/render.js';
-import '../renderer/sourcemap/lib/encode.js';
-import '../syntax/color/utils/constants.js';
+import { EnumToken } from './types.js';
 
 /**
  * expand css nesting ast nodes
@@ -18,11 +15,11 @@ function expand(ast) {
     const result = { ...ast, chi: [] };
     for (let i = 0; i < ast.chi.length; i++) {
         const node = ast.chi[i];
-        if (node.typ == EnumToken.RuleNodeType) {
+        if (node.typ === EnumToken.RuleNodeType) {
             // @ts-ignore
             result.chi.push(...expandRule(node));
         }
-        else if (node.typ == EnumToken.AtRuleNodeType && 'chi' in node) {
+        else if (node.typ == EnumToken.AtRuleNodeType && "chi" in node) {
             let hasRule = false;
             let j = node.chi.length;
             while (j--) {
@@ -50,20 +47,23 @@ function expandRule(node) {
         for (; i < ast.chi.length; i++) {
             if (ast.chi[i].typ == EnumToken.RuleNodeType) {
                 const rule = ast.chi[i];
-                if (!rule.sel.includes('&')) {
+                if (!rule.sel.includes("&")) {
                     const selRule = splitRule(rule.sel);
-                    const arSelf = splitRule(ast.sel).filter((r) => r.every((t) => t != ':before' && t != ':after' && !t.startsWith('::'))).reduce((acc, curr) => acc.concat([curr.join('')]), []).join(',');
+                    const arSelf = splitRule(ast.sel)
+                        .filter((r) => r.every((t) => t != ":before" && t != ":after" && !t.startsWith("::")))
+                        .reduce((acc, curr) => acc.concat([curr.join("")]), [])
+                        .join(",");
                     if (arSelf.length == 0) {
                         ast.chi.splice(i--, 1);
                         continue;
                     }
-                    //
-                    selRule.forEach(arr => combinators.includes(arr[0].charAt(0)) ? arr.unshift(arSelf) : arr.unshift(arSelf, ' '));
-                    rule.sel = selRule.reduce((acc, curr) => {
-                        acc.push(curr.join(''));
+                    selRule.forEach((arr) => combinators.includes(arr[0].charAt(0)) ? arr.unshift(arSelf) : arr.unshift(arSelf, " "));
+                    rule.sel = selRule
+                        .reduce((acc, curr) => {
+                        acc.push(curr.join(""));
                         return acc;
-                    }, []).join(',');
-                    // }
+                    }, [])
+                        .join(",");
                 }
                 else {
                     let childSelectorCompound = [];
@@ -71,22 +71,22 @@ function expandRule(node) {
                     let withoutCompound = [];
                     // pseudo elements cannot be used with '&'
                     // https://www.w3.org/TR/css-nesting-1/#example-7145ff1e
-                    const rules = splitRule(ast.sel).filter((r) => r.every((t) => t != ':before' && t != ':after' && !t.startsWith('::')));
-                    const parentSelector = !node.sel.includes('&');
+                    const rules = splitRule(ast.sel).filter((r) => r.every((t) => t != ":before" && t != ":after" && !t.startsWith("::")));
+                    const parentSelector = !node.sel.includes("&");
                     if (rules.length == 0) {
                         ast.chi.splice(i--, 1);
                         continue;
                     }
-                    for (const sel of (rule.raw ?? splitRule(rule.sel))) {
-                        const s = sel.join('');
-                        if (s.includes('&') || parentSelector) {
-                            if (s.indexOf('&', 1) == -1) {
-                                if (s.at(0) == '&') {
-                                    if (s.at(1) == ' ') {
+                    for (const sel of rule.raw ?? splitRule(rule.sel)) {
+                        const s = sel.join("");
+                        if (s.includes("&") || parentSelector) {
+                            if (s.indexOf("&", 1) == -1) {
+                                if (s.at(0) == "&") {
+                                    if (s.at(1) == " ") {
                                         childSelectorCompound.push(s.slice(2));
                                     }
                                     else {
-                                        if (s == '&' || parentSelector) {
+                                        if (s == "&" || parentSelector) {
                                             withCompound.push(s);
                                         }
                                     }
@@ -101,29 +101,48 @@ function expandRule(node) {
                         }
                     }
                     const selectors = [];
-                    const selector = rules.length > 1 ? ':is(' + rules.map(a => a.join('')).join(',') + ')' : rules[0].join('');
+                    const selector = rules.length > 1 ? ":is(" + rules.map((a) => a.join("")).join(",") + ")" : rules[0].join("");
                     if (childSelectorCompound.length > 0) {
                         if (childSelectorCompound.length == 1) {
-                            selectors.push(replaceCompound('& ' + childSelectorCompound[0].trim(), selector));
+                            selectors.push(replaceCompound("& " + childSelectorCompound[0].trim(), selector));
                         }
                         else {
-                            selectors.push(replaceCompound('& :is(' + childSelectorCompound.reduce((acc, curr) => acc + (acc.length > 0 ? ',' : '') + curr.trim(), '') + ')', selector));
+                            selectors.push(replaceCompound("& :is(" +
+                                childSelectorCompound.reduce((acc, curr) => acc + (acc.length > 0 ? "," : "") + curr.trim(), "") +
+                                ")", selector));
                         }
                     }
                     if (withCompound.length > 0) {
-                        if (withCompound.every((t) => t[0] == '&' && t.indexOf('&', 1) == -1)) {
-                            withoutCompound.push(...withCompound.map(t => t.slice(1)));
+                        if (withCompound.every((t) => t[0] == "&" && t.indexOf("&", 1) == -1)) {
+                            withoutCompound.push(...withCompound.map((t) => t.slice(1)));
                             withCompound.length = 0;
                         }
                     }
                     if (withoutCompound.length > 0) {
                         if (withoutCompound.length == 1) {
-                            const useIs = rules.length == 1 && selector.match(/^[a-zA-Z.:]/) != null && selector.includes(' ') && withoutCompound.length == 1 && withoutCompound[0].match(/^[a-zA-Z]+$/) != null;
-                            const compound = useIs ? ':is(&)' : '&';
-                            selectors.push(replaceCompound(rules.length == 1 ? (useIs ? withoutCompound[0] + ':is(&)' : (selector.match(/^[.:]/) && withoutCompound[0].match(/^[a-zA-Z]+$/) ? withoutCompound[0] + compound : compound + withoutCompound[0])) : (withoutCompound[0].match(/^[a-zA-Z:]+$/) ? withoutCompound[0].trim() + compound : '&' + (withoutCompound[0].match(/^\S+$/) ? withoutCompound[0].trim() : ':is(' + withoutCompound[0].trim() + ')')), selector));
+                            const useIs = rules.length == 1 &&
+                                selector.match(/^[a-zA-Z.:]/) != null &&
+                                selector.includes(" ") &&
+                                withoutCompound.length == 1 &&
+                                withoutCompound[0].match(/^[a-zA-Z]+$/) != null;
+                            const compound = useIs ? ":is(&)" : "&";
+                            selectors.push(replaceCompound(rules.length == 1
+                                ? useIs
+                                    ? withoutCompound[0] + ":is(&)"
+                                    : selector.match(/^[.:]/) && withoutCompound[0].match(/^[a-zA-Z]+$/)
+                                        ? withoutCompound[0] + compound
+                                        : compound + withoutCompound[0]
+                                : withoutCompound[0].match(/^[a-zA-Z:]+$/)
+                                    ? withoutCompound[0].trim() + compound
+                                    : "&" +
+                                        (withoutCompound[0].match(/^\S+$/)
+                                            ? withoutCompound[0].trim()
+                                            : ":is(" + withoutCompound[0].trim() + ")"), selector));
                         }
                         else {
-                            selectors.push(replaceCompound('&:is(' + withoutCompound.reduce((acc, curr) => acc + (acc.length > 0 ? ',' : '') + curr.trim(), '') + ')', selector));
+                            selectors.push(replaceCompound("&:is(" +
+                                withoutCompound.reduce((acc, curr) => acc + (acc.length > 0 ? "," : "") + curr.trim(), "") +
+                                ")", selector));
                         }
                     }
                     if (withCompound.length > 0) {
@@ -131,7 +150,7 @@ function expandRule(node) {
                             selectors.push(replaceCompound(withCompound[0], selector));
                         }
                     }
-                    rule.sel = selectors.reduce((acc, curr) => curr.length == 0 ? acc : acc + (acc.length > 0 ? ',' : '') + curr, '');
+                    rule.sel = selectors.reduce((acc, curr) => (curr.length == 0 ? acc : acc + (acc.length > 0 ? "," : "") + curr), "");
                 }
                 ast.chi.splice(i--, 1);
                 result.push(...expandRule(rule));
@@ -139,11 +158,13 @@ function expandRule(node) {
             else if (ast.chi[i].typ == EnumToken.AtRuleNodeType) {
                 let astAtRule = ast.chi[i];
                 const values = [];
-                if (astAtRule.nam == 'scope') {
-                    if (astAtRule.val.includes('&')) {
+                if (astAtRule.nam === "scope") {
+                    if (astAtRule.val.includes("&")) {
                         astAtRule.val = replaceCompound(astAtRule.val, ast.sel);
                     }
-                    const slice = astAtRule.chi.slice().filter(t => t.typ == EnumToken.RuleNodeType && t.sel.includes('&'));
+                    const slice = astAtRule.chi
+                        .slice()
+                        .filter((t) => t.typ == EnumToken.RuleNodeType && t.sel.includes("&"));
                     if (slice.length > 0) {
                         expandRule({ ...node, chi: astAtRule.chi.slice() });
                     }
@@ -154,13 +175,13 @@ function expandRule(node) {
                     // @ts-ignore
                     astAtRule.chi.length = 0;
                     for (const r of expandRule(clone)) {
-                        if (r.typ == EnumToken.AtRuleNodeType && 'chi' in r) {
-                            if (astAtRule.val !== '' && r.val !== '') {
-                                if (astAtRule.nam == 'media' && r.nam == 'media') {
-                                    r.val = astAtRule.val + ' and ' + r.val;
+                        if (r.typ == EnumToken.AtRuleNodeType && "chi" in r) {
+                            if (astAtRule.val !== "" && r.val !== "") {
+                                if (astAtRule.nam === "media" && r.nam === "media") {
+                                    r.val = astAtRule.val + " and " + r.val;
                                 }
-                                else if (astAtRule.nam == 'layer' && r.nam == 'layer') {
-                                    r.val = astAtRule.val + '.' + r.val;
+                                else if (astAtRule.nam == "layer" && r.nam == "layer") {
+                                    r.val = astAtRule.val + "." + r.val;
                                 }
                             }
                             // @ts-ignore
@@ -190,38 +211,42 @@ function replaceCompound(input, replace) {
     const tokens = parseString(input);
     let replacement = null;
     for (const t of walkValues(tokens)) {
-        if (t.value.typ == EnumToken.LiteralTokenType) {
-            if (t.value.val == '&') {
-                if (tokens.length == 2) {
-                    if (replacement == null) {
-                        replacement = parseString(replace);
-                    }
-                    t.value.val = replaceCompoundLiteral(t.value.val, replace);
-                    // }
-                    continue;
+        if (t.value.typ == EnumToken.NestingSelectorTokenType) {
+            if (tokens.length == 2) {
+                if (replacement == null) {
+                    replacement = parseString(replace);
                 }
-                const rule = splitRule(replace);
-                t.value.val = rule.length > 1 ? ':is(' + replace + ')' : replace;
+                Object.assign(t.value, {
+                    typ: EnumToken.LiteralTokenType,
+                    val: replaceCompoundLiteral(t.value.val, replace),
+                });
+                continue;
             }
+            const rule = splitRule(replace);
+            Object.assign(t.value, {
+                typ: EnumToken.LiteralTokenType,
+                val: rule.length > 1 ? ":is(" + replace + ")" : replace,
+            });
         }
     }
-    return tokens.reduce((acc, curr) => acc + renderToken(curr), '');
+    return tokens.reduce((acc, curr) => acc + renderToken(curr), "");
 }
 function replaceCompoundLiteral(selector, replace) {
-    const tokens = [''];
+    const tokens = [""];
     let i = 0;
     for (; i < selector.length; i++) {
-        if (selector.charAt(i) == '&') {
-            tokens.push('&');
-            tokens.push('');
+        if (selector.charAt(i) == "&") {
+            tokens.push("&", "");
         }
     }
-    return tokens.sort((a, b) => {
-        if (a == '&') {
+    return tokens
+        .sort((a, b) => {
+        if (a == "&") {
             return 1;
         }
-        return b == '&' ? -1 : 0;
-    }).reduce((acc, curr) => acc + (curr == '&' ? replace : curr), '');
+        return b == "&" ? -1 : 0;
+    })
+        .reduce((acc, curr) => acc + (curr == "&" ? replace : curr), "");
 }
 
 export { expand, replaceCompound };

package/dist/lib/ast/features/calc.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 ComputeCalcExpressionFeature {
+    accept: Set<EnumToken>;
+    get ordering(): number;
+    get processMode(): FeatureWalkMode;
+    static register(options: ParserOptions): void;
+    run(ast: AstRule | AstAtRule): AstNode | null;
+}

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

@@ -2,13 +2,8 @@ import { EnumToken } from '../types.js';
 import { walkValues, WalkerEvent, WalkerOptionEnum } from '../walk.js';
 import { evaluate } from '../math/expression.js';
 import { renderToken } from '../../renderer/render.js';
-import '../../renderer/sourcemap/lib/encode.js';
-import { mathFuncs } from '../../syntax/syntax.js';
-import '../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';
 
 class ComputeCalcExpressionFeature {
     accept = new Set([EnumToken.RuleNodeType, EnumToken.AtRuleNodeType]);
@@ -25,14 +20,14 @@ class ComputeCalcExpressionFeature {
         }
     }
     run(ast) {
-        if (!('chi' in ast)) {
+        if (!("chi" in ast)) {
             return null;
         }
         for (const node of ast.chi) {
             if (node.typ != EnumToken.DeclarationNodeType) {
                 continue;
             }
-            const set = new Set;
+            const set = new Set();
             for (const { value, parent } of walkValues(node.val, node, {
                 event: WalkerEvent.Enter,
                 // @ts-ignore
@@ -42,20 +37,36 @@ class ComputeCalcExpressionFeature {
                         parent.typ == EnumToken.DeclarationNodeType &&
                         // @ts-ignore
                         parent.val.length == 1 &&
-                        node.typ == EnumToken.FunctionTokenType &&
+                        (node.typ === EnumToken.MathFunctionTokenType || node.typ === EnumToken.FunctionTokenType) &&
                         mathFuncs.includes(node.val) &&
                         node.chi.length == 1 &&
                         node.chi[0].typ == EnumToken.IdenTokenType) {
                         return WalkerOptionEnum.Ignore;
                     }
-                    if ((node.typ == EnumToken.FunctionTokenType && node.val == 'var') || (!mathFuncs.includes(parent.val) && [EnumToken.ColorTokenType, EnumToken.DeclarationNodeType, EnumToken.RuleNodeType, EnumToken.AtRuleNodeType, EnumToken.StyleSheetNodeType].includes(parent?.typ))) {
+                    if ((node.typ === EnumToken.WildCardFunctionTokenType && node.val == "var") ||
+                        (!mathFuncs.includes(parent.val) &&
+                            [
+                                EnumToken.MathFunctionTokenType,
+                                EnumToken.ColorTokenType,
+                                EnumToken.DeclarationNodeType,
+                                EnumToken.RuleNodeType,
+                                EnumToken.AtRuleNodeType,
+                                EnumToken.StyleSheetNodeType,
+                            ].includes(parent?.typ))) {
                         return null;
                     }
                     // @ts-ignore
-                    const slice = (node.typ == EnumToken.FunctionTokenType ? node.chi : (node.typ == EnumToken.DeclarationNodeType ? node.val : node.chi))?.slice();
-                    if (slice != null && node.typ == EnumToken.FunctionTokenType && mathFuncs.includes(node.val)) {
+                    const slice = (node.typ == EnumToken.FunctionTokenType || node.typ == EnumToken.MathFunctionTokenType
+                        ? node.chi
+                        : node.typ == EnumToken.DeclarationNodeType
+                            ? node.val
+                            : node.chi)?.slice();
+                    if (slice != null &&
+                        (node.typ === EnumToken.MathFunctionTokenType ||
+                            (node.typ == EnumToken.FunctionTokenType &&
+                                mathFuncs.includes(node.val)))) {
                         // @ts-ignore
-                        const key = 'chi' in node ? 'chi' : 'val';
+                        const key = "chi" in node ? "chi" : "val";
                         const str1 = renderToken({ ...node, [key]: slice });
                         const str2 = renderToken(node); // values.reduce((acc: string, curr: Token): string => acc + renderToken(curr), '');
                         if (str1.length <= str2.length) {
@@ -65,25 +76,52 @@ class ComputeCalcExpressionFeature {
                         return WalkerOptionEnum.Ignore;
                     }
                     return null;
-                }
+                },
             })) {
-                if (value != null && value.typ == EnumToken.FunctionTokenType && mathFuncs.includes(value.val)) {
+                if (value != null &&
+                    (value.typ === EnumToken.MathFunctionTokenType ||
+                        (value.typ == EnumToken.FunctionTokenType && mathFuncs.includes(value.val)))) {
                     if (!set.has(value)) {
                         set.add(value);
                         if (parent != null) {
                             // @ts-ignore
-                            const cp = value.typ == EnumToken.FunctionTokenType && mathFuncs.includes(value.val) && value.val != 'calc' ? [value] : (value.typ == EnumToken.DeclarationNodeType ? value.val : value.chi);
+                            const cp = (value.typ === EnumToken.MathFunctionTokenType ||
+                                (value.typ == EnumToken.FunctionTokenType &&
+                                    mathFuncs.includes(value.val))) &&
+                                value.val != "calc"
+                                ? [value]
+                                : value.typ == EnumToken.DeclarationNodeType
+                                    ? value.val
+                                    : value.chi;
                             const values = evaluate(cp);
+                            // fix a + -b to a - b
+                            for (const { value } of walkValues(values)) {
+                                if (value.typ === EnumToken.BinaryExpressionTokenType &&
+                                    value.op === EnumToken.Add &&
+                                    Math.sign(value.r.val) == -1) {
+                                    value.op = EnumToken.Sub;
+                                    // @ts-expect-error
+                                    value.r.val *= -1;
+                                }
+                            }
                             // @ts-ignore
                             const children = parent.typ == EnumToken.DeclarationNodeType ? parent.val : parent.chi;
                             if (values.length == 1 && values[0].typ != EnumToken.BinaryExpressionTokenType) {
                                 for (let i = 0; i < children.length; i++) {
                                     if (children[i] == value) {
-                                        children.splice(i, 1, !(parent.typ == EnumToken.FunctionTokenType && parent.val == 'calc') && (typeof values[0].val != 'number' && !(values[0].typ == EnumToken.FunctionTokenType && mathFuncs.includes(values[0].val))) ? {
-                                            typ: EnumToken.FunctionTokenType,
-                                            val: 'calc',
-                                            chi: values
-                                        } : values[0]);
+                                        children.splice(i, 1, !(parent.typ === EnumToken.MathFunctionTokenType ||
+                                            (parent.typ == EnumToken.FunctionTokenType &&
+                                                parent.val == "calc")) &&
+                                            typeof values[0].val != "number" &&
+                                            !(values[0].typ == EnumToken.MathFunctionTokenType ||
+                                                (values[0].typ == EnumToken.FunctionTokenType &&
+                                                    mathFuncs.includes(values[0].val)))
+                                            ? {
+                                                typ: EnumToken.MathFunctionTokenType,
+                                                val: "calc",
+                                                chi: values,
+                                            }
+                                            : values[0]);
                                         break;
                                     }
                                 }
@@ -92,9 +130,9 @@ class ComputeCalcExpressionFeature {
                                 for (let i = 0; i < children.length; i++) {
                                     if (children[i] == value) {
                                         children.splice(i, 1, {
-                                            typ: EnumToken.FunctionTokenType,
-                                            val: 'calc',
-                                            chi: values
+                                            typ: EnumToken.MathFunctionTokenType,
+                                            val: "calc",
+                                            chi: values,
                                         });
                                         break;
                                     }

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

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