@tbela99/css-parser 1.4.1 → 1.4.3

package/dist/lib/ast/transform/compute.d.ts

@@ -0,0 +1,8 @@
+import type { Token } from "../../../@types/token.d.ts";
+import type { Matrix } from "./type.d.ts";
+export declare function compute(transformLists: Token[]): {
+    matrix: Token;
+    cumulative: Token[];
+    minified: Token[];
+} | null;
+export declare function computeMatrix(transformList: Token[], matrixVar: Matrix): Matrix | null;

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

@@ -1,23 +1,15 @@
 import { multiply, toZero, identity } from './utils.js';
-import { EnumToken } from '../types.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 '../../syntax/color/color.js';
-import '../../syntax/color/utils/constants.js';
-import '../../renderer/sourcemap/lib/encode.js';
+import { EnumToken, length2Px } from '../types.js';
 import { stripCommaToken } from '../../validation/utils/list.js';
 import { translateX, translateY, translateZ, translate, translate3d } from './translate.js';
+import { getNumber, getAngle } from '../../syntax/color/color.js';
 import { rotate, rotate3D } from './rotate.js';
 import { scale3d, scale, scaleX, scaleY, scaleZ } from './scale.js';
 import { minify } from './minify.js';
 import { skew, skewX, skewY } from './skew.js';
 import { serialize, matrix } from './matrix.js';
 import { perspective } from './perspective.js';
