@tbela99/css-parser 1.3.3 → 1.3.4

package/dist/lib/ast/expand.js

@@ -16,14 +16,11 @@ import '../syntax/color/utils/constants.js';
  */
 function expand(ast) {
     const result = { ...ast, chi: [] };
-    // @ts-ignore
     for (let i = 0; i < ast.chi.length; i++) {
-        // @ts-ignore
         const node = ast.chi[i];
         if (node.typ == EnumToken.RuleNodeType) {
             // @ts-ignore
             result.chi.push(...expandRule(node));
-            // i += expanded.length - 1;
         }
         else if (node.typ == EnumToken.AtRuleNodeType && 'chi' in node) {
             let hasRule = false;
@@ -38,6 +35,10 @@ function expand(ast) {
             // @ts-ignore
             result.chi.push({ ...(hasRule ? expand(node) : node) });
         }
+        else {
+            // @ts-ignore
+            result.chi.push(node);
+        }
     }
     return result;
 }
@@ -220,13 +221,7 @@ function replaceCompoundLiteral(selector, replace) {
             return 1;
         }
         return b == '&' ? -1 : 0;
-    }).reduce((acc, curr) => {
-        // if (acc.length > 0 && curr == '&' && (replace.charAt(0) != '.' || replace.includes(' '))) {
-        //
-        //     return acc + ':is(' + replace + ')';
-        // }
-        return acc + (curr == '&' ? replace : curr);
-    }, '');
+    }).reduce((acc, curr) => acc + (curr == '&' ? replace : curr), '');
 }
 
 export { expand, replaceCompound };

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

@@ -1,5 +1,5 @@
 import { EnumToken } from '../types.js';
