@js-draw/math 1.2.2 → 1.3.1

package/dist/cjs/Color4.d.ts

@@ -12,7 +12,7 @@ import Vec3 from './Vec3';
  * console.log('To string:', Color4.orange.toHexString());
  * ```
  */
-export default class Color4 {
+export declare class Color4 {
     /** Red component. Should be in the range [0, 1]. */
     readonly r: number;
     /** Green component. ${\tt g} \in [0, 1]$ */
@@ -120,4 +120,4 @@ export default class Color4 {
     static gray: Color4;
     static white: Color4;
 }
-export { Color4 };
+export default Color4;

package/dist/cjs/Mat33.d.ts

@@ -107,15 +107,45 @@ export declare class Mat33 {
     mapEntries(mapping: (component: number, rowcol: [number, number]) => number): Mat33;
     /** Estimate the scale factor of this matrix (based on the first row). */
     getScaleFactor(): number;
+    /** Returns the `idx`-th column (`idx` is 0-indexed). */
+    getColumn(idx: number): Vec3;
+    /** Returns the magnitude of the entry with the largest entry */
+    maximumEntryMagnitude(): number;
     /**
      * Constructs a 3x3 translation matrix (for translating `Vec2`s) using
      * **transformVec2**.
+     *
+     * Creates a matrix in the form
+     * $$
+     * 	\begin{pmatrix}
+     * 		1 & 0 & {\tt amount.x}\\
+     * 		0 & 1 & {\tt amount.y}\\
+     * 		0 & 0 & 1
+     * 	\end{pmatrix}
+     * $$
      */
     static translation(amount: Vec2): Mat33;
     static zRotation(radians: number, center?: Point2): Mat33;
     static scaling2D(amount: number | Vec2, center?: Point2): Mat33;
-    /** @see {@link fromCSSMatrix} */
+    /**
+     * **Note**: Assumes `this.c1 = this.c2 = 0` and `this.c3 = 1`.
+     *
+     * @see {@link fromCSSMatrix} and {@link toSafeCSSTransformList}
+     */
     toCSSMatrix(): string;
+    /**
+     * @beta May change or even be removed between minor releases.
+     *
+     * Converts this matrix into a list of CSS transforms that attempt to preserve
+     * this matrix's translation.
+     *
+     * In Chrome/Firefox, translation attributes only support 6 digits (likely an artifact
+     * of using lower-precision floating point numbers). This works around
+     * that by expanding this matrix into the product of several CSS transforms.
+     *
+     * **Note**: Assumes `this.c1 = this.c2 = 0` and `this.c3 = 1`.
+     */
+    toSafeCSSTransformList(): string;
     /**
      * Converts a CSS-form `matrix(a, b, c, d, e, f)` to a Mat33.
      *

package/dist/cjs/Mat33.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Mat33 = void 0;
 const Vec2_1 = require("./Vec2");
 const Vec3_1 = __importDefault(require("./Vec3"));
+const rounding_1 = require("./rounding");
 /**
  * Represents a three dimensional linear transformation or
  * a two-dimensional affine transformation. (An affine transformation scales/rotates/shears
@@ -259,9 +260,30 @@ class Mat33 {
     getScaleFactor() {
         return Math.hypot(this.a1, this.a2);
     }
+    /** Returns the `idx`-th column (`idx` is 0-indexed). */
+    getColumn(idx) {
+        return Vec3_1.default.of(this.rows[0].at(idx), this.rows[1].at(idx), this.rows[2].at(idx));
+    }
+    /** Returns the magnitude of the entry with the largest entry */
+    maximumEntryMagnitude() {
+        let greatestSoFar = Math.abs(this.a1);
+        for (const entry of this.toArray()) {
+            greatestSoFar = Math.max(greatestSoFar, Math.abs(entry));
+        }
+        return greatestSoFar;
+    }
     /**
      * Constructs a 3x3 translation matrix (for translating `Vec2`s) using
      * **transformVec2**.
+     *
+     * Creates a matrix in the form
+     * $$
+     * 	\begin{pmatrix}
+     * 		1 & 0 & {\tt amount.x}\\
+     * 		0 & 1 & {\tt amount.y}\\
+     * 		0 & 0 & 1
+     * 	\end{pmatrix}
+     * $$
      */
     static translation(amount) {
         // When transforming Vec2s by a 3x3 matrix, we give the input
@@ -296,10 +318,131 @@ class Mat33 {
         // Translate such that [center] goes to (0, 0)
         return result.rightMul(Mat33.translation(center.times(-1)));
     }
-    /** @see {@link fromCSSMatrix} */
+    /**
+     * **Note**: Assumes `this.c1 = this.c2 = 0` and `this.c3 = 1`.
+     *
+     * @see {@link fromCSSMatrix} and {@link toSafeCSSTransformList}
+     */
     toCSSMatrix() {
         return `matrix(${this.a1},${this.b1},${this.a2},${this.b2},${this.a3},${this.b3})`;
     }
+    /**
+     * @beta May change or even be removed between minor releases.
+     *
+     * Converts this matrix into a list of CSS transforms that attempt to preserve
+     * this matrix's translation.
+     *
+     * In Chrome/Firefox, translation attributes only support 6 digits (likely an artifact
+     * of using lower-precision floating point numbers). This works around
+     * that by expanding this matrix into the product of several CSS transforms.
+     *
+     * **Note**: Assumes `this.c1 = this.c2 = 0` and `this.c3 = 1`.
+     */
+    toSafeCSSTransformList() {
+        // Check whether it's safe to return just the CSS matrix
+        const translation = Vec2_1.Vec2.of(this.a3, this.b3);
+        const translationRoundedX = (0, rounding_1.toRoundedString)(translation.x);
+        const translationRoundedY = (0, rounding_1.toRoundedString)(translation.y);
+        const nonDigitsRegex = /[^0-9]+/g;
+        const translationXDigits = translationRoundedX.replace(nonDigitsRegex, '').length;
+        const translationYDigits = translationRoundedY.replace(nonDigitsRegex, '').length;
+        // Is it safe to just return the default CSS matrix?
+        if (translationXDigits <= 5 && translationYDigits <= 5) {
+            return this.toCSSMatrix();
+        }
+        // Remove the last column (the translation column)
+        let transform = new Mat33(this.a1, this.a2, 0, this.b1, this.b2, 0, 0, 0, 1);
+        const transforms = [];
+        let lastScale = null;
+        // Appends a translate() command to the list of `transforms`.
+        const addTranslate = (translation) => {
+            lastScale = null;
+            if (!translation.eq(Vec2_1.Vec2.zero)) {
+                transforms.push(`translate(${(0, rounding_1.toRoundedString)(translation.x)}px, ${(0, rounding_1.toRoundedString)(translation.y)}px)`);
+            }
+        };
+        // Appends a scale() command to the list of transforms, possibly merging with
+        // the last command, if a scale().
+        const addScale = (scale) => {
+            // Merge with the last scale
+            if (lastScale) {
+                const newScale = lastScale.scale(scale);
+                // Don't merge if the new scale has very large values
+                if (newScale.maximumEntryMagnitude() < 1e7) {
+                    const previousCommand = transforms.pop();
+                    console.assert(previousCommand.startsWith('scale'), 'Invalid state: Merging scale commands');
+                    scale = newScale;
+                }
+            }
+            if (scale.x === scale.y) {
+                transforms.push(`scale(${(0, rounding_1.toRoundedString)(scale.x)})`);
+            }
+            else {
+                transforms.push(`scale(${(0, rounding_1.toRoundedString)(scale.x)}, ${(0, rounding_1.toRoundedString)(scale.y)})`);
+            }
+            lastScale = scale;
+        };
+        // Returns the number of digits before the `.` in the given number string.
+        const digitsPreDecimalCount = (numberString) => {
+            let decimalIndex = numberString.indexOf('.');
+            if (decimalIndex === -1) {
+                decimalIndex = numberString.length;
+            }
+            return numberString.substring(0, decimalIndex).replace(nonDigitsRegex, '').length;
+        };
+        // Returns the number of digits (positive for left shift, negative for right shift)
+        // required to shift the decimal to the middle of the number.
+        const getShift = (numberString) => {
+            const preDecimal = digitsPreDecimalCount(numberString);
+            const postDecimal = (numberString.match(/[.](\d*)/) ?? ['', ''])[1].length;
+            // The shift required to center the decimal point.
+            const toCenter = postDecimal - preDecimal;
+            // toCenter is positive for a left shift (adding more pre-decimals),
+            // so, after applying it,
+            const postShiftPreDecimal = preDecimal + toCenter;
+            // We want the digits before the decimal to have a length at most 4, however.
+            // Thus, right shift until this is the case.
+            const shiftForAtMost5DigitsPreDecimal = 4 - Math.max(postShiftPreDecimal, 4);
+            return toCenter + shiftForAtMost5DigitsPreDecimal;
+        };
+        const addShiftedTranslate = (translate, depth = 0) => {
+            const xString = (0, rounding_1.toRoundedString)(translate.x);
+            const yString = (0, rounding_1.toRoundedString)(translate.y);
+            const xShiftDigits = getShift(xString);
+            const yShiftDigits = getShift(yString);
+            const shift = Vec2_1.Vec2.of(Math.pow(10, xShiftDigits), Math.pow(10, yShiftDigits));
+            const invShift = Vec2_1.Vec2.of(Math.pow(10, -xShiftDigits), Math.pow(10, -yShiftDigits));
+            addScale(invShift);
+            const shiftedTranslate = translate.scale(shift);
+            const roundedShiftedTranslate = Vec2_1.Vec2.of(Math.floor(shiftedTranslate.x), Math.floor(shiftedTranslate.y));
+            addTranslate(roundedShiftedTranslate);
+            // Don't recurse more than 3 times -- the more times we recurse, the more
+            // the scaling is influenced by error.
+            if (!roundedShiftedTranslate.eq(shiftedTranslate) && depth < 3) {
+                addShiftedTranslate(shiftedTranslate.minus(roundedShiftedTranslate), depth + 1);
+            }
+            addScale(shift);
+            return translate;
+        };
+        const adjustTransformFromScale = () => {
+            if (lastScale) {
+                const scaledTransform = transform.rightMul(Mat33.scaling2D(lastScale));
+                // If adding the scale to the transform leads to large values, avoid
+                // doing this.
+                if (scaledTransform.maximumEntryMagnitude() < 1e12) {
+                    transforms.pop();
+                    transform = transform.rightMul(Mat33.scaling2D(lastScale));
+                    lastScale = null;
+                }
+            }
+        };
+        addShiftedTranslate(translation);
+        adjustTransformFromScale();
+        if (!transform.eq(Mat33.identity)) {
+            transforms.push(transform.toCSSMatrix());
+        }
+        return transforms.join(' ');
+    }
     /**
      * Converts a CSS-form `matrix(a, b, c, d, e, f)` to a Mat33.
      *
@@ -314,30 +457,95 @@ class Mat33 {
         if (cssString === '' || cssString === 'none') {
             return Mat33.identity;
         }
-        const numberExp = '([-]?\\d*(?:\\.\\d*)?(?:[eE][-]?\\d+)?)';
-        const numberSepExp = '[, \\t\\n]';
-        const regExpSource = `^\\s*matrix\\s*\\(${[
-            // According to MDN, matrix(a,b,c,d,e,f) has form:
-            // 		⎡ a c e ⎤
-            // 		⎢ b d f ⎥
-            // 		⎣ 0 0 1 ⎦
-            numberExp, numberExp, numberExp,
-            numberExp, numberExp, numberExp, // b, d, f
-        ].join(`${numberSepExp}+`)}${numberSepExp}*\\)\\s*$`;
-        const matrixExp = new RegExp(regExpSource, 'i');
-        const match = matrixExp.exec(cssString);
-        if (!match) {
-            throw new Error(`Unsupported transformation: ${cssString}`);
+        const parseArguments = (argumentString) => {
+            return argumentString.split(/[, \t\n]+/g).map(argString => {
+                let isPercentage = false;
+                if (argString.endsWith('%')) {
+                    isPercentage = true;
+                    argString = argString.substring(0, argString.length - 1);
+                }
+                // Remove trailing px units.
+                argString = argString.replace(/px$/ig, '');
+                const numberExp = /^[-]?\d*(?:\.\d*)?(?:[eE][-+]?\d+)?$/i;
+                if (!numberExp.exec(argString)) {
+                    throw new Error(`All arguments to transform functions must be numeric (state: ${JSON.stringify({
+                        currentArgument: argString,
+                        allArguments: argumentString,
+                    })})`);
+                }
+                let argNumber = parseFloat(argString);
+                if (isPercentage) {
+                    argNumber /= 100;
+                }
+                return argNumber;
+            });
+        };
+        const keywordToAction = {
+            matrix: (matrixData) => {
+                if (matrixData.length !== 6) {
+                    throw new Error(`Invalid matrix argument: ${matrixData}. Must have length 6`);
+                }
+                const a = matrixData[0];
+                const b = matrixData[1];
+                const c = matrixData[2];
+                const d = matrixData[3];
+                const e = matrixData[4];
+                const f = matrixData[5];
+                const transform = new Mat33(a, c, e, b, d, f, 0, 0, 1);
+                return transform;
+            },
+            scale: (scaleArgs) => {
+                let scaleX, scaleY;
+                if (scaleArgs.length === 1) {
+                    scaleX = scaleArgs[0];
+                    scaleY = scaleArgs[0];
+                }
+                else if (scaleArgs.length === 2) {
+                    scaleX = scaleArgs[0];
+                    scaleY = scaleArgs[1];
+                }
+                else {
+                    throw new Error(`The scale() function only supports two arguments. Given: ${scaleArgs}`);
+                }
+                return Mat33.scaling2D(Vec2_1.Vec2.of(scaleX, scaleY));
+            },
+            translate: (translateArgs) => {
+                let translateX = 0;
+                let translateY = 0;
+                if (translateArgs.length === 1) {
+                    // If no y translation is given, assume 0.
+                    translateX = translateArgs[0];
+                }
+                else if (translateArgs.length === 2) {
+                    translateX = translateArgs[0];
+                    translateY = translateArgs[1];
+                }
+                else {
+                    throw new Error(`The translate() function requires either 1 or 2 arguments. Given ${translateArgs}`);
+                }
+                return Mat33.translation(Vec2_1.Vec2.of(translateX, translateY));
+            },
+        };
+        // A command (\w+)
+        // followed by a set of arguments ([ \t\n0-9eE.,\-%]+)
+        const partRegex = /\s*(\w+)\s*\(([^)]*)\)/ig;
+        let match;
+        let matrix = null;
+        while ((match = partRegex.exec(cssString)) !== null) {
+            const action = match[1].toLowerCase();
+            if (!(action in keywordToAction)) {
+                throw new Error(`Unsupported CSS transform action: ${action}`);
+            }
+            const args = parseArguments(match[2]);
+            const currentMatrix = keywordToAction[action](args);
+            if (!matrix) {
+                matrix = currentMatrix;
+            }
+            else {
+                matrix = matrix.rightMul(currentMatrix);
+            }
         }
-        const matrixData = match.slice(1).map(entry => parseFloat(entry));
-        const a = matrixData[0];
-        const b = matrixData[1];
-        const c = matrixData[2];
-        const d = matrixData[3];
-        const e = matrixData[4];
-        const f = matrixData[5];
-        const transform = new Mat33(a, c, e, b, d, f, 0, 0, 1);
-        return transform;
+        return matrix ?? Mat33.identity;
     }
 }
 exports.Mat33 = Mat33;

package/dist/cjs/Vec3.d.ts

@@ -35,6 +35,13 @@ export declare class Vec3 {
     length(): number;
     magnitude(): number;
     magnitudeSquared(): number;
+    /**
+     * Returns the entry of this with the greatest magnitude.
+     *
+     * In other words, returns $\max \{ |x| : x \in {\bf v} \}$, where ${\bf v}$ is the set of
+     * all entries of this vector.
+     */
+    maximumEntryMagnitude(): number;
     /**
      * Return this' angle in the XY plane (treats this as a Vec2).
      *

package/dist/cjs/Vec3.js

@@ -58,6 +58,15 @@ class Vec3 {
     magnitudeSquared() {
         return this.dot(this);
     }
+    /**
+     * Returns the entry of this with the greatest magnitude.
+     *
+     * In other words, returns $\max \{ |x| : x \in {\bf v} \}$, where ${\bf v}$ is the set of
+     * all entries of this vector.
+     */
+    maximumEntryMagnitude() {
+        return Math.max(Math.abs(this.x), Math.max(Math.abs(this.y), Math.abs(this.z)));
+    }
     /**
      * Return this' angle in the XY plane (treats this as a Vec2).
      *

package/dist/cjs/shapes/Path.d.ts

@@ -53,6 +53,13 @@ export declare class Path {
     getExactBBox(): Rect2;
     private cachedGeometry;
     get geometry(): GeometryArrayType;
+    /**
+     * Iterates through the start/end points of each component in this path.
+     *
+     * If a start point is equivalent to the end point of the previous segment,
+     * the point is **not** emitted twice.
+     */
+    startEndPoints(): Generator<import("../Vec3").Vec3, undefined, unknown>;
     private cachedPolylineApproximation;
     polylineApproximation(): LineSegment2[];
     static computeBBoxForSegment(startPoint: Point2, part: PathCommand): Rect2;

package/dist/cjs/shapes/Path.js

@@ -51,6 +51,7 @@ class Path {
         let startPoint = this.startPoint;
         const geometry = [];
         for (const part of this.parts) {
+            let exhaustivenessCheck;
             switch (part.kind) {
                 case PathCommandType.CubicBezierTo:
                     geometry.push(new CubicBezier_1.default(startPoint, part.controlPoint1, part.controlPoint2, part.endPoint));
@@ -68,11 +69,43 @@ class Path {
                     geometry.push(new PointShape2D_1.default(part.point));
                     startPoint = part.point;
                     break;
+                default:
+                    exhaustivenessCheck = part;
+                    return exhaustivenessCheck;
             }
         }
         this.cachedGeometry = geometry;
         return this.cachedGeometry;
     }
+    /**
+     * Iterates through the start/end points of each component in this path.
+     *
+     * If a start point is equivalent to the end point of the previous segment,
+     * the point is **not** emitted twice.
+     */
+    *startEndPoints() {
+        yield this.startPoint;
+        for (const part of this.parts) {
+            let exhaustivenessCheck;
+            switch (part.kind) {
+                case PathCommandType.CubicBezierTo:
+                    yield part.endPoint;
+                    break;
+                case PathCommandType.QuadraticBezierTo:
+                    yield part.endPoint;
+                    break;
+                case PathCommandType.LineTo:
+                    yield part.point;
+                    break;
+                case PathCommandType.MoveTo:
+                    yield part.point;
+                    break;
+                default:
+                    exhaustivenessCheck = part;
+                    return exhaustivenessCheck;
+            }
+        }
+    }
     // Approximates this path with a group of line segments.
     polylineApproximation() {
         if (this.cachedPolylineApproximation) {

package/dist/cjs/shapes/Rect2.d.ts

@@ -19,7 +19,6 @@ export declare class Rect2 extends Abstract2DShape {
     readonly h: number;
     readonly topLeft: Point2;
     readonly size: Vec2;
-    readonly bottomRight: Point2;
     readonly area: number;
     constructor(x: number, y: number, w: number, h: number);
     translatedBy(vec: Vec2): Rect2;
@@ -35,6 +34,7 @@ export declare class Rect2 extends Abstract2DShape {
     getClosestPointOnBoundaryTo(target: Point2): Vec3;
     get corners(): Point2[];
     get maxDimension(): number;
+    get bottomRight(): Vec3;
     get topRight(): Vec3;
     get bottomLeft(): Vec3;
     get width(): number;

package/dist/cjs/shapes/Rect2.js

@@ -26,7 +26,6 @@ class Rect2 extends Abstract2DShape_1.default {
         // Precompute/store vector forms.
         this.topLeft = Vec2_1.Vec2.of(this.x, this.y);
         this.size = Vec2_1.Vec2.of(this.w, this.h);
-        this.bottomRight = this.topLeft.plus(this.size);
         this.area = this.w * this.h;
     }
     translatedBy(vec) {
@@ -42,8 +41,8 @@ class Rect2 extends Abstract2DShape_1.default {
     }
     containsRect(other) {
         return this.x <= other.x && this.y <= other.y
-            && this.bottomRight.x >= other.bottomRight.x
-            && this.bottomRight.y >= other.bottomRight.y;
+            && this.x + this.w >= other.x + other.w
+            && this.y + this.h >= other.y + other.h;
     }
     intersects(other) {
         // Project along x/y axes.
@@ -116,6 +115,12 @@ class Rect2 extends Abstract2DShape_1.default {
         if (margin === 0) {
             return this;
         }
+        // Prevent width/height from being negative
+        if (margin < 0) {
+            const xMargin = -Math.min(-margin, this.w / 2);
+            const yMargin = -Math.min(-margin, this.h / 2);
+            return new Rect2(this.x - xMargin, this.y - yMargin, this.w + xMargin * 2, this.h + yMargin * 2);
+        }
         return new Rect2(this.x - margin, this.y - margin, this.w + margin * 2, this.h + margin * 2);
     }
     getClosestPointOnBoundaryTo(target) {
@@ -144,6 +149,9 @@ class Rect2 extends Abstract2DShape_1.default {
     get maxDimension() {
         return Math.max(this.w, this.h);
     }
+    get bottomRight() {
+        return this.topLeft.plus(this.size);
+    }
     get topRight() {
         return this.bottomRight.plus(Vec2_1.Vec2.of(0, -this.h));
     }
@@ -234,16 +242,16 @@ class Rect2 extends Abstract2DShape_1.default {
             return Rect2.empty;
         }
         const firstRect = rects[0];
-        let minX = firstRect.topLeft.x;
-        let minY = firstRect.topLeft.y;
-        let maxX = firstRect.bottomRight.x;
-        let maxY = firstRect.bottomRight.y;
+        let minX = firstRect.x;
+        let minY = firstRect.y;
+        let maxX = firstRect.x + firstRect.w;
+        let maxY = firstRect.y + firstRect.h;
         for (let i = 1; i < rects.length; i++) {
             const rect = rects[i];
-            minX = Math.min(minX, rect.topLeft.x);
-            minY = Math.min(minY, rect.topLeft.y);
-            maxX = Math.max(maxX, rect.bottomRight.x);
-            maxY = Math.max(maxY, rect.bottomRight.y);
+            minX = Math.min(minX, rect.x);
+            minY = Math.min(minY, rect.y);
+            maxX = Math.max(maxX, rect.x + rect.w);
+            maxY = Math.max(maxY, rect.y + rect.h);
         }
         return new Rect2(minX, minY, maxX - minX, maxY - minY);
     }

package/dist/mjs/Color4.d.ts

@@ -12,7 +12,7 @@ import Vec3 from './Vec3';
  * console.log('To string:', Color4.orange.toHexString());
  * ```
  */