+import { transformFunctions } from '../../syntax/constants.js';
 
 function compute(transformLists) {
     transformLists = transformLists.slice();
@@ -36,20 +28,21 @@ function compute(transformLists) {
     const serialized = serialize(matrix);
     if (cumulative.length > 0) {
         for (let i = 0; i < cumulative.length; i++) {
-            if (cumulative[i].typ == EnumToken.IdenTokenType && cumulative[i].val == 'none') {
+            if (cumulative[i].typ == EnumToken.IdenTokenType && cumulative[i].val == "none") {
                 cumulative.splice(i--, 1);
             }
         }
         if (cumulative.length == 0) {
             cumulative.push({
-                typ: EnumToken.IdenTokenType, val: 'none'
+                typ: EnumToken.IdenTokenType,
+                val: "none",
             });
         }
     }
     return {
         matrix: serialize(toZero(matrix)),
         cumulative,
-        minified: minify(matrix) ?? [serialized]
+        minified: minify(matrix) ?? [serialized],
     };
 }
 function computeMatrix(transformList, matrixVar) {
@@ -57,19 +50,24 @@ function computeMatrix(transformList, matrixVar) {
     let val;
     let i = 0;
     for (; i < transformList.length; i++) {
-        if (transformList[i].typ != EnumToken.FunctionTokenType || !transformFunctions.includes(transformList[i].val)) {
+        if (transformList[i].typ != EnumToken.TransformFunctionTokenType ||
+            !transformFunctions.includes(transformList[i].val)) {
             return null;
         }
         switch (transformList[i].val) {
-            case 'translate':
-            case 'translateX':
-            case 'translateY':
-            case 'translateZ':
-            case 'translate3d':
+            case "translate":
+            case "translateX":
+            case "translateY":
+            case "translateZ":
+            case "translate3d":
                 {
                     values.length = 0;
                     const children = stripCommaToken(transformList[i].chi.slice());
-                    const valCount = transformList[i].val == 'translate3d' ? 3 : transformList[i].val == 'translate' ? 2 : 1;
+                    const valCount = transformList[i].val == "translate3d"
+                        ? 3
+                        : transformList[i].val == "translate"
+                            ? 2
+                            : 1;
                     for (let j = 0; j < children.length; j++) {
                         if (children[j].typ == EnumToken.WhitespaceTokenType) {
                             continue;
@@ -83,16 +81,16 @@ function computeMatrix(transformList, matrixVar) {
                     if (values.length == 0 || values.length > valCount) {
                         return null;
                     }
-                    if (transformList[i].val == 'translateX') {
+                    if (transformList[i].val == "translateX") {
                         matrixVar = translateX(values[0], matrixVar);
                     }
-                    else if (transformList[i].val == 'translateY') {
+                    else if (transformList[i].val == "translateY") {
                         matrixVar = translateY(values[0], matrixVar);
                     }
-                    else if (transformList[i].val == 'translateZ') {
+                    else if (transformList[i].val == "translateZ") {
                         matrixVar = translateZ(values[0], matrixVar);
                     }
-                    else if (transformList[i].val == 'translate') {
+                    else if (transformList[i].val == "translate") {
                         matrixVar = translate(values, matrixVar);
                     }
                     else {
@@ -101,43 +99,45 @@ function computeMatrix(transformList, matrixVar) {
                     }
                 }
                 break;
-            case 'rotate':
-            case 'rotateX':
-            case 'rotateY':
-            case 'rotateZ':
-            case 'rotate3d':
+            case "rotate":
+            case "rotateX":
+            case "rotateY":
+            case "rotateZ":
+            case "rotate3d":
                 {
                     let x = 0;
                     let y = 0;
                     let z = 0;
                     let angle;
                     let values = [];
-                    let valuesCount = transformList[i].val == 'rotate3d' ? 4 : 1;
+                    let valuesCount = transformList[i].val == "rotate3d" ? 4 : 1;
                     for (const child of stripCommaToken(transformList[i].chi.slice())) {
                         values.push(child);
-                        if (transformList[i].val == 'rotateX') {
+                        if (transformList[i].val == "rotateX") {
                             x = 1;
                         }
-                        else if (transformList[i].val == 'rotateY') {
+                        else if (transformList[i].val == "rotateY") {
                             y = 1;
                         }
-                        else if (transformList[i].val == 'rotate' || transformList[i].val == 'rotateZ') {
+                        else if (transformList[i].val == "rotate" ||
+                            transformList[i].val == "rotateZ") {
                             z = 1;
                         }
                     }
                     if (values.length != valuesCount) {
                         return null;
                     }
-                    if (transformList[i].val == 'rotate3d') {
+                    if (transformList[i].val == "rotate3d") {
                         x = getNumber(values[0]);
                         y = getNumber(values[1]);
                         z = getNumber(values[2]);
                     }
                     angle = getAngle(values.at(-1));
-                    if ([x, y, z, angle].some(t => typeof t != 'number' || Number.isNaN(+t))) {
+                    if ([x, y, z, angle].some((t) => typeof t != "number" || Number.isNaN(+t))) {
                         return null;
                     }
-                    if (transformList[i].val == 'rotate' || transformList[i].val == 'rotateZ') {
+                    if (transformList[i].val == "rotate" ||
+                        transformList[i].val == "rotateZ") {
                         matrixVar = rotate(angle * 2 * Math.PI, matrixVar);
                     }
                     else {
@@ -145,11 +145,11 @@ function computeMatrix(transformList, matrixVar) {
                     }
                 }
                 break;
-            case 'scale':
-            case 'scaleX':
-            case 'scaleY':
-            case 'scaleZ':
-            case 'scale3d':
+            case "scale":
+            case "scaleX":
+            case "scaleY":
+            case "scaleZ":
+            case "scale3d":
                 {
                     values.length = 0;
                     let child;
@@ -161,14 +161,14 @@ function computeMatrix(transformList, matrixVar) {
                         }
                         values.push(getNumber(child));
                     }
-                    if (transformList[i].val == 'scale3d') {
+                    if (transformList[i].val == "scale3d") {
                         if (values.length != 3) {
                             return null;
                         }
                         matrixVar = scale3d(...values, matrixVar);
                         break;
                     }
-                    if (transformList[i].val == 'scale') {
+                    if (transformList[i].val == "scale") {
                         if (values.length != 1 && values.length != 2) {
                             return null;
                         }
@@ -178,20 +178,20 @@ function computeMatrix(transformList, matrixVar) {
                     if (values.length != 1) {
                         return null;
                     }
-                    else if (transformList[i].val == 'scaleX') {
+                    else if (transformList[i].val == "scaleX") {
                         matrixVar = scaleX(values[0], matrixVar);
                     }
-                    else if (transformList[i].val == 'scaleY') {
+                    else if (transformList[i].val == "scaleY") {
                         matrixVar = scaleY(values[0], matrixVar);
                     }
-                    else if (transformList[i].val == 'scaleZ') {
+                    else if (transformList[i].val == "scaleZ") {
                         matrixVar = scaleZ(values[0], matrixVar);
                     }
                 }
                 break;
-            case 'skew':
-            case 'skewX':
-            case 'skewY':
+            case "skew":
+            case "skewX":
+            case "skewY":
                 {
                     values.length = 0;
                     let child;
@@ -206,18 +206,22 @@ function computeMatrix(transformList, matrixVar) {
                         value = getAngle(child);
                         values.push(value * 2 * Math.PI);
                     }
-                    if (values.length == 0 || (values.length > (transformList[i].val == 'skew' ? 2 : 1))) {
+                    if (values.length == 0 ||
+                        values.length > (transformList[i].val == "skew" ? 2 : 1)) {
                         return null;
                     }
-                    if (transformList[i].val == 'skew') {
+                    if (transformList[i].val == "skew") {
                         matrixVar = skew(values, matrixVar);
                     }
                     else {
-                        matrixVar = transformList[i].val == 'skewX' ? skewX(values[0], matrixVar) : skewY(values[0], matrixVar);
+                        matrixVar =
+                            transformList[i].val == "skewX"
+                                ? skewX(values[0], matrixVar)
+                                : skewY(values[0], matrixVar);
                     }
                 }
                 break;
-            case 'perspective':
+            case "perspective":
                 {
                     const values = [];
                     let child;
@@ -227,7 +231,7 @@ function computeMatrix(transformList, matrixVar) {
                         if (child.typ == EnumToken.CommentTokenType || child.typ == EnumToken.WhitespaceTokenType) {
                             continue;
                         }
-                        if (child.typ == EnumToken.IdenTokenType && child.val == 'none') {
+                        if (child.typ == EnumToken.IdenTokenType && child.val == "none") {
                             values.push(child);
                             continue;
                         }
@@ -243,13 +247,17 @@ function computeMatrix(transformList, matrixVar) {
                     matrixVar = perspective(values[0], matrixVar);
                 }
                 break;
-            case 'matrix3d':
-            case 'matrix':
+            case "matrix3d":
+            case "matrix":
                 {
                     const values = [];
                     let value;
                     for (const token of transformList[i].chi) {
-                        if ([EnumToken.WhitespaceTokenType, EnumToken.CommentTokenType, EnumToken.CommaTokenType].includes(token.typ)) {
+                        if ([
+                            EnumToken.WhitespaceTokenType,
+                            EnumToken.CommentTokenType,
+                            EnumToken.CommaTokenType,
+                        ].includes(token.typ)) {
                             continue;
                         }
                         value = getNumber(token);
@@ -258,7 +266,7 @@ function computeMatrix(transformList, matrixVar) {
                         }
                         values.push(value);
                     }
-                    if (transformList[i].val == 'matrix') {
+                    if (transformList[i].val == "matrix") {
                         if (values.length != 6) {
                             return null;
                         }
@@ -279,19 +287,22 @@ function splitTransformList(transformList) {
     let pattern = null;
     const tokens = [];
     for (let i = 0; i < transformList.length; i++) {
-        if (transformList[i].typ == EnumToken.CommentTokenType || transformList[i].typ == EnumToken.WhitespaceTokenType) {
+        if (transformList[i].typ == EnumToken.CommentTokenType ||
+            transformList[i].typ == EnumToken.WhitespaceTokenType) {
             continue;
         }
-        if (pattern == null || (transformList[i].typ == EnumToken.FunctionTokenType && !transformList[i].val.startsWith(pattern))) {
-            if (transformList[i].typ == EnumToken.FunctionTokenType) {
-                if (transformList[i].val.startsWith('scale')) {
-                    pattern = 'scale';
+        if (pattern == null ||
+            (transformList[i].typ == EnumToken.TransformFunctionTokenType &&
+                !transformList[i].val.startsWith(pattern))) {
+            if (transformList[i].typ == EnumToken.TransformFunctionTokenType) {
+                if (transformList[i].val.startsWith("scale")) {
+                    pattern = "scale";
                 }
-                else if (transformList[i].val.startsWith('rotate')) {
-                    pattern = 'rotate';
+                else if (transformList[i].val.startsWith("rotate")) {
+                    pattern = "rotate";
                 }
-                else if (transformList[i].val.startsWith('translate')) {
-                    pattern = 'translate';
+                else if (transformList[i].val.startsWith("translate")) {
+                    pattern = "translate";
                 }
                 else {
                     pattern = null;
@@ -300,7 +311,9 @@ function splitTransformList(transformList) {
                 continue;
             }
         }
-        if (pattern != null && transformList[i].typ == EnumToken.FunctionTokenType && transformList[i].val.startsWith(pattern)) {
+        if (pattern != null &&
+            transformList[i].typ == EnumToken.TransformFunctionTokenType &&
+            transformList[i].val.startsWith(pattern)) {
             tokens[tokens.length - 1].push(transformList[i]);
             continue;
         }

package/dist/lib/ast/transform/matrix.d.ts

@@ -0,0 +1,22 @@
+import type { FunctionToken, IdentToken, Token } from "../../../@types/index.d.ts";
+import type { Matrix } from "./type.d.ts";
+export declare function parseMatrix(mat: FunctionToken | IdentToken): Matrix | null;
+export declare function matrix(values: [number, number, number, number, number, number] | [
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number
+]): Matrix | null;
+export declare function serialize(matrix: Matrix): Token;

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

@@ -1,18 +1,11 @@
-import { is2DMatrix, identity } from './utils.js';
+import { identity, is2DMatrix } from './utils.js';
 import { EnumToken } from '../types.js';
 import { eq } from '../../parser/utils/eq.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) {
-        return mat.val == 'none' ? identity() : null;
+        return mat.val == "none" ? identity() : null;
     }
     const children = mat.chi.filter((t) => t.typ == EnumToken.NumberTokenType || t.typ == EnumToken.IdenTokenType);
     const values = [];
@@ -66,46 +59,39 @@ function serialize(matrix) {
     if (eq(matrix, identity())) {
         return {
             typ: EnumToken.IdenTokenType,
-            val: 'none'
+            val: "none",
         };
     }
     if (is2DMatrix(matrix)) {
         // https://drafts.csswg.org/css-transforms-2/#two-dimensional-subset
         return {
-            typ: EnumToken.FunctionTokenType,
-            val: 'matrix',
-            chi: [
-                matrix[0],
-                matrix[1],
-                matrix[4],
-                matrix[4 + 1],
-                matrix[3 * 4],
-                matrix[3 * 4 + 1]
-            ].reduce((acc, t) => {
+            typ: EnumToken.TransformFunctionTokenType,
+            val: "matrix",
+            chi: [matrix[0], matrix[1], matrix[4], matrix[4 + 1], matrix[3 * 4], matrix[3 * 4 + 1]].reduce((acc, t) => {
                 if (acc.length > 0) {
                     acc.push({ typ: EnumToken.CommaTokenType });
                 }
                 acc.push({
                     typ: EnumToken.NumberTokenType,
-                    val: t
+                    val: t,
                 });
                 return acc;
-            }, [])
+            }, []),
         };
     }
     return {
-        typ: EnumToken.FunctionTokenType,
-        val: 'matrix3d',
+        typ: EnumToken.TransformFunctionTokenType,
+        val: "matrix3d",
         chi: matrix.reduce((acc, curr) => {
             if (acc.length > 0) {
                 acc.push({ typ: EnumToken.CommaTokenType });
             }
             acc.push({
                 typ: EnumToken.NumberTokenType,
-                val: curr
+                val: curr,
             });
             return acc;
-        }, [])
+        }, []),
     };
 }
 

package/dist/lib/ast/transform/minify.d.ts

@@ -0,0 +1,5 @@
+import type { FunctionToken, Token } from "../../../@types/index.d.ts";
+import type { Matrix } from "./type.d.ts";
+export declare function minify(matrix: Matrix): Token[] | null;
+export declare function eqMatrix(a: FunctionToken | Matrix, b: Token[]): boolean;
+export declare function minifyTransformFunctions(transform: FunctionToken): FunctionToken;

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

@@ -1,4 +1,4 @@
-import { multiply, identity, epsilon, decompose, round, toZero } from './utils.js';
+import { multiply, epsilon, decompose, round, toZero, identity } from './utils.js';
 import { EnumToken } from '../types.js';
 import { computeMatrix } from './compute.js';
 import { parseMatrix } from './matrix.js';
@@ -39,7 +39,7 @@ function minify(matrix) {
         if (coordinates.size == 1) {
             if (coordinates.has('x')) {
                 result.push({
-                    typ: EnumToken.FunctionTokenType,
+                    typ: EnumToken.TransformFunctionTokenType,
                     val: 'translate',
                     chi: [{ typ: EnumToken.LengthTokenType, val: round(decomposed.translate[0]), unit: 'px' }]
                 });
@@ -48,7 +48,7 @@ function minify(matrix) {
                 let axis = coordinates.has('y') ? 'y' : 'z';
                 let index = axis == 'y' ? 1 : 2;
                 result.push({
-                    typ: EnumToken.FunctionTokenType,
+                    typ: EnumToken.TransformFunctionTokenType,
                     val: 'translate' + axis.toUpperCase(),
                     chi: [{ typ: EnumToken.LengthTokenType, val: round(decomposed.translate[index]), unit: 'px' }]
                 });
@@ -56,7 +56,7 @@ function minify(matrix) {
         }
         else if (coordinates.has('z')) {
             result.push({
-                typ: EnumToken.FunctionTokenType,
+                typ: EnumToken.TransformFunctionTokenType,
                 val: 'translate3d',
                 chi: [
                     decomposed.translate[0] == 0 ? {
@@ -75,7 +75,7 @@ function minify(matrix) {
         }
         else {
             result.push({
-                typ: EnumToken.FunctionTokenType,
+                typ: EnumToken.TransformFunctionTokenType,
                 val: 'translate',
                 chi: [
                     { typ: EnumToken.LengthTokenType, val: round(decomposed.translate[0]), unit: 'px' },
@@ -89,7 +89,7 @@ function minify(matrix) {
         const [x, y, z, angle] = decomposed.rotate;
         if (y == 0 && z == 0) {
             result.push({
-                typ: EnumToken.FunctionTokenType,
+                typ: EnumToken.TransformFunctionTokenType,
                 val: 'rotateX',
                 chi: [
                     {
@@ -102,7 +102,7 @@ function minify(matrix) {
         }
         else if (x == 0 && z == 0) {
             result.push({
-                typ: EnumToken.FunctionTokenType,
+                typ: EnumToken.TransformFunctionTokenType,
                 val: 'rotateY',
                 chi: [
                     {
@@ -115,7 +115,7 @@ function minify(matrix) {
         }
         else if (x == 0 && y == 0) {
             result.push({
-                typ: EnumToken.FunctionTokenType,
+                typ: EnumToken.TransformFunctionTokenType,
                 val: 'rotate',
                 chi: [
                     {
@@ -128,7 +128,7 @@ function minify(matrix) {
         }
         else {
             result.push({
-                typ: EnumToken.FunctionTokenType,
+                typ: EnumToken.TransformFunctionTokenType,
                 val: 'rotate3d',
                 chi: [
                     {
@@ -164,7 +164,7 @@ function minify(matrix) {
         }
         if (skew.size == 1) {
             result.push({
-                typ: EnumToken.FunctionTokenType,
+                typ: EnumToken.TransformFunctionTokenType,
                 val: 'skew' + (skew.has('x') ? '' : 'Y'),
                 chi: [
                     { typ: EnumToken.AngleTokenType, val: round(decomposed.skew[0]), unit: 'deg' }
@@ -173,7 +173,7 @@ function minify(matrix) {
         }
         else {
             result.push({
-                typ: EnumToken.FunctionTokenType,
+                typ: EnumToken.TransformFunctionTokenType,
                 val: 'skew',
                 chi: [
                     { typ: EnumToken.AngleTokenType, val: round(decomposed.skew[0]), unit: 'deg' },
@@ -197,7 +197,7 @@ function minify(matrix) {
         if (scales.size == 1) {
             let prefix = scales.has('x') ? 'X' : scales.has('y') ? 'Y' : 'Z';
             result.push({
-                typ: EnumToken.FunctionTokenType,
+                typ: EnumToken.TransformFunctionTokenType,
                 val: 'scale' + prefix,
                 chi: [
                     { typ: EnumToken.NumberTokenType, val: round(prefix == 'Z' ? sz : prefix == 'Y' ? sy : sx) }
@@ -206,7 +206,7 @@ function minify(matrix) {
         }
         else if (!scales.has('z')) {
             result.push({
-                typ: EnumToken.FunctionTokenType,
+                typ: EnumToken.TransformFunctionTokenType,
                 val: 'scale',
                 chi: [
                     { typ: EnumToken.NumberTokenType, val: round(sx) },
@@ -217,7 +217,7 @@ function minify(matrix) {
         }
         else {
             result.push({
-                typ: EnumToken.FunctionTokenType,
+                typ: EnumToken.TransformFunctionTokenType,
                 val: 'scale3d',
                 chi: [
                     { typ: EnumToken.NumberTokenType, val: round(sx) },
@@ -296,7 +296,7 @@ function minifyTransformFunctions(transform) {
     if (name == 'translate3d' || name == 'translate') {
         if (t.size == 0) {
             return {
-                typ: EnumToken.FunctionTokenType,
+                typ: EnumToken.TransformFunctionTokenType,
                 val: 'translate',
                 chi: [
                     { typ: EnumToken.NumberTokenType, val: 0 }
@@ -305,7 +305,7 @@ function minifyTransformFunctions(transform) {
         }
         if (t.size == 1) {
             return {
-                typ: EnumToken.FunctionTokenType,
+                typ: EnumToken.TransformFunctionTokenType,
                 val: 'translate' + (t.has('x') ? '' : t.has('y') ? 'Y' : 'Z'),
                 chi: [
                     values[t.has('x') ? 0 : t.has('y') ? 1 : 2]
@@ -317,7 +317,7 @@ function minifyTransformFunctions(transform) {
                 return transform;
             }
             return {
-                typ: EnumToken.FunctionTokenType,
+                typ: EnumToken.TransformFunctionTokenType,
                 val: 'translate',
                 chi: [
                     values[0],
@@ -330,7 +330,7 @@ function minifyTransformFunctions(transform) {
     if (name == 'scale3d' || name == 'scale') {
         if (t.size == 0) {
             return {
-                typ: EnumToken.FunctionTokenType,
+                typ: EnumToken.TransformFunctionTokenType,
                 val: 'scale',
                 chi: [
                     { typ: EnumToken.NumberTokenType, val: 1 }
@@ -339,7 +339,7 @@ function minifyTransformFunctions(transform) {
         }
         if (t.size == 1) {
             return {
-                typ: EnumToken.FunctionTokenType,
+                typ: EnumToken.TransformFunctionTokenType,
                 val: 'scale' + (t.has('x') ? 'X' : t.has('y') ? 'Y' : 'Z'),
                 chi: [
                     values[t.has('x') ? 0 : t.has('y') ? 1 : 2]
@@ -351,7 +351,7 @@ function minifyTransformFunctions(transform) {
                 return transform;
             }
             return {
-                typ: EnumToken.FunctionTokenType,
+                typ: EnumToken.TransformFunctionTokenType,
                 val: 'scale',
                 chi: [
                     values[0],

package/dist/lib/ast/transform/perspective.d.ts

@@ -0,0 +1,3 @@
+import type { IdentToken } from "../../../@types/index.d.ts";
+import type { Matrix } from "./type.d.ts";
+export declare function perspective(x: number | IdentToken, from: Matrix): Matrix;

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

@@ -1,4 +1,4 @@
-import { identity, multiply } from './utils.js';
+import { multiply, identity } from './utils.js';
 
 function perspective(x, from) {
     const matrix = identity();

package/dist/lib/ast/transform/rotate.d.ts

@@ -0,0 +1,12 @@
+import type { Matrix } from "./type.d.ts";
+/**
+ * angle in radian
+ * @param angle
+ * @param x
+ * @param y
+ * @param z
+ * @param from
+ */
+export declare function rotate3D(angle: number, x: number, y: number, z: number, from: Matrix): Matrix;
+export declare function rotate(angle: number, from: Matrix): Matrix;
+export declare const rotateZ: typeof rotate;

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

@@ -1,4 +1,4 @@
-import { identity, multiply } from './utils.js';
+import { multiply, identity } from './utils.js';
 
 /**
  * angle in radian

package/dist/lib/ast/transform/scale.d.ts

@@ -0,0 +1,6 @@
+import type { Matrix } from "./type.d.ts";
+export declare function scaleX(x: number, from: Matrix): Matrix;
+export declare function scaleY(y: number, from: Matrix): Matrix;
+export declare function scaleZ(z: number, from: Matrix): Matrix;
+export declare function scale(x: number, y: number, from: Matrix): Matrix;
+export declare function scale3d(x: number, y: number, z: number, from: Matrix): Matrix;