@tbela99/css-parser 1.1.1 → 1.3.0

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

@@ -1,14 +1,14 @@
-import { multiply, identity } from './utils.js';
+import { multiply, toZero, 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,6 @@ import { perspective } from './perspective.js';
 function compute(transformLists) {
     transformLists = transformLists.slice();
     stripCommaToken(transformLists);
-    if (transformLists.length == 0) {
-        return null;
-    }
     let matrix = identity();
     let mat;
     const cumulative = [];
@@ -49,8 +46,10 @@ function compute(transformLists) {
             });
         }
     }
+    // console.error({matrix});
+    // matrix = toZero(matrix) as Matrix;
     return {
-        matrix: serialize(matrix),
+        matrix: serialize(toZero(matrix)),
         cumulative,
         minified: minify(matrix) ?? [serialized]
     };
@@ -60,9 +59,6 @@ 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.FunctionTokenType || !transformFunctions.includes(transformList[i].val)) {
             return null;
         }
@@ -75,24 +71,16 @@ function computeMatrix(transformList, matrixVar) {
                 {
                     values.length = 0;
                     const children = stripCommaToken(transformList[i].chi.slice());
-                    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);
+                    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 +116,6 @@ 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;
-                        }
                         values.push(child);
                         if (transformList[i].val == 'rotateX') {
                             x = 1;
@@ -173,17 +158,11 @@ 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.NumberTokenType) {
                             return null;
                         }
                         values.push(getNumber(child));
                     }
-                    if (values.length == 0) {
-                        return null;
-                    }
                     if (transformList[i].val == 'scale3d') {
                         if (values.length != 3) {
                             return null;
@@ -221,13 +200,12 @@ 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;
-                        }
                         values.push(value * 2 * Math.PI);
                     }
                     if (values.length == 0 || (values.length > (transformList[i].val == 'skew' ? 2 : 1))) {
@@ -268,7 +246,6 @@ function computeMatrix(transformList, matrixVar) {
                 }
                 break;
             case 'matrix3d':
-            // return null;
             case 'matrix':
                 {
                     const values = [];

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

@@ -1,14 +1,14 @@
-import { toZero, is2DMatrix, identity } from './utils.js';
+import { 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';
 
 function parseMatrix(mat) {
     if (mat.typ == EnumToken.IdenTokenType) {
@@ -30,30 +30,30 @@ function parseMatrix(mat) {
 function matrix(values) {
     const matrix = identity();
     if (values.length === 6) {
-        matrix[0][0] = values[0];
-        matrix[0][1] = values[1];
-        matrix[1][0] = values[2];
-        matrix[1][1] = values[3];
-        matrix[3][0] = values[4];
-        matrix[3][1] = values[5];
+        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[3 * 4 + 1] = values[5];
     }
     else if (values.length === 16) {
-        matrix[0][0] = values[0];
-        matrix[0][1] = values[1];
-        matrix[0][2] = values[2];
-        matrix[0][3] = values[3];
-        matrix[1][0] = values[4];
-        matrix[1][1] = values[5];
-        matrix[1][2] = values[6];
-        matrix[1][3] = values[7];
-        matrix[2][0] = values[8];
-        matrix[2][1] = values[9];
-        matrix[2][2] = values[10];
-        matrix[2][3] = values[11];
-        matrix[3][0] = values[12];
-        matrix[3][1] = values[13];
-        matrix[3][2] = values[14];
-        matrix[3][3] = values[15];
+        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[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 + 1] = values[13];
+        matrix[3 * 4 + 2] = values[14];
+        matrix[3 * 4 + 3] = values[15];
     }
     else {
         return null;
@@ -61,7 +61,7 @@ function matrix(values) {
     return matrix;
 }
 function serialize(matrix) {
-    matrix = matrix.map(t => toZero(t.slice()));
+    matrix = matrix.slice();
     // @ts-ignore
     if (eq(matrix, identity())) {
         return {
@@ -75,19 +75,19 @@ function serialize(matrix) {
             typ: EnumToken.FunctionTokenType,
             val: 'matrix',
             chi: [
-                matrix[0][0],
-                matrix[0][1],
-                matrix[1][0],
-                matrix[1][1],
-                matrix[3][0],
-                matrix[3][1]
+                matrix[0 * 4 + 0],
+                matrix[0 * 4 + 1],
+                matrix[1 * 4 + 0],
+                matrix[1 * 4 + 1],
+                matrix[3 * 4 + 0],
+                matrix[3 * 4 + 1]
             ].reduce((acc, t) => {
                 if (acc.length > 0) {
                     acc.push({ typ: EnumToken.CommaTokenType });
                 }
                 acc.push({
                     typ: EnumToken.NumberTokenType,
-                    val: reduceNumber(t)
+                    val: t
                 });
                 return acc;
             }, [])
@@ -96,13 +96,13 @@ function serialize(matrix) {
     return {
         typ: EnumToken.FunctionTokenType,
         val: 'matrix3d',
-        chi: matrix.flat().reduce((acc, curr) => {
+        chi: matrix.reduce((acc, curr) => {
             if (acc.length > 0) {
                 acc.push({ typ: EnumToken.CommaTokenType });
             }
             acc.push({
                 typ: EnumToken.NumberTokenType,
-                val: reduceNumber(curr)
+                val: curr
             });
             return acc;
         }, [])

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

@@ -36,25 +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.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 {
@@ -63,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' }]
                 });
             }
         }
@@ -74,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' }
                 ]
             });
         }
@@ -91,15 +78,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' }
                 ]
             });
         }
@@ -113,7 +94,7 @@ function minify(matrix) {
                 chi: [
                     {
                         typ: EnumToken.AngleTokenType,
-                        val: '' + round(angle),
+                        val: round(angle),
                         unit: 'deg'
                     }
                 ]
@@ -126,7 +107,7 @@ function minify(matrix) {
                 chi: [
                     {
                         typ: EnumToken.AngleTokenType,
-                        val: '' + round(angle),
+                        val: round(angle),
                         unit: 'deg'
                     }
                 ]
@@ -139,7 +120,7 @@ function minify(matrix) {
                 chi: [
                     {
                         typ: EnumToken.AngleTokenType,
-                        val: '' + round(angle),
+                        val: round(angle),
                         unit: 'deg'
                     }
                 ]
@@ -152,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'
                     }
                 ]
@@ -175,9 +156,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');
         }
@@ -189,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' }
                 ]
             });
         }
@@ -198,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' }
                 ]
             });
         }
@@ -222,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) }
                 ]
             });
         }
@@ -231,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) },
                 ]
             });
         }
@@ -242,24 +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)) ? [
         {
@@ -269,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) {
@@ -280,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);
 }