@tbela99/css-parser 1.3.2 → 1.3.4

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);

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

@@ -2,9 +2,6 @@ const epsilon = 1e-5;
 function identity() {
     return [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];
 }
-function pLength(point) {
-    return Math.sqrt(point[0] * point[0] + point[1] * point[1] + point[2] * point[2]);
-}
 function normalize(point) {
     const [x, y, z] = point;
     const norm = Math.sqrt(point[0] * point[0] + point[1] * point[1] + point[2] * point[2]);
@@ -32,8 +29,14 @@ function multiply(matrixA, matrixB) {
 function inverse(matrix) {
     // Create augmented matrix [matrix | identity]
     let augmented = [
-        1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1,
-        1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1
+        ...matrix.slice(0, 4),
+        1, 0, 0, 0,
+        ...matrix.slice(4, 8),
+        0, 1, 0, 0,
+        ...matrix.slice(8, 12),
+        0, 0, 1, 0,
+        ...matrix.slice(12, 16),
+        0, 0, 0, 1
     ];
     // Gaussian elimination with partial pivoting
     for (let col = 0; col < 4; col++) {
@@ -73,24 +76,9 @@ function inverse(matrix) {
     // Extract the inverse from the right side of the augmented matrix
     return augmented.slice(0, 16);
 }
-// function transpose(matrix: Matrix): Matrix {
-//     // Crée une nouvelle matrice vide 4x4
-//     // @ts-ignore
-//     let transposed: Matrix = [[], [], [], []] as Matrix;
-//
-//     // Parcourt chaque ligne et colonne pour transposer
-//     for (let i = 0; i < 4; i++) {
-//
-//         for (let j = 0; j < 4; j++) {
-//
-//             transposed[j][i] = matrix[i][j];
-//         }
-//     }
-//
-//     return transposed;
-// }
 function round(number) {
-    return Math.abs(number) < epsilon ? 0 : +number.toPrecision(6);
+    const rounded = Math.round(number);
+    return Math.abs(rounded - number) <= epsilon ? rounded : +number.toPrecision(6);
 }
 // translate3d(25.9808px, 0, 15px ) rotateY(60deg) skewX(49.9999deg) scale(1, 1.2)
 // translate → rotate → skew → scale
@@ -113,7 +101,7 @@ function decompose(original) {
         perspectiveMatrix[15] = 1;
         // @ts-ignore
         const inverted = inverse(original.slice());
-        if (!inverted) {
+        if (inverted === null) {
             return null;
         }
         const transposedInverse = transposeMatrix4(inverted);
@@ -134,8 +122,13 @@ function decompose(original) {
     const row0 = [matrix[0], matrix[1], matrix[2]];
     const row1 = [matrix[4], matrix[5], matrix[6]];
     const row2 = [matrix[8], matrix[9], matrix[10]];
+    const cross = [
+        row1[1] * row2[2] - row1[2] * row2[1],
+        row1[2] * row2[0] - row1[0] * row2[2],
+        row1[0] * row2[1] - row1[1] * row2[0],
+    ];
     // Compute scale
-    const scaleX = pLength(row0);
+    const scaleX = Math.hypot(...row0);
     const row0Norm = normalize(row0);
     const skewXY = dot(row0Norm, row1);
     const row1Proj = [
@@ -143,7 +136,7 @@ function decompose(original) {
         row1[1] - skewXY * row0Norm[1],
         row1[2] - skewXY * row0Norm[2]
     ];
-    const scaleY = pLength(row1Proj);
+    const scaleY = Math.hypot(...row1Proj);
     const row1Norm = normalize(row1Proj);
     const skewXZ = dot(row0Norm, row2);
     const skewYZ = dot(row1Norm, row2);
@@ -152,8 +145,9 @@ function decompose(original) {
         row2[1] - skewXZ * row0Norm[1] - skewYZ * row1Norm[1],
         row2[2] - skewXZ * row0Norm[2] - skewYZ * row1Norm[2]
     ];
-    const scaleZ = pLength(row2Proj);
     const row2Norm = normalize(row2Proj);
+    const determinant = row0[0] * cross[0] + row0[1] * cross[1] + row0[2] * cross[2];
+    const scaleZ = Math.hypot(...row2Proj) * (determinant < 0 ? -1 : 1);
     // Build rotation matrix from orthonormalized vectors
     const r00 = row0Norm[0], r01 = row1Norm[0], r02 = row2Norm[0];
     const r10 = row0Norm[1], r11 = row1Norm[1], r12 = row2Norm[1];
@@ -190,7 +184,6 @@ function decompose(original) {
         qz = 0.25 * s;
     }
     [qx, qy, qz] = toZero([qx, qy, qz]);
-    // const q = gcd(qx, gcd(qy, qz));
     let q = [Math.abs(qx), Math.abs(qy), Math.abs(qz)].reduce((acc, curr) => {
         if (acc == 0 || (curr > 0 && curr < acc)) {
             acc = curr;
@@ -235,16 +228,16 @@ function toZero(v) {
 // https://drafts.csswg.org/css-transforms-1/#2d-matrix
 function is2DMatrix(matrix) {
     // m13,m14,  m23, m24, m31, m32, m34, m43 are all 0
-    return matrix[0 * 4 + 2] === 0 &&
-        matrix[0 * 4 + 3] === 0 &&
-        matrix[1 * 4 + 2] === 0 &&
-        matrix[1 * 4 + 3] === 0 &&
-        matrix[2 * 4 + 0] === 0 &&
-        matrix[2 * 4 + 1] === 0 &&
-        matrix[2 * 4 + 3] === 0 &&
-        matrix[3 * 4 + 2] === 0 &&
-        matrix[2 * 4 + 2] === 1 &&
-        matrix[3 * 4 + 3] === 1;
+    return matrix[2] === 0 &&
+        matrix[3] === 0 &&
+        matrix[6] === 0 &&
+        matrix[7] === 0 &&
+        matrix[8] === 0 &&
+        matrix[9] === 0 &&
+        matrix[11] === 0 &&
+        matrix[14] === 0 &&
+        matrix[10] === 1 &&
+        matrix[15] === 1;
 }
 
 export { decompose, epsilon, identity, is2DMatrix, multiply, round, toZero };

package/dist/lib/ast/types.js

@@ -19,14 +19,26 @@ var ValidationLevel;
      * disable validation
      */
     ValidationLevel[ValidationLevel["None"] = 0] = "None";
+    /**
+     * validate selectors
+     */
+    ValidationLevel[ValidationLevel["Selector"] = 1] = "Selector";
+    /**
+     * validate at-rules
+     */
+    ValidationLevel[ValidationLevel["AtRule"] = 2] = "AtRule";
+    /**
+     * validate declarations
+     */
+    ValidationLevel[ValidationLevel["Declaration"] = 4] = "Declaration";
     /**
      * validate selectors and at-rules
      */
-    ValidationLevel[ValidationLevel["Default"] = 1] = "Default";
+    ValidationLevel[ValidationLevel["Default"] = 3] = "Default";
     /**
      * validate selectors, at-rules and declarations
      */
-    ValidationLevel[ValidationLevel["All"] = 2] = "All"; // selectors + at-rules + declarations
+    ValidationLevel[ValidationLevel["All"] = 7] = "All"; // selectors + at-rules + declarations
 })(ValidationLevel || (ValidationLevel = {}));
 /**
  * enum of all token types
@@ -330,7 +342,7 @@ var EnumToken;
     /**
      * keyframe rule node type
      */
-    EnumToken[EnumToken["KeyFrameRuleNodeType"] = 73] = "KeyFrameRuleNodeType";
+    EnumToken[EnumToken["KeyFramesRuleNodeType"] = 73] = "KeyFramesRuleNodeType";
     /**
      * class selector token type
      */
@@ -410,7 +422,7 @@ var EnumToken;
     /**
      * keyframe at rule node type
      */
-    EnumToken[EnumToken["KeyframeAtRuleNodeType"] = 93] = "KeyframeAtRuleNodeType";
+    EnumToken[EnumToken["KeyframesAtRuleNodeType"] = 93] = "KeyframesAtRuleNodeType";
     /**
      * invalid declaration node type
      */