@tbela99/css-parser 1.2.0 → 1.3.0

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

@@ -36,26 +36,12 @@ 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.has('x')) {
                 result.push({
                     typ: EnumToken.FunctionTokenType,
                     val: 'translate',
-                    chi: [{ typ: EnumToken.LengthTokenType, val: round(decomposed.translate[0]) + '', unit: 'px' }]
+                    chi: [{ typ: EnumToken.LengthTokenType, val: round(decomposed.translate[0]), unit: 'px' }]
                 });
             }
             else {
@@ -64,7 +50,7 @@ function minify(matrix) {
                 result.push({
                     typ: EnumToken.FunctionTokenType,
                     val: 'translate' + axis.toUpperCase(),
-                    chi: [{ typ: EnumToken.LengthTokenType, val: round(decomposed.translate[index]) + '', unit: 'px' }]
+                    chi: [{ typ: EnumToken.LengthTokenType, val: round(decomposed.translate[index]), unit: 'px' }]
                 });
             }
         }
@@ -75,15 +61,15 @@ function minify(matrix) {
                 chi: [
                     decomposed.translate[0] == 0 ? {
                         typ: EnumToken.NumberTokenType,
-                        'val': '0'
-                    } : { typ: EnumToken.LengthTokenType, val: round(decomposed.translate[0]) + '', unit: 'px' },
+                        val: 0
+                    } : { 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' },
+                        val: 0
+                    } : { typ: EnumToken.LengthTokenType, val: round(decomposed.translate[1]), unit: 'px' },
                     { typ: EnumToken.CommaTokenType },
-                    { typ: EnumToken.LengthTokenType, val: round(decomposed.translate[2]) + '', unit: 'px' }
+                    { typ: EnumToken.LengthTokenType, val: round(decomposed.translate[2]), unit: 'px' }
                 ]
             });
         }
@@ -92,9 +78,9 @@ function minify(matrix) {
                 typ: EnumToken.FunctionTokenType,
                 val: 'translate',
                 chi: [
-                    { typ: EnumToken.LengthTokenType, val: round(decomposed.translate[0]) + '', unit: 'px' },
+                    { 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.LengthTokenType, val: round(decomposed.translate[1]), unit: 'px' }
                 ]
             });
         }
@@ -108,7 +94,7 @@ function minify(matrix) {
                 chi: [
                     {
                         typ: EnumToken.AngleTokenType,
-                        val: '' + round(angle),
+                        val: round(angle),
                         unit: 'deg'
                     }
                 ]
@@ -121,7 +107,7 @@ function minify(matrix) {
                 chi: [
                     {
                         typ: EnumToken.AngleTokenType,
-                        val: '' + round(angle),
+                        val: round(angle),
                         unit: 'deg'
                     }
                 ]
@@ -134,7 +120,7 @@ function minify(matrix) {
                 chi: [
                     {
                         typ: EnumToken.AngleTokenType,
-                        val: '' + round(angle),
+                        val: round(angle),
                         unit: 'deg'
                     }
                 ]
@@ -147,22 +133,22 @@ function minify(matrix) {
                 chi: [
                     {
                         typ: EnumToken.NumberTokenType,
-                        val: '' + round(x)
+                        val: round(x)
                     },
                     { typ: EnumToken.CommaTokenType },
                     {
                         typ: EnumToken.NumberTokenType,
-                        val: '' + round(y)
+                        val: round(y)
                     },
                     { typ: EnumToken.CommaTokenType },
                     {
                         typ: EnumToken.NumberTokenType,
-                        val: '' + round(z)
+                        val: round(z)
                     },
                     { typ: EnumToken.CommaTokenType },
                     {
                         typ: EnumToken.AngleTokenType,
-                        val: '' + round(angle),
+                        val: round(angle),
                         unit: 'deg'
                     }
                 ]
@@ -185,7 +171,7 @@ function minify(matrix) {
                 typ: EnumToken.FunctionTokenType,
                 val: 'skew' + (skew.has('x') ? '' : 'Y'),
                 chi: [
-                    { typ: EnumToken.AngleTokenType, val: '' + round(decomposed.skew[0]), unit: 'deg' }
+                    { typ: EnumToken.AngleTokenType, val: round(decomposed.skew[0]), unit: 'deg' }
                 ]
             });
         }
@@ -194,9 +180,9 @@ function minify(matrix) {
                 typ: EnumToken.FunctionTokenType,
                 val: 'skew',
                 chi: [
-                    { typ: EnumToken.AngleTokenType, val: '' + round(decomposed.skew[0]), unit: 'deg' },
+                    { typ: EnumToken.AngleTokenType, val: round(decomposed.skew[0]), unit: 'deg' },
                     { typ: EnumToken.CommaTokenType },
-                    { typ: EnumToken.AngleTokenType, val: '' + round(decomposed.skew[1]), unit: 'deg' }
+                    { typ: EnumToken.AngleTokenType, val: round(decomposed.skew[1]), unit: 'deg' }
                 ]
             });
         }