-export default class Color4 {
+export declare class Color4 {
     /** Red component. Should be in the range [0, 1]. */
     readonly r: number;
     /** Green component. ${\tt g} \in [0, 1]$ */
@@ -120,4 +120,4 @@ export default class Color4 {
     static gray: Color4;
     static white: Color4;
 }
-export { Color4 };
+export default Color4;

package/dist/mjs/Color4.mjs

@@ -12,7 +12,7 @@ import  Vec3  from './Vec3.mjs';
  * console.log('To string:', Color4.orange.toHexString());
  * ```
  */
-class Color4 {
+export class Color4 {
     constructor(
     /** Red component. Should be in the range [0, 1]. */
     r, 
@@ -377,4 +377,3 @@ Color4.black = Color4.ofRGB(0, 0, 0);
 Color4.gray = Color4.ofRGB(0.5, 0.5, 0.5);
 Color4.white = Color4.ofRGB(1, 1, 1);
 export default Color4;
-export { Color4 };

package/dist/mjs/Mat33.d.ts

@@ -107,15 +107,45 @@ export declare class Mat33 {
     mapEntries(mapping: (component: number, rowcol: [number, number]) => number): Mat33;
     /** Estimate the scale factor of this matrix (based on the first row). */
     getScaleFactor(): number;
+    /** Returns the `idx`-th column (`idx` is 0-indexed). */
+    getColumn(idx: number): Vec3;
+    /** Returns the magnitude of the entry with the largest entry */
+    maximumEntryMagnitude(): number;
     /**
      * Constructs a 3x3 translation matrix (for translating `Vec2`s) using
      * **transformVec2**.
+     *
+     * Creates a matrix in the form
+     * $$
+     * 	\begin{pmatrix}
+     * 		1 & 0 & {\tt amount.x}\\
+     * 		0 & 1 & {\tt amount.y}\\
+     * 		0 & 0 & 1
+     * 	\end{pmatrix}
+     * $$
      */
     static translation(amount: Vec2): Mat33;
     static zRotation(radians: number, center?: Point2): Mat33;
     static scaling2D(amount: number | Vec2, center?: Point2): Mat33;
-    /** @see {@link fromCSSMatrix} */
+    /**
+     * **Note**: Assumes `this.c1 = this.c2 = 0` and `this.c3 = 1`.
+     *
+     * @see {@link fromCSSMatrix} and {@link toSafeCSSTransformList}
+     */
     toCSSMatrix(): string;
+    /**
+     * @beta May change or even be removed between minor releases.
+     *
+     * Converts this matrix into a list of CSS transforms that attempt to preserve
+     * this matrix's translation.
+     *
+     * In Chrome/Firefox, translation attributes only support 6 digits (likely an artifact
+     * of using lower-precision floating point numbers). This works around
+     * that by expanding this matrix into the product of several CSS transforms.
+     *
+     * **Note**: Assumes `this.c1 = this.c2 = 0` and `this.c3 = 1`.
+     */
+    toSafeCSSTransformList(): string;
     /**
      * Converts a CSS-form `matrix(a, b, c, d, e, f)` to a Mat33.
      *