@tbela99/css-parser 0.9.1 → 1.1.0

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

@@ -1,10 +1,35 @@
 import { EnumToken } from '../types.js';
 import { walkValues } from '../walk.js';
 import { renderToken } from '../../renderer/render.js';
+import '../../renderer/color/utils/constants.js';
+import { splitRule } from '../minify.js';
+import '../../parser/parse.js';
+import '../../parser/tokenize.js';
+import '../../parser/utils/config.js';
+import { mathFuncs } from '../../syntax/syntax.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)]
+        });
+    }
+    else {
+        result.push(token);
+    }
+    return result;
+}
 function replace(node, variableScope) {
     for (const { value, parent: parentValue } of walkValues(node.val)) {
-        if (value?.typ == EnumToken.FunctionTokenType && value.val == 'var') {
+        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 (info?.replaceable) {
@@ -26,33 +51,35 @@ function replace(node, variableScope) {
     }
 }
 class InlineCssVariablesFeature {
-    static get ordering() {
+    get ordering() {
         return 0;
     }
+    get preProcess() {
+        return true;
+    }
+    get postProcess() {
+        return false;
+    }
     static register(options) {
         if (options.inlineCssVariables) {
-            for (const feature of options.features) {
-                if (feature instanceof InlineCssVariablesFeature) {
-                    return;
-                }
-            }
             // @ts-ignore
             options.features.push(new InlineCssVariablesFeature());
         }
     }
     run(ast, options = {}, parent, context) {
+        if (!('chi' in ast)) {
+            return;
+        }
         if (!('variableScope' in context)) {
             context.variableScope = new Map;
         }
-        const isRoot = parent.typ == EnumToken.StyleSheetNodeType && ast.typ == EnumToken.RuleNodeType && [':root', 'html'].includes(ast.sel);
+        // [':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 variableScope = context.variableScope;
         // @ts-ignore
         for (const node of ast.chi) {
-            if (node.typ == EnumToken.CDOCOMMNodeType || node.typ == EnumToken.CommentNodeType) {
-                continue;
-            }
             if (node.typ != EnumToken.DeclarationNodeType) {
-                break;
+                continue;
             }
             // css variable
             if (node.nam.startsWith('--')) {
@@ -63,13 +90,14 @@ class InlineCssVariablesFeature {
                         parent: new Set(),
                         declarationCount: 1,
                         replaceable: isRoot,
-                        node: node
+                        node: node,
+                        values: structuredClone(node.val)
                     };
                     info.parent.add(ast);
                     variableScope.set(node.nam, info);
                     let recursive = false;
-                    for (const { value, parent: parentValue } of walkValues(node.val)) {
-                        if (value?.typ == EnumToken.FunctionTokenType && value.val == 'var') {
+                    for (const { value } of walkValues(node.val)) {
+                        if (value?.typ == EnumToken.FunctionTokenType && (mathFuncs.includes(value.val) || value.val == 'var')) {
                             recursive = true;
                             break;
                         }
@@ -108,23 +136,13 @@ class InlineCssVariablesFeature {
                 for (const parent of info.parent) {
                     i = parent.chi?.length ?? 0;
                     while (i--) {
-                        if (parent.chi[i].typ == EnumToken.DeclarationNodeType && parent.chi[i].nam == info.node.nam) {
+                        if (parent.chi[i] == info.node) {
                             // @ts-ignore
-                            parent.chi.splice(i++, 1, {
+                            parent.chi.splice(i, 1, {
                                 typ: EnumToken.CommentTokenType,
-                                val: `/* ${info.node.nam}: ${info.node.val.reduce((acc, curr) => acc + renderToken(curr), '')} */`
+                                val: `/* ${info.node.nam}: ${info.values.reduce((acc, curr) => acc + renderToken(curr), '')} */`
                             });
-                        }
-                    }
-                    if (parent.chi?.length == 0 && 'parent' in parent) {
-                        // @ts-ignore
-                        for (i = 0; i < parent.parent.chi?.length; i++) {
-                            // @ts-ignore
-                            if (parent.parent.chi[i] == parent) {
-                                // @ts-ignore
-                                parent.parent.chi.splice(i, 1);
-                                break;
-                            }
+                            break;
                         }
                     }
                 }

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

@@ -1,126 +1,152 @@
-import { EnumToken } from '../types.js';
+import { EnumToken, SyntaxValidationResult } from '../types.js';
 import { getSyntaxConfig } from '../../validation/config.js';
-import { ValidationTokenEnum } from '../../validation/parser/types.js';
+import '../../validation/parser/types.js';
 import '../../validation/parser/parse.js';
-import '../minify.js';
+import { splitRule, definedPropertySettings } from '../minify.js';
 import { walkValues } from '../walk.js';
-import '../../parser/parse.js';
-import '../../renderer/color/utils/constants.js';
-import '../../renderer/sourcemap/lib/encode.js';
+import { parseAtRulePrelude, parseString } from '../../parser/parse.js';
+import '../../parser/tokenize.js';
 import '../../parser/utils/config.js';
+import { pseudoAliasMap } from '../../syntax/syntax.js';
+import { renderToken } from '../../renderer/render.js';
+import { funcLike } from '../../renderer/color/utils/constants.js';
 import '../../validation/syntaxes/complex-selector.js';
+import { evaluateSyntax } from '../../validation/syntax.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) + '()';
+            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;
+    }));
+}
+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 (key in pseudoAliasMap) {
+                const isPseudClass = pseudoAliasMap[key].startsWith('::');
+                value.val = pseudoAliasMap[key];
+                if (value.typ == EnumToken.IdenTokenType &&
+                    ['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',
+                    });
+                }
+                else if (isPseudClass && value.typ == EnumToken.PseudoElementTokenType) {
+                    // @ts-ignore
+                    value.typ = EnumToken.PseudoClassTokenType;
+                }
+                result = true;
+            }
+        }
+    }
+    return result;
+}
 class ComputePrefixFeature {
-    static get ordering() {
+    get ordering() {
         return 2;
     }
+    get preProcess() {
+        return true;
+    }
+    get postProcess() {
+        return false;
+    }
     static register(options) {
         if (options.removePrefix) {
-            for (const feature of options.features) {
-                if (feature instanceof ComputePrefixFeature) {
-                    return;
-                }
-            }
             // @ts-ignore
             options.features.push(new ComputePrefixFeature(options));
         }
     }
-    run(ast) {
-        // @ts-ignore
-        const j = ast.chi.length;
-        let k = 0;
-        // @ts-ignore
-        for (; k < j; k++) {
-            // @ts-ignore
-            const node = ast.chi[k];
-            if (node.typ == EnumToken.DeclarationNodeType) {
-                if (node.nam.charAt(0) == '-') {
-                    const match = node.nam.match(/^-([^-]+)-(.+)$/);
-                    if (match != null) {
-                        const nam = match[2];
-                        if (nam.toLowerCase() in config.declarations) {
-                            node.nam = nam;
+    run(node) {
+        if (node.typ == EnumToken.RuleNodeType) {
+            node.sel = replacePseudo(splitRule(node.sel)).reduce((acc, curr, index) => acc + (index > 0 ? ',' : '') + curr.join(''), '');
+            if (node.raw != null) {
+                node.raw = replacePseudo(node.raw);
+            }
+            if (node.optimized != null) {
+                node.optimized.selector = replacePseudo(node.optimized.selector);
+            }
+            if (node.tokens != null) {
+                replaceAstNodes(node.tokens);
+            }
+        }
+        else if (node.typ == EnumToken.DeclarationNodeType) {
+            if (node.nam.charAt(0) == '-') {
+                const match = node.nam.match(/^-([^-]+)-(.+)$/);
+                if (match != null) {
+                    let nam = match[2];
+                    if (!(nam in config.declarations)) {
+                        if (node.nam in pseudoAliasMap) {
+                            nam = pseudoAliasMap[node.nam];
                         }
                     }
-                }
-                if (node.nam.toLowerCase() in config.declarations) {
-                    for (const { value } of walkValues(node.val)) {
-                        if (value.typ == EnumToken.IdenTokenType && value.val.charAt(0) == '-' && value.val.charAt(1) != '-') {
-                            // @ts-ignore
-                            const values = config.declarations[node.nam].ast.slice();
-                            const match = value.val.match(/^-(.*?)-(.*)$/);
-                            if (match != null) {
-                                const val = matchToken({ ...value, val: match[2] }, values);
-                                if (val != null) {
-                                    // @ts-ignore
-                                    value.val = val.val;
-                                }
-                            }
-                        }
+                    if (nam in config.declarations) {
+                        node.nam = nam;
                     }
                 }
             }
-        }
-        return ast;
-    }
-}
-function matchToken(token, matches) {
-    let result;
-    for (let i = 0; i < matches.length; i++) {
-        switch (matches[i].typ) {
-            case ValidationTokenEnum.Whitespace:
-            case ValidationTokenEnum.Comma:
-                break;
-            case ValidationTokenEnum.Keyword:
-                if (token.typ == EnumToken.IdenTokenType && token.val == matches[i].val) {
-                    return token;
-                }
-                break;
-            case ValidationTokenEnum.PropertyType:
-                if (['ident', 'custom-ident'].includes(matches[i].val)) {
-                    if (token.typ == EnumToken.IdenTokenType && token.val == matches[i].val) {
-                        return token;
+            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')) {
+                        // not supported yet
+                        break;
                     }
+                    hasPrefix = true;
+                    break;
                 }
-                else {
-                    const val = matches[i].val;
-                    if (val in config.declarations || val in config.syntaxes) {
-                        // @ts-ignore
-                        result = matchToken(token, (config.syntaxes[val] ?? config.declarations[val]).ast.slice());
-                        if (result != null) {
-                            return result;
+            }
+            if (hasPrefix) {
+                const nodes = structuredClone(node.val);
+                for (const { value } of walkValues(nodes)) {
+                    if ((value.typ == EnumToken.IdenTokenType || funcLike.includes(value.typ))) {
+                        const match = value.val.match(/^-([^-]+)-(.+)$/);
+                        if (match == null) {
+                            continue;
                         }
+                        value.val = match[2];
                     }
                 }
-                break;
-            case ValidationTokenEnum.PipeToken:
-                for (let j = 0; j < matches[i].chi.length; j++) {
-                    result = matchToken(token, matches[i].chi[j]);
-                    if (result != null) {
-                        return result;
-                    }
+                if (SyntaxValidationResult.Valid == evaluateSyntax({ ...node, val: nodes }, {}).valid) {
+                    node.val = nodes;
                 }
-                break;
-            case ValidationTokenEnum.ColumnToken:
-            case ValidationTokenEnum.AmpersandToken:
-                result = matchToken(token, matches[i].l);
-                if (result == null) {
-                    result = matchToken(token, matches[i].r);
+            }
+        }
+        else if (node.typ == EnumToken.AtRuleNodeType || node.typ == EnumToken.KeyframeAtRuleNodeType) {
+            if (node.nam.startsWith('-')) {
+                const match = node.nam.match(/^-([^-]+)-(.+)$/);
+                if (match != null && '@' + match[2] in config.atRules) {
+                    node.nam = match[2];
                 }
-                if (result != null) {
-                    return result;
+            }
+            if (node.typ == EnumToken.AtRuleNodeType && node.val !== '') {
+                if (node.tokens == null) {
+                    Object.defineProperty(node, 'tokens', {
+                        // @ts-ignore
+                        ...definedPropertySettings,
+                        value: parseAtRulePrelude(parseString(node.val), node),
+                    });
                 }
-                break;
-            case ValidationTokenEnum.Bracket:
-                result = matchToken(token, matches[i].chi);
-                if (result != null) {
-                    return result;
+                if (replaceAstNodes(node.tokens)) {
+                    node.val = node.tokens.reduce((acc, curr) => acc + renderToken(curr), '');
                 }
-                break;
+            }
         }
+        return node;
     }
-    return null;
 }
 
 export { ComputePrefixFeature };

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

@@ -3,42 +3,62 @@ 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 '../../renderer/color/utils/constants.js';
 import '../../renderer/sourcemap/lib/encode.js';
-import '../../parser/utils/config.js';
 
 class ComputeShorthandFeature {
-    static get ordering() {
-        return 2;
+    get ordering() {
+        return 3;
+    }
+    get preProcess() {
+        return false;
+    }
+    get postProcess() {
+        return true;
     }
     static register(options) {
         if (options.computeShorthand) {
-            for (const feature of options.features) {
-                if (feature instanceof ComputeShorthandFeature) {
-                    return;
-                }
-            }
             // @ts-ignore
             options.features.push(new ComputeShorthandFeature(options));
         }
     }
     run(ast, options = {}, parent, context) {
+        if (!('chi' in ast)) {
+            return ast;
+        }
         // @ts-ignore
         const j = ast.chi.length;
         let k = 0;
+        let l;
         let properties = new PropertyList(options);
+        const rules = [];
         // @ts-ignore
         for (; k < j; k++) {
+            l = k;
+            // capture comments with the next token
+            while (l + 1 < j) {
+                // @ts-ignore
+                const node = ast.chi[l];
+                if (node.typ == EnumToken.CommentNodeType) {
+                    l++;
+                    continue;
+                }
+                break;
+            }
             // @ts-ignore
-            const node = ast.chi[k];
-            if (node.typ == EnumToken.CommentNodeType || node.typ == EnumToken.DeclarationNodeType) {
-                properties.add(node);
-                continue;
+            const node = ast.chi[l];
+            if (node.typ == EnumToken.DeclarationNodeType) {
+                properties.add(...ast.chi.slice(k, l + 1));
+            }
+            else {
+                rules.push(...ast.chi.slice(k, l + 1));
             }
-            break;
+            k = l;
         }
         // @ts-ignore
-        ast.chi = [...properties].concat(ast.chi.slice(k));
+        ast.chi = [...properties, ...rules];
         return ast;
     }
 }

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

@@ -0,0 +1,67 @@
+import { EnumToken } from '../types.js';
+import { consumeWhitespace } from '../../validation/utils/whitespace.js';
+import '../minify.js';
+import '../walk.js';
+import '../../parser/parse.js';
+import '../../parser/tokenize.js';
+import '../../parser/utils/config.js';
+import { filterValues, renderToken } from '../../renderer/render.js';
+import '../../renderer/color/utils/constants.js';
+import { compute } from '../transform/compute.js';
+import { eqMatrix } from '../transform/minify.js';
+
+class TransformCssFeature {
+    get ordering() {
+        return 4;
+    }
+    get preProcess() {
+        return false;
+    }
+    get postProcess() {
+        return true;
+    }
+    static register(options) {
+        // @ts-ignore
+        if (options.computeTransform) {
+            // @ts-ignore
+            options.features.push(new TransformCssFeature());
+        }
+    }
+    run(ast) {
+        if (!('chi' in ast)) {
+            return;
+        }
+        let i = 0;
+        let node;
+        // @ts-ignore
+        for (; i < ast.chi.length; i++) {
+            // @ts-ignore
+            node = ast.chi[i];
+            if (node.typ != EnumToken.DeclarationNodeType || !node.nam.match(/^(-[a-z]+-)?transform$/)) {
+                continue;
+            }
+            const children = node.val.slice();
+            consumeWhitespace(children);
+            let { matrix, cumulative, minified } = compute(children) ?? {};
+            if (matrix == null || cumulative == null || minified == null) {
+                continue;
+            }
+            let r = [filterValues(node.val.slice())];
+            if (eqMatrix(matrix, cumulative)) {
+                r.push(cumulative);
+            }
+            if (eqMatrix(matrix, minified)) {
+                r.push(minified);
+            }
+            const l = renderToken(matrix).length;
+            node.val = r.reduce((acc, curr) => {
+                if (curr.reduce((acc, t) => acc + renderToken(t), '').length < l) {
+                    return curr;
+                }
+                return acc;
+            }, [matrix]);
+        }
+    }
+}
+
+export { TransformCssFeature };

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

@@ -0,0 +1,7 @@
+var FeatureWalkMode;
+(function (FeatureWalkMode) {
+    FeatureWalkMode[FeatureWalkMode["Pre"] = 0] = "Pre";
+    FeatureWalkMode[FeatureWalkMode["Post"] = 1] = "Post";
+})(FeatureWalkMode || (FeatureWalkMode = {}));
+
+export { FeatureWalkMode };

package/dist/lib/ast/math/expression.js

@@ -1,6 +1,12 @@
 import { EnumToken } from '../types.js';
 import { rem, compute } from './math.js';
 import { reduceNumber } from '../../renderer/render.js';
+import '../../renderer/color/utils/constants.js';
+import '../minify.js';
+import '../walk.js';
+import '../../parser/parse.js';
+import '../../parser/tokenize.js';
+import '../../parser/utils/config.js';
 import { mathFuncs } from '../../syntax/syntax.js';
 
 /**
@@ -39,14 +45,19 @@ function evaluate(tokens) {
         return tokens;
     }
     if (nodes.length <= 1) {
-        // @ts-ignore
-        if (nodes.length == 1 && nodes[0].typ == EnumToken.IdenTokenType && typeof Math[nodes[0].val.toUpperCase()] == 'number') {
-            return [{
-                    ...nodes[0],
-                    // @ts-ignore
-                    val: '' + Math[nodes[0].val.toUpperCase()],
-                    typ: EnumToken.NumberTokenType
-                }];
+        if (nodes.length == 1) {
+            if (nodes[0].typ == EnumToken.BinaryExpressionTokenType) {
+                return inlineExpression(nodes[0]);
+            }
+            // @ts-ignore
+            if (nodes[0].typ == EnumToken.IdenTokenType && typeof Math[nodes[0].val.toUpperCase()] == 'number') {
+                return [{
+                        ...nodes[0],
+                        // @ts-ignore
+                        val: '' + Math[nodes[0].val.toUpperCase()],
+                        typ: EnumToken.NumberTokenType
+                    }];
+            }
         }
         return nodes;
     }
@@ -167,7 +178,6 @@ function doEvaluate(l, r, op) {
     }
     // @ts-ignore
     const val = compute(v1, v2, op);
-    // typ = typeof val == 'number' ? EnumToken.NumberTokenType : EnumToken.FractionTokenType;
     const token = {
         ...(l.typ == EnumToken.NumberTokenType ? r : l),
         typ,
@@ -513,4 +523,4 @@ function factor(tokens, ops) {
     return tokens;
 }
 
-export { evaluate, evaluateFunc };
+export { buildExpression, evaluate, evaluateFunc, inlineExpression };

package/dist/lib/ast/math/math.js

@@ -1,12 +1,29 @@
 import { EnumToken } from '../types.js';
 import { reduceNumber } from '../../renderer/render.js';
+import '../../renderer/color/utils/constants.js';
+import '../minify.js';
+import '../walk.js';
+import '../../parser/parse.js';
+import '../../parser/tokenize.js';
+import '../../parser/utils/config.js';
 
 function gcd(x, y) {
     x = Math.abs(x);
     y = Math.abs(y);
+    if (x == y) {
+        return x;
+    }
     let t;
-    if (x == 0 || y == 0) {
-        return 1;
+    if (x == 0) {
+        return y;
+    }
+    if (y == 0) {
+        return x;
+    }
+    if (y > x) {
+        t = x;
+        x = y;
+        y = t;
     }
     while (y) {
         t = y;
@@ -76,6 +93,7 @@ function compute(a, b, op) {
             r2 = l1.r.val * r1.l.val;
             break;
     }
+    // @ts-ignore
     const a2 = simplify(l2, r2);
     if (a2[1] == 1) {
         return a2[0];