@@ -218,7 +204,7 @@ function minify(matrix) {
                 typ: EnumToken.FunctionTokenType,
                 val: 'scale' + prefix,
                 chi: [
-                    { typ: EnumToken.NumberTokenType, val: '' + round(prefix == 'Z' ? sz : prefix == 'Y' ? sy : sx) }
+                    { typ: EnumToken.NumberTokenType, val: round(prefix == 'Z' ? sz : prefix == 'Y' ? sy : sx) }
                 ]
             });
         }
@@ -227,9 +213,9 @@ function minify(matrix) {
                 typ: EnumToken.FunctionTokenType,
                 val: 'scale',
                 chi: [
-                    { typ: EnumToken.NumberTokenType, val: '' + round(sx) },
+                    { typ: EnumToken.NumberTokenType, val: round(sx) },
                     { typ: EnumToken.CommaTokenType },
-                    { typ: EnumToken.NumberTokenType, val: '' + round(sy) },
+                    { typ: EnumToken.NumberTokenType, val: round(sy) },
                 ]
             });
         }
@@ -238,25 +224,15 @@ function minify(matrix) {
                 typ: EnumToken.FunctionTokenType,
                 val: 'scale3d',
                 chi: [
-                    { typ: EnumToken.NumberTokenType, val: '' + round(sx) },
+                    { typ: EnumToken.NumberTokenType, val: round(sx) },
                     { typ: EnumToken.CommaTokenType },
-                    { typ: EnumToken.NumberTokenType, val: '' + round(sy) },
+                    { typ: EnumToken.NumberTokenType, val: round(sy) },
                     { typ: EnumToken.CommaTokenType },
-                    { typ: EnumToken.NumberTokenType, val: '' + round(sz) }
+                    { typ: EnumToken.NumberTokenType, val: round(sz) }
                 ]
             });
         }
     }
-    // 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)) ? [
         {
@@ -266,10 +242,13 @@ 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);
+    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) {
@@ -277,12 +256,14 @@ function eqMatrix(a, b) {
         }
         mat = multiply(mat, tmp);
     }
+    // toZero(mat);
+    // console.error({mat});
     if (mat == null) {
         return false;
     }
     for (let i = 0; i < 4; i++) {
         for (let j = 0; j < 4; j++) {
-            if (Math.abs(mat[i][j] - data[i][j]) > epsilon) {
+            if (Math.abs(mat[i * 4 + j] - data[i * 4 + j]) > epsilon) {
                 return false;
             }
         }

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

@@ -3,7 +3,7 @@ import { identity, multiply } from './utils.js';
 function perspective(x, from) {
     const matrix = identity();
     // @ts-ignore
-    matrix[2][3] = typeof x == 'object' && x.val == 'none' ? 0 : x == 0 ? Number.NEGATIVE_INFINITY : -1 / x;
+    matrix[2 * 4 + 3] = typeof x == 'object' && x.val == 'none' ? 0 : x == 0 ? Number.NEGATIVE_INFINITY : -1 / x;
     return multiply(from, matrix);
 }
 

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][0] = 1 - 2 * (y * y + z * z) * sq;
-    matrix[0][1] = 2 * (x * y * sq + z * sc);
-    matrix[0][2] = 2 * (x * z * sq - y * sc);
-    matrix[1][0] = 2 * (x * y * sq - z * sc);
-    matrix[1][1] = 1 - 2 * (x * x + z * z) * sq;
-    matrix[1][2] = 2 * (y * z * sq + x * sc);
-    matrix[2][0] = 2 * (x * z * sq + y * sc);
-    matrix[2][1] = 2 * (y * z * sq - x * sc);
-    matrix[2][2] = 1 - 2 * (x * x + y * y) * sq;
+    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[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][0] = Math.cos(angle);
-    matrix[0][1] = Math.sin(angle);
-    matrix[1][0] = -Math.sin(angle);
-    matrix[1][1] = Math.cos(angle);
+    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);
     return multiply(from, matrix);
 }
 

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

