@js-draw/math 1.3.0 → 1.4.0

package/dist/cjs/Mat33.d.ts

@@ -107,14 +107,31 @@ 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;
     /**
      * Converts a CSS-form `matrix(a, b, c, d, e, f)` to a Mat33.

package/dist/cjs/Mat33.fromCSSMatrix.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cjs/Mat33.js

@@ -259,9 +259,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,7 +317,11 @@ 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})`;
     }
@@ -314,30 +339,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/mjs/Mat33.d.ts

@@ -107,14 +107,31 @@ 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;
     /**
      * Converts a CSS-form `matrix(a, b, c, d, e, f)` to a Mat33.

package/dist/mjs/Mat33.fromCSSMatrix.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/mjs/Mat33.mjs

@@ -253,9 +253,30 @@ export class Mat33 {
     getScaleFactor() {
         return Math.hypot(this.a1, this.a2);
     }
+    /** Returns the `idx`-th column (`idx` is 0-indexed). */
+    getColumn(idx) {
+        return Vec3.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
@@ -290,7 +311,11 @@ export 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})`;
     }
@@ -308,30 +333,95 @@ export 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.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.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;
     }
 }
 Mat33.identity = new Mat33(1, 0, 0, 0, 1, 0, 0, 0, 1);

package/dist/mjs/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/mjs/Vec3.mjs

@@ -55,6 +55,15 @@ export 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/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@js-draw/math",
-	"version": "1.3.0",
+	"version": "1.4.0",
 	"description": "A math library for js-draw. ",
 	"types": "./dist/mjs/lib.d.ts",
 	"main": "./dist/cjs/lib.js",
@@ -22,13 +22,13 @@
 		"dist-test": "npm run build && cd dist-test/test_imports && npm install && npm run test",
 		"dist": "npm run build && npm run dist-test",
 		"build": "rm -rf ./dist && mkdir dist && build-tool build",
-		"watch": "rm -rf ./dist && mkdir dist && build-tool watch"
+		"watch": "rm -rf ./dist/* && mkdir -p dist && build-tool watch"
 	},
 	"dependencies": {
 		"bezier-js": "6.1.3"
 	},
 	"devDependencies": {
-		"@js-draw/build-tool": "^1.0.2",
+		"@js-draw/build-tool": "^1.4.0",
 		"@types/bezier-js": "4.1.0",
 		"@types/jest": "29.5.3",
 		"@types/jsdom": "21.1.1"
@@ -45,5 +45,5 @@
 		"svg",
 		"math"
 	],
-	"gitHead": "46b3d8f819f8e083f6e3e1d01e027e4311355456"
+	"gitHead": "b520078c16a4d23d9bed4531eafda87bfce3f6b1"
 }

package/src/Mat33.fromCSSMatrix.test.ts

@@ -0,0 +1,90 @@
+import Mat33 from './Mat33';
+import { Vec2 } from './Vec2';
+
+describe('Mat33.fromCSSMatrix', () => {
+	it('should convert CSS matrix(...) strings to matricies', () => {
+		// From MDN:
+		// 		⎡ a c e ⎤
+		// 		⎢ b d f ⎥  =  matrix(a,b,c,d,e,f)
+		// 		⎣ 0 0 1 ⎦
+		const identity = Mat33.fromCSSMatrix('matrix(1, 0, 0, 1, 0, 0)');
+		expect(identity).objEq(Mat33.identity);
+		expect(Mat33.fromCSSMatrix('matrix(1, 2, 3, 4, 5, 6)')).objEq(new Mat33(
+			1, 3, 5,
+			2, 4, 6,
+			0, 0, 1,
+		));
+		expect(Mat33.fromCSSMatrix('matrix(1e2, 2, 3, 4, 5, 6)')).objEq(new Mat33(
+			1e2, 3, 5,
+			2, 4, 6,
+			0, 0, 1,
+		));
+		expect(Mat33.fromCSSMatrix('matrix(1.6, 2, .3, 4, 5, 6)')).objEq(new Mat33(
+			1.6, .3, 5,
+			2, 4, 6,
+			0, 0, 1,
+		));
+		expect(Mat33.fromCSSMatrix('matrix(-1, 2, 3.E-2, 4, -5.123, -6.5)')).objEq(new Mat33(
+			-1, 0.03, -5.123,
+			2, 4, -6.5,
+			0, 0, 1,
+		));
+		expect(Mat33.fromCSSMatrix('matrix(1.6,\n\t2, .3, 4, 5, 6)')).objEq(new Mat33(
+			1.6, .3, 5,
+			2, 4, 6,
+			0, 0, 1,
+		));
+		expect(Mat33.fromCSSMatrix('matrix(1.6,2, .3E-2, 4, 5, 6)')).objEq(new Mat33(
+			1.6, 3e-3, 5,
+			2, 4, 6,
+			0, 0, 1,
+		));
+		expect(Mat33.fromCSSMatrix('matrix(-1, 2e6,	3E-2,-5.123, -6.5e-1, 0.01)')).objEq(new Mat33(
+			-1, 	3E-2,  	-6.5e-1,
+			2e6,	-5.123,	0.01,
+			0,  	0,     	1,
+		));
+	});
+
+	it('should convert multi-matrix arguments into a single CSS matrix', () => {
+		const identity = Mat33.fromCSSMatrix('matrix(1, 0, 0, 1, 0, 0) matrix(1, 0, 0, 1, 0, 0)');
+		expect(identity).objEq(Mat33.identity);
+
+		expect(Mat33.fromCSSMatrix('matrix(1, 0, 0, 1, 0, 0) matrix(1, 2, 3, 4, 5, 6) matrix(1, 0, 0, 1, 0, 0)')).objEq(new Mat33(
+			1, 3, 5,
+			2, 4, 6,
+			0, 0, 1,
+		));
+
+		expect(Mat33.fromCSSMatrix('matrix(2,\n\t 0, 0, 2, 0, 0) matrix(1, 2, 3, 4, 5, 6) matrix(1, 0, 0, 1, 0, 0)')).objEq(new Mat33(
+			2, 6, 10,
+			4, 8, 12,
+			0, 0, 1,
+		));
+	});
+
+	it('should convert scale()s with a single argument', () => {
+		expect(Mat33.fromCSSMatrix('scale(1)')).objEq(Mat33.identity);
+		expect(Mat33.fromCSSMatrix('scale(0.4)')).objEq(Mat33.scaling2D(0.4));
+		expect(Mat33.fromCSSMatrix('scale(-0.4 )')).objEq(Mat33.scaling2D(-0.4));
+		expect(Mat33.fromCSSMatrix('scale(100%)')).objEq(Mat33.identity);
+		expect(Mat33.fromCSSMatrix('scale(20e2%)')).objEq(Mat33.scaling2D(20));
+		expect(Mat33.fromCSSMatrix('scale(200%) scale(50%)')).objEq(Mat33.identity);
+	});
+
+	it('should convert scale()s with two arguments', () => {
+		expect(Mat33.fromCSSMatrix('scale(1\t 1)')).objEq(Mat33.identity);
+		expect(Mat33.fromCSSMatrix('scale(1\t 2)')).objEq(Mat33.scaling2D(Vec2.of(1, 2)));
+		expect(Mat33.fromCSSMatrix('scale(1\t 2) scale(1)')).objEq(Mat33.scaling2D(Vec2.of(1, 2)));
+	});
+
+	it('should convert translate()s', () => {
+		expect(Mat33.fromCSSMatrix('translate(0)')).objEq(Mat33.identity);
+		expect(Mat33.fromCSSMatrix('translate(1, 1)')).objEq(Mat33.translation(Vec2.of(1, 1)));
+		expect(Mat33.fromCSSMatrix('translate(1 200%)')).objEq(Mat33.translation(Vec2.of(1, 2)));
+	});
+
+	it('should support px following numbers', () => {
+		expect(Mat33.fromCSSMatrix('translate(1px, 2px)')).objEq(Mat33.translation(Vec2.of(1, 2)));
+	});
+});

package/src/Mat33.test.ts

@@ -198,47 +198,11 @@ describe('Mat33 tests', () => {
 		));
 	});
 
-	it('should convert CSS matrix(...) strings to matricies', () => {
-		// From MDN:
-		// 		⎡ a c e ⎤
-		// 		⎢ b d f ⎥  =  matrix(a,b,c,d,e,f)
-		// 		⎣ 0 0 1 ⎦
-		const identity = Mat33.fromCSSMatrix('matrix(1, 0, 0, 1, 0, 0)');
-		expect(identity).objEq(Mat33.identity);
-		expect(Mat33.fromCSSMatrix('matrix(1, 2, 3, 4, 5, 6)')).objEq(new Mat33(
-			1, 3, 5,
-			2, 4, 6,
-			0, 0, 1,
-		));
-		expect(Mat33.fromCSSMatrix('matrix(1e2, 2, 3, 4, 5, 6)')).objEq(new Mat33(
-			1e2, 3, 5,
-			2, 4, 6,
-			0, 0, 1,
-		));
-		expect(Mat33.fromCSSMatrix('matrix(1.6, 2, .3, 4, 5, 6)')).objEq(new Mat33(
-			1.6, .3, 5,
-			2, 4, 6,
-			0, 0, 1,
-		));
-		expect(Mat33.fromCSSMatrix('matrix(-1, 2, 3.E-2, 4, -5.123, -6.5)')).objEq(new Mat33(
-			-1, 0.03, -5.123,
-			2, 4, -6.5,
-			0, 0, 1,
-		));
-		expect(Mat33.fromCSSMatrix('matrix(1.6,\n\t2, .3, 4, 5, 6)')).objEq(new Mat33(
-			1.6, .3, 5,
-			2, 4, 6,
-			0, 0, 1,
-		));
-		expect(Mat33.fromCSSMatrix('matrix(1.6,2, .3E-2, 4, 5, 6)')).objEq(new Mat33(
-			1.6, 3e-3, 5,
-			2, 4, 6,
-			0, 0, 1,
-		));
-		expect(Mat33.fromCSSMatrix('matrix(-1, 2e6,	3E-2,-5.123, -6.5e-1, 0.01)')).objEq(new Mat33(
-			-1, 	3E-2,  	-6.5e-1,
-			2e6,	-5.123,	0.01,
-			0,  	0,     	1,
-		));
+	it('getColumn should return the given column index', () => {
+		expect(Mat33.identity.getColumn(0)).objEq(Vec3.unitX);
+		expect(Mat33.identity.getColumn(1)).objEq(Vec3.of(0, 1, 0));
+
+		// scaling2D only scales the x/y components of vectors it transforms
+		expect(Mat33.scaling2D(2).getColumn(2)).objEq(Vec3.of(0, 0, 1));
 	});
 });

package/src/Mat33.ts

@@ -335,9 +335,37 @@ export class Mat33 {
 		return Math.hypot(this.a1, this.a2);
 	}
 
+	/** Returns the `idx`-th column (`idx` is 0-indexed). */
+	public getColumn(idx: number) {
+		return Vec3.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 */
+	public 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}
+	 * $$
 	 */
 	public static translation(amount: Vec2): Mat33 {
 		// When transforming Vec2s by a 3x3 matrix, we give the input
@@ -392,7 +420,11 @@ export class Mat33 {
 		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}
+	 */
 	public toCSSMatrix(): string {
 		return `matrix(${this.a1},${this.b1},${this.a2},${this.b2},${this.a3},${this.b3})`;
 	}
@@ -412,39 +444,118 @@ export class Mat33 {
 			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, // a, c, e
-				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: string) => {
+			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: number[]) => {
+				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: number[]) => {
+				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.of(scaleX, scaleY));
+			},
+
+			translate: (translateArgs: number[]) => {
+				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.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: Mat33|null = 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 as keyof typeof keywordToAction](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;
 	}
 }
 export default Mat33;

package/src/Vec3.ts

@@ -63,6 +63,16 @@ export class Vec3 {
 		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.
+	 */
+	public maximumEntryMagnitude(): number {
+		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/src/rounding.ts

@@ -165,3 +165,4 @@ export const toStringOfSamePrecision = (num: number, ...references: string[]): s
 	const negativeSign = textMatch[1];
 	return cleanUpNumber(`${negativeSign}${preDecimal}.${postDecimal}`);
 };
+