@js-draw/math 1.21.3 → 1.22.0

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@js-draw/math",
-	"version": "1.21.3",
+	"version": "1.22.0",
 	"description": "A math library for js-draw. ",
 	"types": "./dist/mjs/lib.d.ts",
 	"main": "./dist/cjs/lib.js",
@@ -27,7 +27,7 @@
 		"bezier-js": "6.1.3"
 	},
 	"devDependencies": {
-		"@js-draw/build-tool": "^1.21.3",
+		"@js-draw/build-tool": "^1.22.0",
 		"@types/bezier-js": "4.1.0",
 		"@types/jest": "29.5.5",
 		"@types/jsdom": "21.1.3"
@@ -44,5 +44,5 @@
 		"svg",
 		"math"
 	],
-	"gitHead": "2b11a1efafeeb3b84effb7d849343d273df371f8"
+	"gitHead": "c922cf6e44d078133100e01383ba1bacdebe01bd"
 }

package/src/Color4.test.ts

@@ -15,7 +15,7 @@ describe('Color4', () => {
 		expect(Color4.fromString('rgb(0, 0, 0)')).objEq(Color4.black);
 		expect(Color4.fromString('rgb ( 255, 0,\t 0)')).objEq(Color4.ofRGBA(1, 0, 0, 1));
 		expect(Color4.fromString('rgba ( 255, 0,\t 0, 0.5)')).objEq(Color4.ofRGBA(1, 0, 0, 0.5));
-		expect(Color4.fromString('rgba( 0, 0, 128, 0)')).objEq(Color4.ofRGBA(0, 0, 128/255, 0));
+		expect(Color4.fromString('rgba( 0, 0, 128, 0)')).objEq(Color4.ofRGBA(0, 0, 128 / 255, 0));
 	});
 
 	it('should parse transparent/none as completely transparent', () => {
@@ -29,13 +29,11 @@ describe('Color4', () => {
 	});
 
 	it('should mix red and green to get yellow', () => {
-		expect(Color4.ofRGB(1, 0, 0).mix(Color4.ofRGB(0, 1, 0), 0.3)).objEq(
-			Color4.ofRGB(0.7, 0.3, 0)
-		);
+		expect(Color4.ofRGB(1, 0, 0).mix(Color4.ofRGB(0, 1, 0), 0.3)).objEq(Color4.ofRGB(0.7, 0.3, 0));
 	});
 
 	it('should mix red with nothing and get red', () => {
-		expect(Color4.average([ Color4.red ])).objEq(Color4.red);
+		expect(Color4.average([Color4.red])).objEq(Color4.red);
 	});
 
 	it('different colors should be different', () => {
@@ -47,14 +45,11 @@ describe('Color4', () => {
 	it('should correctly convert to hsv', () => {
 		expect(Color4.red.asHSV()).objEq(Vec3.of(0, 1, 1));
 		expect(Color4.ofRGB(0.5, 0.5, 0.5).asHSV()).objEq(Vec3.of(0, 0, 0.5));
-		expect(Color4.ofRGB(0.5, 0.25, 0.5).asHSV()).objEq(Vec3.of(Math.PI * 5 / 3, 0.5, 0.5), 0.1);
+		expect(Color4.ofRGB(0.5, 0.25, 0.5).asHSV()).objEq(Vec3.of((Math.PI * 5) / 3, 0.5, 0.5), 0.1);
 	});
 
 	it('fromHSV(color.asHSV) should return the original color', () => {
-		const testColors = [
-			Color4.red, Color4.green, Color4.blue,
-			Color4.white, Color4.black,
-		];
+		const testColors = [Color4.red, Color4.green, Color4.blue, Color4.white, Color4.black];
 
 		const testWithColor = (color: Color4) => {
 			expect(Color4.fromHSV(...color.asHSV().asArray())).objEq(color);
@@ -65,8 +60,8 @@ describe('Color4', () => {
 		}
 
 		for (let i = 0; i <= 6; i++) {
-			testWithColor(Color4.fromHSV(i * Math.PI / 7, 0.5, 0.5));
-			testWithColor(Color4.fromHSV(i * Math.PI / 6, 0.5, 0.5));
+			testWithColor(Color4.fromHSV((i * Math.PI) / 7, 0.5, 0.5));
+			testWithColor(Color4.fromHSV((i * Math.PI) / 6, 0.5, 0.5));
 		}
 	});
 
@@ -78,17 +73,17 @@ describe('Color4', () => {
 
 	it('should return correct contrast ratios', () => {
 		// Expected values from https://webaim.org/resources/contrastchecker/
-		const testCases: [ Color4, Color4, number ][] = [
-			[ Color4.white, Color4.black, 21 ],
-			[ Color4.fromHex('#FF0000'), Color4.black, 5.25 ],
-			[ Color4.fromHex('#FF0000'), Color4.fromHex('#0000FF'), 2.14 ],
-			[ Color4.fromHex('#300000'), Color4.fromHex('#003000'), 1.26 ],
-			[ Color4.fromHex('#300000'), Color4.fromHex('#003000'), 1.26 ],
-			[ Color4.fromHex('#D60000'), Color4.fromHex('#003000'), 2.71 ],
+		const testCases: [Color4, Color4, number][] = [
+			[Color4.white, Color4.black, 21],
+			[Color4.fromHex('#FF0000'), Color4.black, 5.25],
+			[Color4.fromHex('#FF0000'), Color4.fromHex('#0000FF'), 2.14],
+			[Color4.fromHex('#300000'), Color4.fromHex('#003000'), 1.26],
+			[Color4.fromHex('#300000'), Color4.fromHex('#003000'), 1.26],
+			[Color4.fromHex('#D60000'), Color4.fromHex('#003000'), 2.71],
 		];
 
-		for (const [ colorA, colorB, expectedContrast ] of testCases) {
+		for (const [colorA, colorB, expectedContrast] of testCases) {
 			expect(Color4.contrastRatio(colorA, colorB)).toBeCloseTo(expectedContrast, 1);
 		}
 	});
-});
+});

package/src/Color4.ts

@@ -25,9 +25,8 @@ export class Color4 {
 		public readonly b: number,
 
 		/** Alpha/transparent component. ${\tt a} \in [0, 1]$. 0 = transparent */
-		public readonly a: number
-	) {
-	}
+		public readonly a: number,
+	) {}
 
 	/**
 	 * Create a color from red, green, blue components. The color is fully opaque (`a = 1.0`).
@@ -62,7 +61,7 @@ export class Color4 {
 			const components = hexString.split('');
 
 			// Convert to RRGGBBAA or RRGGBB format
-			hexString = components.map(component => `${component}0`).join('');
+			hexString = components.map((component) => `${component}0`).join('');
 		}
 
 		if (hexString.length === 6) {
@@ -108,14 +107,21 @@ export class Color4 {
 
 			if (componentsList.length === 3) {
 				return Color4.ofRGB(
-					componentsList[0] / 255, componentsList[1] / 255, componentsList[2] / 255
+					componentsList[0] / 255,
+					componentsList[1] / 255,
+					componentsList[2] / 255,
 				);
 			} else if (componentsList.length === 4) {
 				return Color4.ofRGBA(
-					componentsList[0] / 255, componentsList[1] / 255, componentsList[2] / 255, componentsList[3]
+					componentsList[0] / 255,
+					componentsList[1] / 255,
+					componentsList[2] / 255,
+					componentsList[3],
 				);
 			} else {
-				throw new Error(`RGB string, ${text}, has wrong number of components: ${componentsList.length}`);
+				throw new Error(
+					`RGB string, ${text}, has wrong number of components: ${componentsList.length}`,
+				);
 			}
 		}
 
@@ -145,7 +151,7 @@ export class Color4 {
 	}
 
 	/** @returns true if `this` and `other` are approximately equal. */
-	public eq(other: Color4|null|undefined): boolean {
+	public eq(other: Color4 | null | undefined): boolean {
 		if (other == null) {
 			return false;
 		}
@@ -202,7 +208,7 @@ export class Color4 {
 		// - https://stackoverflow.com/a/9733420
 
 		// Normalize the components, as per above
-		const components = [ this.r, this.g, this.b ].map(component => {
+		const components = [this.r, this.g, this.b].map((component) => {
 			if (component < 0.03928) {
 				return component / 12.92;
 			} else {
@@ -358,24 +364,23 @@ export class Color4 {
 
 		let rgb;
 		if (huePrime < 1) {
-			rgb = [ chroma, secondLargestComponent, 0 ];
+			rgb = [chroma, secondLargestComponent, 0];
 		} else if (huePrime < 2) {
-			rgb = [ secondLargestComponent, chroma, 0 ];
+			rgb = [secondLargestComponent, chroma, 0];
 		} else if (huePrime < 3) {
-			rgb = [ 0, chroma, secondLargestComponent ];
+			rgb = [0, chroma, secondLargestComponent];
 		} else if (huePrime < 4) {
-			rgb = [ 0, secondLargestComponent, chroma ];
+			rgb = [0, secondLargestComponent, chroma];
 		} else if (huePrime < 5) {
-			rgb = [ secondLargestComponent, 0, chroma ];
+			rgb = [secondLargestComponent, 0, chroma];
 		} else {
-			rgb = [ chroma, 0, secondLargestComponent ];
+			rgb = [chroma, 0, secondLargestComponent];
 		}
 
 		const adjustment = value - chroma;
 		return Color4.ofRGB(rgb[0] + adjustment, rgb[1] + adjustment, rgb[2] + adjustment);
 	}
 
-
 	/**
 	 * Equivalent to `ofRGB(rgb.x, rgb.y, rgb.z)`.
 	 *
@@ -385,7 +390,7 @@ export class Color4 {
 		return Color4.ofRGBA(rgb.x, rgb.y, rgb.z, alpha ?? 1);
 	}
 
-	private hexString: string|null = null;
+	private hexString: string | null = null;
 
 	/**
 	 * @returns a hexadecimal color string representation of `this`, in the form `#rrggbbaa`.

package/src/Mat33.fromCSSMatrix.test.ts

@@ -9,58 +9,44 @@ describe('Mat33.fromCSSMatrix', () => {
 		// 		⎣ 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,
-		));
+		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, 0.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, 0.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(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,
-		));
+		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', () => {

package/src/Mat33.test.ts

@@ -2,72 +2,40 @@ import Mat33 from './Mat33';
 import { Point2, Vec2 } from './Vec2';
 import Vec3 from './Vec3';
 
-
 describe('Mat33 tests', () => {
 	it('equality', () => {
 		expect(Mat33.identity).objEq(Mat33.identity);
-		expect(new Mat33(
-			0.1, 0.2, 0.3,
-			0.4, 0.5, 0.6,
-			0.7, 0.8, -0.9
-		)).objEq(new Mat33(
-			0.2, 0.1, 0.4,
-			0.5, 0.5, 0.7,
-			0.7, 0.8, -0.9
-		), 0.2);
+		expect(new Mat33(0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, -0.9)).objEq(
+			new Mat33(0.2, 0.1, 0.4, 0.5, 0.5, 0.7, 0.7, 0.8, -0.9),
+			0.2,
+		);
 	});
 
 	it('transposition', () => {
 		expect(Mat33.identity.transposed()).objEq(Mat33.identity);
-		expect(new Mat33(
-			1, 2, 0,
-			0, 0, 0,
-			0, 1, 0
-		).transposed()).objEq(new Mat33(
-			1, 0, 0,
-			2, 0, 1,
-			0, 0, 0
-		));
+		expect(new Mat33(1, 2, 0, 0, 0, 0, 0, 1, 0).transposed()).objEq(
+			new Mat33(1, 0, 0, 2, 0, 1, 0, 0, 0),
+		);
 	});
 
 	it('multiplication', () => {
-		const M = new Mat33(
-			1, 2, 3,
-			4, 5, 6,
-			7, 8, 9
-		);
+		const M = new Mat33(1, 2, 3, 4, 5, 6, 7, 8, 9);
 
 		expect(Mat33.identity.rightMul(Mat33.identity)).objEq(Mat33.identity);
 		expect(M.rightMul(Mat33.identity)).objEq(M);
-		expect(M.rightMul(new Mat33(
-			1, 0, 0,
-			0, 2, 0,
-			0, 0, 1
-		))).objEq(new Mat33(
-			1, 4, 3,
-			4, 10, 6,
-			7, 16, 9
-		));
-		expect(M.rightMul(new Mat33(
-			2, 0, 1,
-			0, 1, 0,
-			0, 0, 3
-		))).objEq(new Mat33(
-			2, 2, 10,
-			8, 5, 22,
-			14, 8, 34
-		));
+		expect(M.rightMul(new Mat33(1, 0, 0, 0, 2, 0, 0, 0, 1))).objEq(
+			new Mat33(1, 4, 3, 4, 10, 6, 7, 16, 9),
+		);
+		expect(M.rightMul(new Mat33(2, 0, 1, 0, 1, 0, 0, 0, 3))).objEq(
+			new Mat33(2, 2, 10, 8, 5, 22, 14, 8, 34),
+		);
 	});
 
 	it('the inverse of the identity matrix should be the identity matrix', () => {
 		const fuzz = 0.01;
 		expect(Mat33.identity.inverse()).objEq(Mat33.identity, fuzz);
 
-		const M = new Mat33(
-			1, 2, 3,
-			4, 1, 0,
-			2, 3, 0
-		);
+		const M = new Mat33(1, 2, 3, 4, 1, 0, 2, 3, 0);
 		expect(M.inverse().rightMul(M)).objEq(Mat33.identity, fuzz);
 	});
 
@@ -82,12 +50,12 @@ describe('Mat33 tests', () => {
 
 	it('z-rotation matricies should preserve the given origin', () => {
 		const testPairs: Array<[number, Vec2]> = [
-			[ Math.PI / 2, Vec2.zero ],
-			[ -Math.PI / 2, Vec2.zero ],
-			[ -Math.PI / 2, Vec2.of(10, 10) ],
+			[Math.PI / 2, Vec2.zero],
+			[-Math.PI / 2, Vec2.zero],
+			[-Math.PI / 2, Vec2.of(10, 10)],
 		];
 
-		for (const [ angle, center ] of testPairs) {
+		for (const [angle, center] of testPairs) {
 			expect(Mat33.zRotation(angle, center).transformVec2(center)).objEq(center);
 		}
 	});
@@ -111,11 +79,7 @@ describe('Mat33 tests', () => {
 
 	it('calling inverse on singular matricies should result in the identity matrix', () => {
 		const fuzz = 0.001;
-		const singularMat = Mat33.ofRows(
-			Vec3.of(0, 0, 1),
-			Vec3.of(0, 1, 0),
-			Vec3.of(0, 1, 1)
-		);
+		const singularMat = Mat33.ofRows(Vec3.of(0, 0, 1), Vec3.of(0, 1, 0), Vec3.of(0, 1, 1));
 		expect(singularMat.invertable()).toBe(false);
 		expect(singularMat.inverse()).objEq(Mat33.identity, fuzz);
 	});
@@ -123,15 +87,19 @@ describe('Mat33 tests', () => {
 	it('z-rotation matricies should be invertable', () => {
 		const fuzz = 0.01;
 		const M = Mat33.zRotation(-0.2617993877991494, Vec2.of(481, 329.5));
-		expect(
-			M.inverse().transformVec2(M.transformVec2(Vec2.unitX))
-		).objEq(Vec2.unitX, fuzz);
+		expect(M.inverse().transformVec2(M.transformVec2(Vec2.unitX))).objEq(Vec2.unitX, fuzz);
 		expect(M.invertable());
 
 		const starterTransform = new Mat33(
-			-0.2588190451025205, -0.9659258262890688, 923.7645204565603,
-			0.9659258262890688,  -0.2588190451025205, -49.829447083761465,
-			0, 0, 1
+			-0.2588190451025205,
+			-0.9659258262890688,
+			923.7645204565603,
+			0.9659258262890688,
+			-0.2588190451025205,
+			-49.829447083761465,
+			0,
+			0,
+			1,
 		);
 		expect(starterTransform.invertable()).toBe(true);
 
@@ -139,32 +107,32 @@ describe('Mat33 tests', () => {
 		const fullTransformInverse = fullTransform.inverse();
 		expect(fullTransform.invertable()).toBe(true);
 
-		expect(
-			fullTransformInverse.rightMul(fullTransform)
-		).objEq(Mat33.identity, fuzz);
+		expect(fullTransformInverse.rightMul(fullTransform)).objEq(Mat33.identity, fuzz);
 
-		expect(
-			fullTransform.transformVec2(fullTransformInverse.transformVec2(Vec2.unitX))
-		).objEq(Vec2.unitX, fuzz);
+		expect(fullTransform.transformVec2(fullTransformInverse.transformVec2(Vec2.unitX))).objEq(
+			Vec2.unitX,
+			fuzz,
+		);
 
-		expect(
-			fullTransformInverse.transformVec2(fullTransform.transformVec2(Vec2.unitX))
-		).objEq(Vec2.unitX, fuzz);
+		expect(fullTransformInverse.transformVec2(fullTransform.transformVec2(Vec2.unitX))).objEq(
+			Vec2.unitX,
+			fuzz,
+		);
 	});
 
 	it('z-rotation matrix inverses should undo the z-rotation', () => {
-		const testCases: Array<[ number, Point2 ]> = [
-			[ Math.PI / 2, Vec2.zero ],
-			[ Math.PI, Vec2.of(1, 1) ],
-			[ -Math.PI, Vec2.of(1, 1) ],
-			[ -Math.PI * 2, Vec2.of(1, 1) ],
-			[ -Math.PI * 2, Vec2.of(123, 456) ],
-			[ -Math.PI / 4, Vec2.of(123, 456) ],
-			[ 0.1, Vec2.of(1, 2) ],
+		const testCases: Array<[number, Point2]> = [
+			[Math.PI / 2, Vec2.zero],
+			[Math.PI, Vec2.of(1, 1)],
+			[-Math.PI, Vec2.of(1, 1)],
+			[-Math.PI * 2, Vec2.of(1, 1)],
+			[-Math.PI * 2, Vec2.of(123, 456)],
+			[-Math.PI / 4, Vec2.of(123, 456)],
+			[0.1, Vec2.of(1, 2)],
 		];
 
 		const fuzz = 0.00001;
-		for (const [ angle, center ] of testCases) {
+		for (const [angle, center] of testCases) {
 			const mat = Mat33.zRotation(angle, center);
 			expect(mat.inverse().rightMul(mat)).objEq(Mat33.identity, fuzz);
 			expect(mat.rightMul(mat.inverse())).objEq(Mat33.identity, fuzz);
@@ -172,30 +140,24 @@ describe('Mat33 tests', () => {
 	});
 
 	it('z-rotation should preserve given origin', () => {
-		const testCases: Array<[ number, Point2 ]> = [
-			[ 6.205048847547065, Vec2.of(75.16363373235318, 104.29870408043762) ],
-			[ 1.234, Vec2.of(-56, 789) ],
-			[ -Math.PI, Vec2.of(-56, 789) ],
-			[ -Math.PI / 2, Vec2.of(-0.001, 1.0002) ],
+		const testCases: Array<[number, Point2]> = [
+			[6.205048847547065, Vec2.of(75.16363373235318, 104.29870408043762)],
+			[1.234, Vec2.of(-56, 789)],
+			[-Math.PI, Vec2.of(-56, 789)],
+			[-Math.PI / 2, Vec2.of(-0.001, 1.0002)],
 		];
 
 		for (const [angle, rotationOrigin] of testCases) {
-			expect(Mat33.zRotation(angle, rotationOrigin).transformVec2(rotationOrigin)).objEq(rotationOrigin);
+			expect(Mat33.zRotation(angle, rotationOrigin).transformVec2(rotationOrigin)).objEq(
+				rotationOrigin,
+			);
 		}
 	});
 
 	it('should correctly apply a mapping to all components', () => {
 		expect(
-			new Mat33(
-				1, 2, 3,
-				4, 5, 6,
-				7, 8, 9,
-			).mapEntries(component => component - 1)
-		).toMatchObject(new Mat33(
-			0, 1, 2,
-			3, 4, 5,
-			6, 7, 8,
-		));
+			new Mat33(1, 2, 3, 4, 5, 6, 7, 8, 9).mapEntries((component) => component - 1),
+		).toMatchObject(new Mat33(0, 1, 2, 3, 4, 5, 6, 7, 8));
 	});
 
 	it('getColumn should return the given column index', () => {