@tbela99/css-parser 1.1.1 → 1.3.0

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

@@ -1,9 +1,8 @@
 const epsilon = 1e-5;
 function identity() {
-    return [[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1]];
+    return [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];
 }
 function pLength(point) {
-    // Calcul de la norme euclidienne
     return Math.sqrt(point[0] * point[0] + point[1] * point[1] + point[2] * point[2]);
 }
 function normalize(point) {
@@ -18,23 +17,85 @@ function dot(point1, point2) {
     return point1[0] * point2[0] + point1[1] * point2[1] + point1[2] * point2[2];
 }
 function multiply(matrixA, matrixB) {
-    let result = Array(4).fill(0).map(() => Array(4).fill(0));
+    let result = new Array(16).fill(0);
     for (let i = 0; i < 4; i++) {
         for (let j = 0; j < 4; j++) {
             for (let k = 0; k < 4; k++) {
-                result[j][i] += matrixA[k][i] * matrixB[j][k];
+                // Utiliser l'indexation linéaire pour accéder aux éléments
+                // Pour une matrice 4x4, l'index est (row * 4 + col)
+                result[j * 4 + i] += matrixA[k * 4 + i] * matrixB[j * 4 + k];
             }
         }
     }
     return result;
 }
+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
+    ];
+    // Gaussian elimination with partial pivoting
+    for (let col = 0; col < 4; col++) {
+        // Find pivot row with maximum absolute value
+        let maxRow = col;
+        let maxVal = Math.abs(augmented[col * 4 + col]);
+        for (let row = col + 1; row < 4; row++) {
+            let val = Math.abs(augmented[row * 4 + col]);
+            if (val > maxVal) {
+                maxVal = val;
+                maxRow = row;
+            }
+        }
+        // Check for singularity
+        if (maxVal < 1e-5) {
+            return null;
+        }
+        // Swap rows if necessary
+        if (maxRow !== col) {
+            [augmented[col], augmented[maxRow]] = [augmented[maxRow], augmented[col]];
+        }
+        // Scale pivot row to make pivot element 1
+        let pivot = augmented[col * 4 + col];
+        for (let j = 0; j < 8; j++) {
+            augmented[col * 4 + j] /= pivot;
+        }
+        // Eliminate column in other rows
+        for (let row = 0; row < 4; row++) {
+            if (row !== col) {
+                let factor = augmented[row * 4 + col];
+                for (let j = 0; j < 8; j++) {
+                    augmented[row * 4 + j] -= factor * augmented[col * 4 + j];
+                }
+            }
+        }
+    }
+    // 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);
 }
 // translate3d(25.9808px, 0, 15px ) rotateY(60deg) skewX(49.9999deg) scale(1, 1.2)
 // translate → rotate → skew → scale
 function decompose(original) {
-    const matrix = original.flat();
+    const matrix = original.slice();
     // Normalize last row
     if (matrix[15] === 0) {
         return null;
@@ -50,11 +111,12 @@ function decompose(original) {
         perspectiveMatrix[7] = 0;
         perspectiveMatrix[11] = 0;
         perspectiveMatrix[15] = 1;
-        const inverse = invertMatrix4(perspectiveMatrix);
-        if (!inverse) {
+        // @ts-ignore
+        const inverted = inverse(original.slice());
+        if (!inverted) {
             return null;
         }
-        const transposedInverse = transposeMatrix4(inverse);
+        const transposedInverse = transposeMatrix4(inverted);
         perspective[0] = dot(rightHandSide, transposedInverse.slice(0, 4));
         perspective[1] = dot(rightHandSide, transposedInverse.slice(4, 8));
         perspective[2] = dot(rightHandSide, transposedInverse.slice(8, 12));
@@ -159,16 +221,6 @@ function transposeMatrix4(m) {
         m[3], m[7], m[11], m[15],
     ];
 }
-function invertMatrix4(m) {
-    new Array(16);
-    const det = m[0] * m[5] * m[10] * m[15] + m[0] * m[9] * m[14] * m[7] + m[0] * m[13] * m[6] * m[11]
-        - m[0] * m[13] * m[10] * m[7] - m[0] * m[9] * m[6] * m[15] - m[0] * m[5] * m[14] * m[11];
-    if (det === 0)
-        return null;
-    // For brevity, not implementing full inverse here — you'd normally use gl-matrix or similar.
-    // Just use a trusted library or expand this if needed.
-    return null; // placeholder
-}
 function toZero(v) {
     for (let i = 0; i < v.length; i++) {
         if (Math.abs(v[i]) <= epsilon) {
@@ -183,16 +235,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][2] === 0 &&
-        matrix[0][3] === 0 &&
-        matrix[1][2] === 0 &&
-        matrix[1][3] === 0 &&
-        matrix[2][0] === 0 &&
-        matrix[2][1] === 0 &&
-        matrix[2][3] === 0 &&
-        matrix[3][2] === 0 &&
-        matrix[2][2] === 1 &&
-        matrix[3][3] === 1;
+    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;
 }
 
 export { decompose, epsilon, identity, is2DMatrix, multiply, round, toZero };

package/dist/lib/ast/types.js

@@ -1,8 +1,14 @@
+/**
+ * syntax validation enum
+ */
 var SyntaxValidationResult;
 (function (SyntaxValidationResult) {
+    /** valid syntax */
     SyntaxValidationResult[SyntaxValidationResult["Valid"] = 0] = "Valid";
+    /** drop invalid syntax */
     SyntaxValidationResult[SyntaxValidationResult["Drop"] = 1] = "Drop";
-    SyntaxValidationResult[SyntaxValidationResult["Lenient"] = 2] = "Lenient"; /* preserve unknown at-rules, declarations and pseudo-classes */
+    /** preserve unknown at-rules, declarations and pseudo-classes */
+    SyntaxValidationResult[SyntaxValidationResult["Lenient"] = 2] = "Lenient";
 })(SyntaxValidationResult || (SyntaxValidationResult = {}));
 /**
  * validation level enum
@@ -154,5 +160,119 @@ var EnumToken;
     EnumToken[EnumToken["TimingFunction"] = 17] = "TimingFunction";
     EnumToken[EnumToken["TimelineFunction"] = 16] = "TimelineFunction";
 })(EnumToken || (EnumToken = {}));
+/**
+ * color types enum
+ */
+var ColorType;
+(function (ColorType) {
+    /**
+     * system colors
+     */
+    ColorType[ColorType["SYS"] = 0] = "SYS";
+    /**
+     * deprecated system colors
+     */
+    ColorType[ColorType["DPSYS"] = 1] = "DPSYS";
+    /**
+     * colors as literals
+     */
+    ColorType[ColorType["LIT"] = 2] = "LIT";
+    /**
+     * colors as hex values
+     */
+    ColorType[ColorType["HEX"] = 3] = "HEX";
+    /**
+     * colors as rgb values
+     */
+    ColorType[ColorType["RGBA"] = 4] = "RGBA";
+    /**
+     * colors as hsl values
+     */
+    ColorType[ColorType["HSLA"] = 5] = "HSLA";
+    /**
+     * colors as hwb values
+     */
+    ColorType[ColorType["HWB"] = 6] = "HWB";
+    /**
+     * colors as cmyk values
+     */
+    ColorType[ColorType["CMYK"] = 7] = "CMYK";
+    /**
+     * colors as oklab values
+     * */
+    ColorType[ColorType["OKLAB"] = 8] = "OKLAB";
+    /**
+     * colors as oklch values
+     * */
+    ColorType[ColorType["OKLCH"] = 9] = "OKLCH";
+    /**
+     * colors as lab values
+     */
+    ColorType[ColorType["LAB"] = 10] = "LAB";
+    /**
+     * colors as lch values
+     */
+    ColorType[ColorType["LCH"] = 11] = "LCH";
+    /**
+     * colors using color() function
+     */
+    ColorType[ColorType["COLOR"] = 12] = "COLOR";
+    /**
+     * color using srgb values
+     */
+    ColorType[ColorType["SRGB"] = 13] = "SRGB";
+    /**
+     * color using prophoto-rgb values
+     */
+    ColorType[ColorType["PROPHOTO_RGB"] = 14] = "PROPHOTO_RGB";
+    /**
+     * color using a98-rgb values
+     */
+    ColorType[ColorType["A98_RGB"] = 15] = "A98_RGB";
+    /**
+     * color using rec2020 values
+     */
+    ColorType[ColorType["REC2020"] = 16] = "REC2020";
+    /**
+     * color using display-p3 values
+     */
+    ColorType[ColorType["DISPLAY_P3"] = 17] = "DISPLAY_P3";
+    /**
+     * color using srgb-linear values
+     */
+    ColorType[ColorType["SRGB_LINEAR"] = 18] = "SRGB_LINEAR";
+    /**
+     * color using xyz-d50 values
+     */
+    ColorType[ColorType["XYZ_D50"] = 19] = "XYZ_D50";
+    /**
+     * color using xyz-d65 values
+     */
+    ColorType[ColorType["XYZ_D65"] = 20] = "XYZ_D65";
+    /**
+     * light-dark() color function
+     */
+    ColorType[ColorType["LIGHT_DARK"] = 21] = "LIGHT_DARK";
+    /**
+     * color-mix() color function
+     */
+    ColorType[ColorType["COLOR_MIX"] = 22] = "COLOR_MIX";
+    /**
+     * alias for rgba
+     */
+    ColorType[ColorType["RGB"] = 4] = "RGB";
+    /**
+     * alias for hsl
+     */
+    ColorType[ColorType["HSL"] = 5] = "HSL";
+    /**
+     * alias for xyz-d65
+     */
+    ColorType[ColorType["XYZ"] = 20] = "XYZ";
+    /**
+     * alias for cmyk
+     */
+    ColorType[ColorType["DEVICE_CMYK"] = 7] = "DEVICE_CMYK";
+})(ColorType || (ColorType = {}));
 
-export { EnumToken, SyntaxValidationResult, ValidationLevel };
+export { ColorType, EnumToken, SyntaxValidationResult, ValidationLevel };

package/dist/lib/fs/resolve.js

@@ -71,27 +71,14 @@ function resolve(url, currentDirectory, cwd) {
             relative: path
         };
     }
-    let result;
+    let result = '';
     if (url.charAt(0) == '/') {
         result = url;
     }
     else if (currentDirectory.charAt(0) == '/') {
         result = dirname(currentDirectory) + '/' + url;
     }
-    else if (currentDirectory === '' || dirname(currentDirectory) === '') {
-        result = url;
-    }
-    else {
-        result = dirname(currentDirectory) + '/' + url;
-    }
     let { parts, i } = splitPath(result);
-    if (parts.length == 0) {
-        const path = result.charAt(0) == '/' ? '/' : '';
-        return {
-            absolute: path,
-            relative: path
-        };
-    }
     const absolute = parts.join('/');
     const { parts: dirs } = splitPath(cwd ?? currentDirectory);
     for (const p of dirs) {

package/dist/lib/parser/declaration/list.js

@@ -5,7 +5,7 @@ import '../../ast/minify.js';
 import '../../ast/walk.js';
 import { parseString } from '../parse.js';
 import '../tokenize.js';
-import '../../renderer/color/utils/constants.js';
+import '../../syntax/color/utils/constants.js';
 import '../../renderer/sourcemap/lib/encode.js';
 import { PropertyMap } from './map.js';
 

package/dist/lib/parser/declaration/map.js

@@ -7,7 +7,7 @@ import '../../ast/walk.js';
 import { parseString } from '../parse.js';
 import '../tokenize.js';
 import { renderToken } from '../../renderer/render.js';
-import '../../renderer/color/utils/constants.js';
+import '../../syntax/color/utils/constants.js';
 import { PropertySet } from './set.js';
 
 const propertiesConfig = getConfig();

package/dist/lib/parser/declaration/set.js

@@ -6,7 +6,7 @@ import '../parse.js';
 import '../tokenize.js';
 import '../utils/config.js';
 import { isLength } from '../../syntax/syntax.js';
-import '../../renderer/color/utils/constants.js';
+import '../../syntax/color/utils/constants.js';
 import '../../renderer/sourcemap/lib/encode.js';
 
 function dedup(values) {
@@ -15,7 +15,7 @@ function dedup(values) {
         while (i-- > 1) {
             const t = value[i];
             const k = value[i == 1 ? 0 : i % 2];
-            if (t.val == k.val && t.val == '0') {
+            if (t.val == k.val && t.val == 0) {
                 if ((t.typ == EnumToken.NumberTokenType && isLength(k)) ||
                     (k.typ == EnumToken.NumberTokenType && isLength(t)) ||
                     (isLength(k) || isLength(t))) {
@@ -52,7 +52,7 @@ class PropertySet {
                 // @ts-ignore
                 for (let token of this.declarations.get(this.config.shorthand).val) {
                     // @ts-ignore
-                    if (this.config.types.some(t => token.typ == EnumToken[t]) || (token.typ == EnumToken.NumberTokenType && token.val == '0' &&
+                    if (this.config.types.some(t => token.typ == EnumToken[t]) || (token.typ == EnumToken.NumberTokenType && token.val == 0 &&
                         (this.config.types.includes('Length') ||
                             this.config.types.includes('Angle') ||
                             this.config.types.includes('Dimension')))) {