-import { walkValues, WalkerValueEvent, WalkerOptionEnum } from '../walk.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';
@@ -11,6 +11,7 @@ import '../../parser/utils/config.js';
 import { FeatureWalkMode } from './type.js';
 
 class ComputeCalcExpressionFeature {
+    accept = new Set([EnumToken.RuleNodeType, EnumToken.AtRuleNodeType]);
     get ordering() {
         return 1;
     }
@@ -33,7 +34,7 @@ class ComputeCalcExpressionFeature {
             }
             const set = new Set;
             for (const { value, parent } of walkValues(node.val, node, {
-                event: WalkerValueEvent.Enter,
+                event: WalkerEvent.Enter,
                 // @ts-ignore
                 fn(node, parent) {
                     if (parent != null &&

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

@@ -52,6 +52,7 @@ function replace(node, variableScope) {
     }
 }
 class InlineCssVariablesFeature {
+    accept = new Set([EnumToken.RuleNodeType, EnumToken.AtRuleNodeType]);
     get ordering() {
         return 0;
     }
@@ -65,9 +66,10 @@ class InlineCssVariablesFeature {
         }
     }
     run(ast, options = {}, parent, context) {
-        if (!('chi' in ast)) {
-            return null;
-        }
+        // if (!('chi' in ast)) {
+        //
+        //     return null;
+        // }
         if (!('variableScope' in context)) {
             context.variableScope = new Map;
         }

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

@@ -1,6 +1,5 @@
 import { EnumToken, SyntaxValidationResult } from '../types.js';
 import { getSyntaxConfig } from '../../validation/config.js';
-import '../../validation/parser/types.js';
 import '../../validation/parser/parse.js';
 import { splitRule } from '../minify.js';
 import { walkValues } from '../walk.js';
@@ -121,6 +120,7 @@ class ComputePrefixFeature {
                         }
                     }
                 }
+                // @ts-ignore
                 if (SyntaxValidationResult.Valid == evaluateSyntax({ ...node, val: nodes }, {}).valid) {
                     node.val = nodes;
                 }

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

@@ -10,6 +10,7 @@ import '../../renderer/sourcemap/lib/encode.js';
 import { FeatureWalkMode } from './type.js';
 
 class ComputeShorthandFeature {
+    accept = new Set([EnumToken.RuleNodeType, EnumToken.AtRuleNodeType, EnumToken.KeyFramesRuleNodeType]);
     get ordering() {
         return 3;
     }

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

@@ -9,10 +9,11 @@ import '../../syntax/color/utils/constants.js';
 import { filterValues, renderToken } from '../../renderer/render.js';
 import '../../renderer/sourcemap/lib/encode.js';
 import { compute } from '../transform/compute.js';
-import { eqMatrix } from '../transform/minify.js';
+import { minifyTransformFunctions, eqMatrix } from '../transform/minify.js';
 import { FeatureWalkMode } from './type.js';
 
 class TransformCssFeature {
+    accept = new Set([EnumToken.RuleNodeType, EnumToken.KeyFramesRuleNodeType]);
     get ordering() {
         return 4;
     }
@@ -39,28 +40,21 @@ class TransformCssFeature {
             if (node.typ != EnumToken.DeclarationNodeType || !node.nam.match(/^(-[a-z]+-)?transform$/)) {
                 continue;
             }
-            const children = node.val.reduce((acc, curr) => {
-                if (curr.typ == EnumToken.FunctionTokenType && 'skew' == curr.val.toLowerCase()) {
-                    if (curr.chi.length == 3) {
-                        if (curr.chi[2].val == 0) {
-                            curr.chi.length = 1;
-                            curr.val = 'skew';
-                        }
-                        else if (curr.chi[0].val == 0) {
-                            curr.chi = [curr.chi[2]];
-                            curr.val = 'skewY';
-                        }
-                    }
-                }
-                acc.push(curr);
-                return acc;
-            }, []);
+            const children = [];
+            for (const child of node.val) {
+                children.push(child.typ == EnumToken.FunctionTokenType ? minifyTransformFunctions(child) : child);
+            }
             consumeWhitespace(children);
-            let { matrix, cumulative, minified } = compute(children) ?? {};
+            let { matrix, cumulative, minified } = compute(children) ?? {
+                matrix: null,
+                cumulative: null,
+                minified: null
+            };
             if (matrix == null || cumulative == null || minified == null) {
+                node.val = children;
                 continue;
             }
-            let r = [filterValues(node.val.slice())];
+            let r = [filterValues(children)];
             if (eqMatrix(matrix, cumulative)) {
                 r.push(cumulative);
             }

package/dist/lib/ast/minify.js

@@ -61,7 +61,7 @@ function minify(ast, options = {}, recursive = false, errors, nestingContent, co
             }
             replacement = parent;
             for (const feature of options.features) {
-                if ((feature.processMode & FeatureWalkMode.Pre) === 0) {
+                if ((feature.processMode & FeatureWalkMode.Pre) === 0 || (feature.accept != null && !feature.accept.has(parent.typ))) {
                     continue;
                 }
                 const result = feature.run(replacement, options, parent.parent ?? ast, context, FeatureWalkMode.Pre);
@@ -100,7 +100,7 @@ function minify(ast, options = {}, recursive = false, errors, nestingContent, co
         replacement = parent;
         if (postprocess) {
             for (const feature of options.features) {
-                if ((feature.processMode & FeatureWalkMode.Post) === 0) {
+                if ((feature.processMode & FeatureWalkMode.Post) === 0 || (feature.accept != null && !feature.accept.has(parent.typ))) {
                     continue;
                 }
                 const result = feature.run(replacement, options, parent.parent ?? ast, context, FeatureWalkMode.Post);
@@ -231,6 +231,7 @@ function doMinify(ast, options = {}, recursive = false, errors, nestingContent,
                     continue;
                 }
                 if (previous?.typ == EnumToken.AtRuleNodeType &&
+                    node.nam != 'font-face' &&
                     previous.nam == node.nam &&
                     previous.val == node.val) {
                     if ('chi' in node) {
@@ -379,7 +380,9 @@ function doMinify(ast, options = {}, recursive = false, errors, nestingContent,
                             break;
                         }
                         if (shouldMerge) {
+                            // @ts-ignore
                             if (((node.typ == EnumToken.RuleNodeType || node.typ == EnumToken.KeyFramesRuleNodeType) && node.sel == previous.sel) ||
+                                // @ts-ignore
                                 (node.typ == EnumToken.AtRuleNodeType) && node.val != 'font-face' && node.val == previous.val) {
                                 // @ts-ignore
                                 node.chi.unshift(...previous.chi);

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

@@ -46,8 +46,6 @@ function compute(transformLists) {
             });
         }
     }
-    // console.error({matrix});
-    // matrix = toZero(matrix) as Matrix;
     return {
         matrix: serialize(toZero(matrix)),
         cumulative,
@@ -71,7 +69,7 @@ function computeMatrix(transformList, matrixVar) {
                 {
                     values.length = 0;
                     const children = stripCommaToken(transformList[i].chi.slice());
-                    const valCount = transformList[i].val == 'translate3d' || transformList[i].val == 'translate' ? 3 : 1;
+                    const valCount = transformList[i].val == 'translate3d' ? 3 : transformList[i].val == 'translate' ? 2 : 1;
                     for (let j = 0; j < children.length; j++) {
                         if (children[j].typ == EnumToken.WhitespaceTokenType) {
                             continue;
@@ -158,7 +156,7 @@ function computeMatrix(transformList, matrixVar) {
                     const children = stripCommaToken(transformList[i].chi.slice());
                     for (let k = 0; k < children.length; k++) {
                         child = children[k];
-                        if (child.typ != EnumToken.NumberTokenType) {
+                        if (child.typ != EnumToken.NumberTokenType && child.typ != EnumToken.PercentageTokenType) {
                             return null;
                         }
                         values.push(getNumber(child));

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

@@ -30,27 +30,27 @@ function parseMatrix(mat) {
 function matrix(values) {
     const matrix = identity();
     if (values.length === 6) {
-        matrix[0 * 4 + 0] = values[0];
-        matrix[0 * 4 + 1] = values[1];
-        matrix[1 * 4 + 0] = values[2];
-        matrix[1 * 4 + 1] = values[3];
-        matrix[3 * 4 + 0] = values[4];
+        matrix[0] = values[0];
+        matrix[1] = values[1];
+        matrix[4] = values[2];
+        matrix[4 + 1] = values[3];
+        matrix[3 * 4] = values[4];
         matrix[3 * 4 + 1] = values[5];
     }
     else if (values.length === 16) {
-        matrix[0 * 4 + 0] = values[0];
-        matrix[0 * 4 + 1] = values[1];
-        matrix[0 * 4 + 2] = values[2];
-        matrix[0 * 4 + 3] = values[3];
-        matrix[1 * 4 + 0] = values[4];
-        matrix[1 * 4 + 1] = values[5];
-        matrix[1 * 4 + 2] = values[6];
-        matrix[1 * 4 + 3] = values[7];
-        matrix[2 * 4 + 0] = values[8];
+        matrix[0] = values[0];
+        matrix[1] = values[1];
+        matrix[2] = values[2];
+        matrix[3] = values[3];
+        matrix[4] = values[4];
+        matrix[4 + 1] = values[5];
+        matrix[4 + 2] = values[6];
+        matrix[4 + 3] = values[7];
+        matrix[2 * 4] = values[8];
         matrix[2 * 4 + 1] = values[9];
         matrix[2 * 4 + 2] = values[10];
         matrix[2 * 4 + 3] = values[11];
-        matrix[3 * 4 + 0] = values[12];
+        matrix[3 * 4] = values[12];
         matrix[3 * 4 + 1] = values[13];
         matrix[3 * 4 + 2] = values[14];
         matrix[3 * 4 + 3] = values[15];
@@ -75,11 +75,11 @@ function serialize(matrix) {
             typ: EnumToken.FunctionTokenType,
             val: 'matrix',
             chi: [
-                matrix[0 * 4 + 0],
-                matrix[0 * 4 + 1],
-                matrix[1 * 4 + 0],
-                matrix[1 * 4 + 1],
-                matrix[3 * 4 + 0],
+                matrix[0],
+                matrix[1],
+                matrix[4],
+                matrix[4 + 1],
+                matrix[3 * 4],
                 matrix[3 * 4 + 1]
             ].reduce((acc, t) => {
                 if (acc.length > 0) {

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

@@ -156,10 +156,6 @@ function minify(matrix) {
         }
     }
     if (transforms.has('skew')) {
-        // if (round(decomposed.skew[0]) == 0) {
-        //
-        //     skew.delete('x');
-        // }
         if (round(decomposed.skew[1]) == 0) {
             skew.delete('y');
         }
@@ -199,7 +195,7 @@ function minify(matrix) {
             scales.delete('x');
         }
         if (scales.size == 1) {
-            let prefix = scales.has('x') ? '' : scales.has('y') ? 'Y' : 'Z';
+            let prefix = scales.has('x') ? 'X' : scales.has('y') ? 'Y' : 'Z';
             result.push({
                 typ: EnumToken.FunctionTokenType,
                 val: 'scale' + prefix,
@@ -242,13 +238,9 @@ function minify(matrix) {
     ] : result;
 }
 function eqMatrix(a, b) {
-    // console.error(JSON.stringify({a, b}, null, 1));
     let mat = identity();
     let tmp = identity();
-    // @ts-ignore
     const data = (Array.isArray(a) ? a : parseMatrix(a));
-    // toZero(data);
-    // console.error({data});
     for (const transform of b) {
         tmp = computeMatrix([transform], identity());
         if (tmp == null) {
@@ -256,8 +248,6 @@ function eqMatrix(a, b) {
         }
         mat = multiply(mat, tmp);
     }
-    // toZero(mat);
-    // console.error({mat});
     if (mat == null) {
         return false;
     }
@@ -270,5 +260,108 @@ function eqMatrix(a, b) {
     }
     return true;
 }
+function minifyTransformFunctions(transform) {
+    const name = transform.val.toLowerCase();
+    if ('skewx' == name) {
+        transform.val = 'skew';
+        return transform;
+    }
+    if (!['translate', 'translate3d', 'scale', 'scale3d'].includes(name)) {
+        return transform;
+    }
+    const values = [];
+    for (const token of transform.chi) {
+        if (token.typ == EnumToken.CommentTokenType || token.typ == EnumToken.WhitespaceTokenType || token.typ == EnumToken.CommaTokenType) {
+            continue;
+        }
+        if (![EnumToken.NumberTokenType, EnumToken.LengthTokenType, EnumToken.AngleTokenType, EnumToken.PercentageTokenType].includes(token.typ)) {
+            return transform;
+        }
+        if (token.typ == EnumToken.PercentageTokenType && typeof token.val == 'number' && name.startsWith('scale')) {
+            Object.assign(token, { typ: EnumToken.NumberTokenType, val: token.val / 100 });
+        }
+        values.push(token);
+    }
+    if ((name == 'translate' || name == 'scale') && values.length > 2) {
+        return transform;
+    }
+    const ignoredValue = name.startsWith('scale') ? 1 : 0;
+    const t = new Set(['x', 'y', 'z']);
+    let i = 3;
+    while (i--) {
+        if (values.length <= i || values[i].val == ignoredValue) {
+            t.delete(i == 0 ? 'x' : i == 1 ? 'y' : 'z');
+        }
+    }
+    if (name == 'translate3d' || name == 'translate') {
+        if (t.size == 0) {
+            return {
+                typ: EnumToken.FunctionTokenType,
+                val: 'translate',
+                chi: [
+                    { typ: EnumToken.NumberTokenType, val: 0 }
+                ]
+            };
+        }
+        if (t.size == 1) {
+            return {
+                typ: EnumToken.FunctionTokenType,
+                val: 'translate' + (t.has('x') ? '' : t.has('y') ? 'Y' : 'Z'),
+                chi: [
+                    values[t.has('x') ? 0 : t.has('y') ? 1 : 2]
+                ]
+            };
+        }
+        if (t.size == 2) {
+            if (t.has('z')) {
+                return transform;
+            }
+            return {
+                typ: EnumToken.FunctionTokenType,
+                val: 'translate',
+                chi: [
+                    values[0],
+                    { typ: EnumToken.CommaTokenType },
+                    values[1]
+                ]
+            };
+        }
+    }
+    if (name == 'scale3d' || name == 'scale') {
+        if (t.size == 0) {
+            return {
+                typ: EnumToken.FunctionTokenType,
+                val: 'scale',
+                chi: [
+                    { typ: EnumToken.NumberTokenType, val: 1 }
+                ]
+            };
+        }
+        if (t.size == 1) {
+            return {
+                typ: EnumToken.FunctionTokenType,
+                val: 'scale' + (t.has('x') ? 'X' : t.has('y') ? 'Y' : 'Z'),
+                chi: [
+                    values[t.has('x') ? 0 : t.has('y') ? 1 : 2]
+                ]
+            };
+        }
+        if (t.size == 2) {
+            if (t.has('z')) {
+                return transform;
+            }
+            return {
+                typ: EnumToken.FunctionTokenType,
+                val: 'scale',
+                chi: [
+                    values[0],
+                    { typ: EnumToken.CommaTokenType },
+                    values[1]
+                ]
+            };
+        }
+    }
+    return transform;
+}
 
-export { eqMatrix, minify };
+export { eqMatrix, minify, minifyTransformFunctions };

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

@@ -17,23 +17,23 @@ function rotate3D(angle, x, y, z, from) {
     x *= unit;
     y *= unit;
     z *= unit;
-    matrix[0 * 4 + 0] = 1 - 2 * (y * y + z * z) * sq;
-    matrix[0 * 4 + 1] = 2 * (x * y * sq + z * sc);
-    matrix[0 * 4 + 2] = 2 * (x * z * sq - y * sc);
-    matrix[1 * 4 + 0] = 2 * (x * y * sq - z * sc);
-    matrix[1 * 4 + 1] = 1 - 2 * (x * x + z * z) * sq;
-    matrix[1 * 4 + 2] = 2 * (y * z * sq + x * sc);
-    matrix[2 * 4 + 0] = 2 * (x * z * sq + y * sc);
+    matrix[0] = 1 - 2 * (y * y + z * z) * sq;
+    matrix[1] = 2 * (x * y * sq + z * sc);
+    matrix[2] = 2 * (x * z * sq - y * sc);
+    matrix[4] = 2 * (x * y * sq - z * sc);
+    matrix[4 + 1] = 1 - 2 * (x * x + z * z) * sq;
+    matrix[4 + 2] = 2 * (y * z * sq + x * sc);
+    matrix[2 * 4] = 2 * (x * z * sq + y * sc);
     matrix[2 * 4 + 1] = 2 * (y * z * sq - x * sc);
     matrix[2 * 4 + 2] = 1 - 2 * (x * x + y * y) * sq;
     return multiply(from, matrix);
 }
 function rotate(angle, from) {
     const matrix = identity();
-    matrix[0 * 4 + 0] = Math.cos(angle);
-    matrix[0 * 4 + 1] = Math.sin(angle);
-    matrix[1 * 4 + 0] = -Math.sin(angle);
-    matrix[1 * 4 + 1] = Math.cos(angle);
+    matrix[0] = Math.cos(angle);
+    matrix[1] = Math.sin(angle);
+    matrix[4] = -Math.sin(angle);
+    matrix[4 + 1] = Math.cos(angle);
     return multiply(from, matrix);
 }
 

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

@@ -2,12 +2,12 @@ import { identity, multiply } from './utils.js';
 
 function scaleX(x, from) {
     const matrix = identity();
-    matrix[0 * 4 + 0] = x;
+    matrix[0] = x;
     return multiply(from, matrix);
 }
 function scaleY(y, from) {
     const matrix = identity();
-    matrix[1 * 4 + 1] = y;
+    matrix[4 + 1] = y;
     return multiply(from, matrix);
 }
 function scaleZ(z, from) {
@@ -17,14 +17,14 @@ function scaleZ(z, from) {
 }
 function scale(x, y, from) {
     const matrix = identity();
-    matrix[0 * 4 + 0] = x;
-    matrix[1 * 4 + 1] = y;
+    matrix[0] = x;
+    matrix[4 + 1] = y;
     return multiply(from, matrix);
 }
 function scale3d(x, y, z, from) {
     const matrix = identity();
-    matrix[0 * 4 + 0] = x;
-    matrix[1 * 4 + 1] = y;
+    matrix[0] = x;
+    matrix[4 + 1] = y;
     matrix[2 * 4 + 2] = z;
     return multiply(from, matrix);
 }

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

@@ -2,20 +2,20 @@ import { identity, multiply } from './utils.js';
 
 function skewX(x, from) {
     const matrix = identity();
-    matrix[1 * 4 + 0] = Math.tan(x);
+    matrix[4] = Math.tan(x);
     return multiply(from, matrix);
 }
 function skewY(y, from) {
     const matrix = identity();
-    matrix[0 * 4 + 1] = Math.tan(y);
+    matrix[1] = Math.tan(y);
     return multiply(from, matrix);
 }
 // convert angle to radian
 function skew(values, from) {
     const matrix = identity();
-    matrix[1 * 4 + 0] = Math.tan(values[0]);
+    matrix[4] = Math.tan(values[0]);
     if (values.length > 1) {
-        matrix[0 * 4 + 1] = Math.tan(values[1]);
+        matrix[1] = Math.tan(values[1]);
     }
     return multiply(from, matrix);
 }

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

@@ -2,7 +2,7 @@ import { identity, multiply } from './utils.js';
 
 function translateX(x, from) {
     const matrix = identity();
-    matrix[3 * 4 + 0] = x;
+    matrix[3 * 4] = x;
     return multiply(from, matrix);
 }
 function translateY(y, from) {
@@ -17,13 +17,13 @@ function translateZ(z, from) {
 }
 function translate(translate, from) {
     const matrix = identity();
-    matrix[3 * 4 + 0] = translate[0];
+    matrix[3 * 4] = translate[0];
     matrix[3 * 4 + 1] = translate[1] ?? 0;
     return multiply(from, matrix);
 }
 function translate3d(translate, from) {
     const matrix = identity();
-    matrix[3 * 4 + 0] = translate[0];
+    matrix[3 * 4] = translate[0];
     matrix[3 * 4 + 1] = translate[1];
     matrix[3 * 4 + 2] = translate[2];
     return multiply(from, matrix);