@@ -2,30 +2,30 @@ import { identity, multiply } from './utils.js';
 
 function scaleX(x, from) {
     const matrix = identity();
-    matrix[0][0] = x;
+    matrix[0 * 4 + 0] = x;
     return multiply(from, matrix);
 }
 function scaleY(y, from) {
     const matrix = identity();
-    matrix[1][1] = y;
+    matrix[1 * 4 + 1] = y;
     return multiply(from, matrix);
 }
 function scaleZ(z, from) {
     const matrix = identity();
-    matrix[2][2] = z;
+    matrix[2 * 4 + 2] = z;
     return multiply(from, matrix);
 }
 function scale(x, y, from) {
     const matrix = identity();
-    matrix[0][0] = x;
-    matrix[1][1] = y;
+    matrix[0 * 4 + 0] = x;
+    matrix[1 * 4 + 1] = y;
     return multiply(from, matrix);
 }
 function scale3d(x, y, z, from) {
     const matrix = identity();
-    matrix[0][0] = x;
-    matrix[1][1] = y;
-    matrix[2][2] = z;
+    matrix[0 * 4 + 0] = x;
+    matrix[1 * 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][0] = Math.tan(x);
+    matrix[1 * 4 + 0] = Math.tan(x);
     return multiply(from, matrix);
 }
 function skewY(y, from) {
     const matrix = identity();
-    matrix[0][1] = Math.tan(y);
+    matrix[0 * 4 + 1] = Math.tan(y);
     return multiply(from, matrix);
 }
 // convert angle to radian
 function skew(values, from) {
     const matrix = identity();
-    matrix[1][0] = Math.tan(values[0]);
+    matrix[1 * 4 + 0] = Math.tan(values[0]);
     if (values.length > 1) {
-        matrix[0][1] = Math.tan(values[1]);
+        matrix[0 * 4 + 1] = Math.tan(values[1]);
     }
     return multiply(from, matrix);
 }

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

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

@@ -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) {
@@ -12,23 +11,19 @@ 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];
-    // }
-    let result = 0;
-    for (let i = 0; i < point1.length; i++) {
-        result += point1[i] * point2[i];
+    if (point1.length === 4 && point2.length === 4) {
+        return point1[0] * point2[0] + point1[1] * point2[1] + point1[2] * point2[2] + point1[3] * point2[3];
     }
-    return result;
-    // return point1[0] * point2[0] + point1[1] * point2[1] + point1[2] * point2[2];
+    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];
             }
         }
     }
@@ -36,20 +31,17 @@ function multiply(matrixA, matrixB) {
 }
 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])
-    ]);
+    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][col]);
+        let maxVal = Math.abs(augmented[col * 4 + col]);
         for (let row = col + 1; row < 4; row++) {
-            let val = Math.abs(augmented[row][col]);
+            let val = Math.abs(augmented[row * 4 + col]);
             if (val > maxVal) {
                 maxVal = val;
                 maxRow = row;
@@ -64,22 +56,22 @@ function inverse(matrix) {
             [augmented[col], augmented[maxRow]] = [augmented[maxRow], augmented[col]];
         }
         // Scale pivot row to make pivot element 1
-        let pivot = augmented[col][col];
+        let pivot = augmented[col * 4 + col];
         for (let j = 0; j < 8; j++) {
-            augmented[col][j] /= pivot;
+            augmented[col * 4 + j] /= pivot;
         }
         // Eliminate column in other rows
         for (let row = 0; row < 4; row++) {
             if (row !== col) {
-                let factor = augmented[row][col];
+                let factor = augmented[row * 4 + col];
                 for (let j = 0; j < 8; j++) {
-                    augmented[row][j] -= factor * augmented[col][j];
+                    augmented[row * 4 + j] -= factor * augmented[col * 4 + j];
                 }
             }
         }
     }
     // Extract the inverse from the right side of the augmented matrix
-    return augmented.map(row => row.slice(4));
+    return augmented.slice(0, 16);
 }
 // function transpose(matrix: Matrix): Matrix {
 //     // Crée une nouvelle matrice vide 4x4
@@ -103,7 +95,7 @@ function round(number) {
 // 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;
@@ -120,7 +112,7 @@ function decompose(original) {
         perspectiveMatrix[11] = 0;
         perspectiveMatrix[15] = 1;
         // @ts-ignore
-        const inverted = inverse(original.reduce((acc, row, i) => acc.concat([row.slice()]), []))?.flat?.();
+        const inverted = inverse(original.slice());
         if (!inverted) {
             return null;
         }
@@ -243,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,35 +160,118 @@ var EnumToken;
     EnumToken[EnumToken["TimingFunction"] = 17] = "TimingFunction";
     EnumToken[EnumToken["TimelineFunction"] = 16] = "TimelineFunction";
 })(EnumToken || (EnumToken = {}));
-// xyz-d65 is an alias for xyz
+/**
+ * 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 = {}));
 

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

@@ -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')))) {