@tbela99/css-parser 1.1.1-alpha4 → 1.2.0

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

@@ -1,14 +1,14 @@
 import { multiply, identity } from './utils.js';
 import { EnumToken } from '../types.js';
-import { length2Px } from './convert.js';
 import { transformFunctions } from '../../syntax/syntax.js';
+import { length2Px } from '../../syntax/utils.js';
 import '../minify.js';
 import '../walk.js';
 import '../../parser/parse.js';
 import '../../parser/tokenize.js';
 import '../../parser/utils/config.js';
-import { getNumber, getAngle } from '../../renderer/color/color.js';
-import '../../renderer/color/utils/constants.js';
+import { getNumber, getAngle } from '../../syntax/color/color.js';
+import '../../syntax/color/utils/constants.js';
 import '../../renderer/sourcemap/lib/encode.js';
 import { stripCommaToken } from '../../validation/utils/list.js';
 import { translateX, translateY, translateZ, translate, translate3d } from './translate.js';
@@ -22,9 +22,10 @@ import { perspective } from './perspective.js';
 function compute(transformLists) {
     transformLists = transformLists.slice();
     stripCommaToken(transformLists);
-    if (transformLists.length == 0) {
-        return null;
-    }
+    // if (transformLists.length == 0) {
+    //
+    //     return null;
+    // }
     let matrix = identity();
     let mat;
     const cumulative = [];
@@ -60,9 +61,10 @@ function computeMatrix(transformList, matrixVar) {
     let val;
     let i = 0;
     for (; i < transformList.length; i++) {
-        if (transformList[i].typ == EnumToken.WhitespaceTokenType) {
-            continue;
-        }
+        // if (transformList[i].typ == EnumToken.WhitespaceTokenType) {
+        //
+        //     continue;
+        // }
         if (transformList[i].typ != EnumToken.FunctionTokenType || !transformFunctions.includes(transformList[i].val)) {
             return null;
         }
@@ -75,25 +77,27 @@ function computeMatrix(transformList, matrixVar) {
                 {
                     values.length = 0;
                     const children = stripCommaToken(transformList[i].chi.slice());
-                    if (children == null || children.length == 0) {
-                        return null;
-                    }
+                    // if (children == null || children.length == 0) {
+                    //
+                    //     return null;
+                    // }
                     const valCount = transformList[i].val == 'translate3d' || transformList[i].val == 'translate' ? 3 : 1;
-                    if (children.length == 1 && children[0].typ == EnumToken.IdenTokenType && children[0].val == 'none') {
-                        values.fill(0, 0, valCount);
-                    }
-                    else {
-                        for (let j = 0; j < children.length; j++) {
-                            if (children[j].typ == EnumToken.WhitespaceTokenType) {
-                                continue;
-                            }
-                            val = length2Px(children[j]);
-                            if (typeof val != 'number' || Number.isNaN(val)) {
-                                return null;
-                            }
-                            values.push(val);
+                    // if (children.length == 1 && children[0].typ == EnumToken.IdenTokenType && (children[0] as IdentToken).val == 'none') {
+                    //
+                    //     values.fill(0, 0, valCount);
+                    //
+                    // } else {
+                    for (let j = 0; j < children.length; j++) {
+                        if (children[j].typ == EnumToken.WhitespaceTokenType) {
+                            continue;
                         }
+                        val = length2Px(children[j]);
+                        if (val == null) {
+                            return null;
+                        }
+                        values.push(val);
                     }
+                    // }
                     if (values.length == 0 || values.length > valCount) {
                         return null;
                     }
@@ -128,9 +132,10 @@ function computeMatrix(transformList, matrixVar) {
                     let values = [];
                     let valuesCount = transformList[i].val == 'rotate3d' ? 4 : 1;
                     for (const child of stripCommaToken(transformList[i].chi.slice())) {
-                        if (child.typ == EnumToken.WhitespaceTokenType) {
-                            continue;
-                        }
+                        // if (child.typ == EnumToken.WhitespaceTokenType) {
+                        //
+                        //     continue;
+                        // }
                         values.push(child);
                         if (transformList[i].val == 'rotateX') {
                             x = 1;
@@ -173,17 +178,19 @@ 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.CommentTokenType || child.typ == EnumToken.WhitespaceTokenType) {
-                            continue;
-                        }
+                        // if (child.typ == EnumToken.CommentTokenType || child.typ == EnumToken.WhitespaceTokenType) {
+                        //
+                        //     continue;
+                        // }
                         if (child.typ != EnumToken.NumberTokenType) {
                             return null;
                         }
                         values.push(getNumber(child));
                     }
-                    if (values.length == 0) {
-                        return null;
-                    }
+                    // if (values.length == 0) {
+                    //
+                    //     return null;
+                    // }
                     if (transformList[i].val == 'scale3d') {
                         if (values.length != 3) {
                             return null;
@@ -221,13 +228,16 @@ function computeMatrix(transformList, matrixVar) {
                     let value;
                     for (let k = 0; k < transformList[i].chi.length; k++) {
                         child = transformList[i].chi[k];
-                        if (child.typ == EnumToken.CommentTokenType || child.typ == EnumToken.WhitespaceTokenType) {
+                        if (child.typ == EnumToken.CommentTokenType ||
+                            child.typ == EnumToken.CommaTokenType ||
+                            child.typ == EnumToken.WhitespaceTokenType) {
                             continue;
                         }
                         value = getAngle(child);
-                        if (value == null) {
-                            return null;
-                        }
+                        // if (value == null) {
+                        //
+                        //     return null;
+                        // }
                         values.push(value * 2 * Math.PI);
                     }
                     if (values.length == 0 || (values.length > (transformList[i].val == 'skew' ? 2 : 1))) {

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

@@ -1,14 +1,15 @@
 import { toZero, is2DMatrix, identity } from './utils.js';
 import { EnumToken } from '../types.js';
-import { reduceNumber } from '../../renderer/render.js';
 import { eq } from '../../parser/utils/eq.js';
-import { getNumber } from '../../renderer/color/color.js';
-import '../../renderer/color/utils/constants.js';
+import { getNumber } from '../../syntax/color/color.js';
+import '../../syntax/color/utils/constants.js';
 import '../minify.js';
 import '../walk.js';
 import '../../parser/parse.js';
 import '../../parser/tokenize.js';
 import '../../parser/utils/config.js';
+import '../../renderer/sourcemap/lib/encode.js';
+import { minifyNumber } from '../../syntax/utils.js';
 
 function parseMatrix(mat) {
     if (mat.typ == EnumToken.IdenTokenType) {
@@ -87,7 +88,7 @@ function serialize(matrix) {
                 }
                 acc.push({
                     typ: EnumToken.NumberTokenType,
-                    val: reduceNumber(t)
+                    val: minifyNumber(t)
                 });
                 return acc;
             }, [])
@@ -102,7 +103,7 @@ function serialize(matrix) {
             }
             acc.push({
                 typ: EnumToken.NumberTokenType,
-                val: reduceNumber(curr)
+                val: minifyNumber(curr)
             });
             return acc;
         }, [])

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

@@ -36,20 +36,21 @@ function minify(matrix) {
                 coordinates.delete(i == 0 ? 'x' : i == 1 ? 'y' : 'z');
             }
         }
-        if (coordinates.size == 3) {
-            result.push({
-                typ: EnumToken.FunctionTokenType,
-                val: 'translate3d',
-                chi: [
-                    { typ: EnumToken.LengthTokenType, val: round(decomposed.translate[0]) + '', unit: 'px' },
-                    { typ: EnumToken.CommaTokenType },
-                    { typ: EnumToken.LengthTokenType, val: round(decomposed.translate[1]) + '', unit: 'px' },
-                    { typ: EnumToken.CommaTokenType },
-                    { typ: EnumToken.LengthTokenType, val: round(decomposed.translate[2]) + '', unit: 'px' }
-                ]
-            });
-        }
-        else if (coordinates.size == 1) {
+        // if (coordinates.size == 3) {
+        //
+        //     result.push({
+        //         typ: EnumToken.FunctionTokenType,
+        //         val: 'translate3d',
+        //         chi: [
+        //             {typ: EnumToken.LengthTokenType, val: round(decomposed.translate[0]) + '', unit: 'px'},
+        //             {typ: EnumToken.CommaTokenType},
+        //             {typ: EnumToken.LengthTokenType, val: round(decomposed.translate[1]) + '', unit: 'px'},
+        //             {typ: EnumToken.CommaTokenType},
+        //             {typ: EnumToken.LengthTokenType, val: round(decomposed.translate[2]) + '', unit: 'px'}
+        //         ]
+        //     })
+        // } else
+        if (coordinates.size == 1) {
             if (coordinates.has('x')) {
                 result.push({
                     typ: EnumToken.FunctionTokenType,
@@ -91,15 +92,9 @@ function minify(matrix) {
                 typ: EnumToken.FunctionTokenType,
                 val: 'translate',
                 chi: [
-                    decomposed.translate[0] == 0 ? {
-                        typ: EnumToken.NumberTokenType,
-                        'val': '0'
-                    } : { typ: EnumToken.LengthTokenType, val: round(decomposed.translate[0]) + '', unit: 'px' },
+                    { typ: EnumToken.LengthTokenType, val: round(decomposed.translate[0]) + '', unit: 'px' },
                     { typ: EnumToken.CommaTokenType },
-                    decomposed.translate[1] == 0 ? {
-                        typ: EnumToken.NumberTokenType,
-                        'val': '0'
-                    } : { typ: EnumToken.LengthTokenType, val: round(decomposed.translate[1]) + '', unit: 'px' }
+                    { typ: EnumToken.LengthTokenType, val: round(decomposed.translate[1]) + '', unit: 'px' }
                 ]
             });
         }
@@ -175,9 +170,10 @@ function minify(matrix) {
         }
     }
     if (transforms.has('skew')) {
-        if (round(decomposed.skew[0]) == 0) {
-            skew.delete('x');
-        }
+        // if (round(decomposed.skew[0]) == 0) {
+        //
+        //     skew.delete('x');
+        // }
         if (round(decomposed.skew[1]) == 0) {
             skew.delete('y');
         }
@@ -251,15 +247,16 @@ function minify(matrix) {
             });
         }
     }
-    if (transforms.has('perspective')) {
-        result.push({
-            typ: EnumToken.FunctionTokenType,
-            val: 'perspective',
-            chi: [
-                { typ: EnumToken.Length, val: '' + round(1 / decomposed.perspective[2]), unit: 'px' },
-            ]
-        });
-    }
+    // if (transforms.has('perspective')) {
+    //
+    //     result.push({
+    //         typ: EnumToken.FunctionTokenType,
+    //         val: 'perspective',
+    //         chi: [
+    //             {typ: EnumToken.Length, val: '' + round(1 / decomposed.perspective[2]), unit: 'px'},
+    //         ]
+    //     });
+    // }
     // identity
     return result.length == 0 || (result.length == 1 && eqMatrix(identity(), result)) ? [
         {

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

@@ -12,10 +12,16 @@ function normalize(point) {
     return norm === 0 ? [0, 0, 0] : [x / norm, y / norm, z / norm];
 }
 function dot(point1, point2) {
-    if (point1.length === 4 && point2.length === 4) {
-        return point1[0] * point2[0] + point1[1] * point2[1] + point1[2] * point2[2] + point1[3] * point2[3];
+    // if (point1.length === 4 && point2.length === 4) {
+    //
+    //     return point1[0] * point2[0] + point1[1] * point2[1] + point1[2] * point2[2] + point1[3] * point2[3];
+    // }
+    let result = 0;
+    for (let i = 0; i < point1.length; i++) {
+        result += point1[i] * point2[i];
     }
-    return point1[0] * point2[0] + point1[1] * point2[1] + point1[2] * point2[2];
+    return result;
+    // 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));
@@ -28,6 +34,69 @@ function multiply(matrixA, matrixB) {
     }
     return result;
 }
+function inverse(matrix) {
+    // Create augmented matrix [matrix | identity]
+    let augmented = matrix.map((row, i) => [
+        ...row,
+        ...(i === 0 ? [1, 0, 0, 0] :
+            i === 1 ? [0, 1, 0, 0] :
+                i === 2 ? [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][col]);
+        for (let row = col + 1; row < 4; row++) {
+            let val = Math.abs(augmented[row][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][col];
+        for (let j = 0; j < 8; j++) {
+            augmented[col][j] /= pivot;
+        }
+        // Eliminate column in other rows
+        for (let row = 0; row < 4; row++) {
+            if (row !== col) {
+                let factor = augmented[row][col];
+                for (let j = 0; j < 8; j++) {
+                    augmented[row][j] -= factor * augmented[col][j];
+                }
+            }
+        }
+    }
+    // Extract the inverse from the right side of the augmented matrix
+    return augmented.map(row => row.slice(4));
+}
+// 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);
 }
@@ -50,11 +119,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.reduce((acc, row, i) => acc.concat([row.slice()]), []))?.flat?.();
+        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 +229,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) {

package/dist/lib/ast/types.js

@@ -154,5 +154,36 @@ var EnumToken;
     EnumToken[EnumToken["TimingFunction"] = 17] = "TimingFunction";
     EnumToken[EnumToken["TimelineFunction"] = 16] = "TimelineFunction";
 })(EnumToken || (EnumToken = {}));
+// xyz-d65 is an alias for xyz
+var ColorType;
+(function (ColorType) {
+    ColorType[ColorType["SYS"] = 0] = "SYS";
+    ColorType[ColorType["DPSYS"] = 1] = "DPSYS";
+    ColorType[ColorType["LIT"] = 2] = "LIT";
+    ColorType[ColorType["HEX"] = 3] = "HEX";
+    ColorType[ColorType["RGBA"] = 4] = "RGBA";
+    ColorType[ColorType["HSLA"] = 5] = "HSLA";
+    ColorType[ColorType["HWB"] = 6] = "HWB";
+    ColorType[ColorType["CMYK"] = 7] = "CMYK";
+    ColorType[ColorType["OKLAB"] = 8] = "OKLAB";
+    ColorType[ColorType["OKLCH"] = 9] = "OKLCH";
+    ColorType[ColorType["LAB"] = 10] = "LAB";
+    ColorType[ColorType["LCH"] = 11] = "LCH";
+    ColorType[ColorType["COLOR"] = 12] = "COLOR";
+    ColorType[ColorType["SRGB"] = 13] = "SRGB";
+    ColorType[ColorType["PROPHOTO_RGB"] = 14] = "PROPHOTO_RGB";
+    ColorType[ColorType["A98_RGB"] = 15] = "A98_RGB";
+    ColorType[ColorType["REC2020"] = 16] = "REC2020";
+    ColorType[ColorType["DISPLAY_P3"] = 17] = "DISPLAY_P3";
+    ColorType[ColorType["SRGB_LINEAR"] = 18] = "SRGB_LINEAR";
+    ColorType[ColorType["XYZ_D50"] = 19] = "XYZ_D50";
+    ColorType[ColorType["XYZ_D65"] = 20] = "XYZ_D65";
+    ColorType[ColorType["LIGHT_DARK"] = 21] = "LIGHT_DARK";
+    ColorType[ColorType["COLOR_MIX"] = 22] = "COLOR_MIX";
+    ColorType[ColorType["RGB"] = 4] = "RGB";
+    ColorType[ColorType["HSL"] = 5] = "HSL";
+    ColorType[ColorType["XYZ"] = 20] = "XYZ";
+    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) {