@js-draw/math 1.21.2 → 1.22.0

package/src/shapes/PointShape2D.ts

@@ -20,9 +20,9 @@ class PointShape2D extends Parameterized2DShape {
 
 	public override argIntersectsLineSegment(lineSegment: LineSegment2, epsilon?: number): number[] {
 		if (lineSegment.containsPoint(this.p, epsilon)) {
-			return [ 0 ];
+			return [0];
 		}
-		return [ ];
+		return [];
 	}
 
 	public override getTightBoundingBox(): Rect2 {
@@ -57,4 +57,4 @@ class PointShape2D extends Parameterized2DShape {
 	}
 }
 
-export default PointShape2D;
+export default PointShape2D;

package/src/shapes/QuadraticBezier.test.ts

@@ -27,24 +27,27 @@ describe('QuadraticBezier', () => {
 	});
 
 	test.each([
-		[ new QuadraticBezier(Vec2.zero, Vec2.unitX, Vec2.unitY), Vec2.zero, 0 ],
-		[ new QuadraticBezier(Vec2.zero, Vec2.unitX, Vec2.unitY), Vec2.unitY, 1 ],
+		[new QuadraticBezier(Vec2.zero, Vec2.unitX, Vec2.unitY), Vec2.zero, 0],
+		[new QuadraticBezier(Vec2.zero, Vec2.unitX, Vec2.unitY), Vec2.unitY, 1],
 
-		[ new QuadraticBezier(Vec2.zero, Vec2.of(0.5, 0), Vec2.of(1, 0)), Vec2.of(0.4, 0), 0.4],
-		[ new QuadraticBezier(Vec2.zero, Vec2.of(0, 0.5), Vec2.of(0, 1)), Vec2.of(0, 0.4), 0.4],
-		[ new QuadraticBezier(Vec2.zero, Vec2.unitX, Vec2.unitY), Vec2.unitX, 0.42514 ],
+		[new QuadraticBezier(Vec2.zero, Vec2.of(0.5, 0), Vec2.of(1, 0)), Vec2.of(0.4, 0), 0.4],
+		[new QuadraticBezier(Vec2.zero, Vec2.of(0, 0.5), Vec2.of(0, 1)), Vec2.of(0, 0.4), 0.4],
+		[new QuadraticBezier(Vec2.zero, Vec2.unitX, Vec2.unitY), Vec2.unitX, 0.42514],
 
 		// Should not return an out-of-range parameter
-		[ new QuadraticBezier(Vec2.zero, Vec2.of(0, 0.5), Vec2.unitY), Vec2.of(0, -1000), 0 ],
-		[ new QuadraticBezier(Vec2.zero, Vec2.of(0, 0.5), Vec2.unitY), Vec2.of(0, 1000), 1 ],
+		[new QuadraticBezier(Vec2.zero, Vec2.of(0, 0.5), Vec2.unitY), Vec2.of(0, -1000), 0],
+		[new QuadraticBezier(Vec2.zero, Vec2.of(0, 0.5), Vec2.unitY), Vec2.of(0, 1000), 1],
 
 		// Edge case -- just a point
-		[ new QuadraticBezier(Vec2.zero, Vec2.zero, Vec2.zero), Vec2.of(0, 1000), 0 ],
-	])('nearestPointTo should return the nearest point and parameter value on %s to %s', (bezier, point, expectedParameter) => {
-		const nearest = bezier.nearestPointTo(point);
-		expect(nearest.parameterValue).toBeCloseTo(expectedParameter, 0.0001);
-		expect(nearest.point).objEq(bezier.at(nearest.parameterValue));
-	});
+		[new QuadraticBezier(Vec2.zero, Vec2.zero, Vec2.zero), Vec2.of(0, 1000), 0],
+	])(
+		'nearestPointTo should return the nearest point and parameter value on %s to %s',
+		(bezier, point, expectedParameter) => {
+			const nearest = bezier.nearestPointTo(point);
+			expect(nearest.parameterValue).toBeCloseTo(expectedParameter, 0.0001);
+			expect(nearest.point).objEq(bezier.at(nearest.parameterValue));
+		},
+	);
 
 	test('.normalAt should return a unit normal vector at the given parameter value', () => {
 		const curves = [
@@ -72,17 +75,20 @@ describe('QuadraticBezier', () => {
 		new QuadraticBezier(Vec2.zero, Vec2.unitY, Vec2.unitY.times(2)),
 		new QuadraticBezier(Vec2.zero, Vec2.unitX, Vec2.unitY),
 		new QuadraticBezier(Vec2.zero, Vec2.unitY, Vec2.unitX),
-	])('.derivativeAt should return a derivative vector with the correct direction (curve: %s)', (curve) => {
-		for (let t = 0; t < 1; t += 0.1) {
-			const derivative = curve.derivativeAt(t);
-			const derivativeApprox = curve.at(t + 0.001).minus(curve.at(t - 0.001));
-			expect(derivativeApprox.normalized()).objEq(derivative.normalized(), 0.01);
-		}
-	});
+	])(
+		'.derivativeAt should return a derivative vector with the correct direction (curve: %s)',
+		(curve) => {
+			for (let t = 0; t < 1; t += 0.1) {
+				const derivative = curve.derivativeAt(t);
+				const derivativeApprox = curve.at(t + 0.001).minus(curve.at(t - 0.001));
+				expect(derivativeApprox.normalized()).objEq(derivative.normalized(), 0.01);
+			}
+		},
+	);
 
 	test('should support Bezier-Bezier intersections', () => {
 		const b1 = new QuadraticBezier(Vec2.zero, Vec2.unitX, Vec2.unitY);
 		const b2 = new QuadraticBezier(Vec2.of(-1, 0.5), Vec2.of(0, 0.6), Vec2.of(1, 0.4));
 		expect(b1.intersectsBezier(b2)).toHaveLength(1);
 	});
-});
+});

package/src/shapes/QuadraticBezier.ts

@@ -12,7 +12,7 @@ export class QuadraticBezier extends BezierJSWrapper {
 	public constructor(
 		public readonly p0: Point2,
 		public readonly p1: Point2,
-		public readonly p2: Point2
+		public readonly p2: Point2,
 	) {
 		super();
 	}
@@ -78,7 +78,7 @@ export class QuadraticBezier extends BezierJSWrapper {
 
 	/** @returns an overestimate of this shape's bounding box. */
 	public override getLooseBoundingBox(): Rect2 {
-		return Rect2.bboxOf([ this.p0, this.p1, this.p2 ]);
+		return Rect2.bboxOf([this.p0, this.p1, this.p2]);
 	}
 
 	/**
@@ -124,14 +124,9 @@ export class QuadraticBezier extends BezierJSWrapper {
 		const f2ndDerivAtZero = b;
 		const f3rdDerivAtZero = 2 * c;
 
-
 		// Using the first few terms of a Maclaurin series to approximate f'(t),
 		// f'(t) ≈ f'(0) + t f''(0) + t² f'''(0) / 2
-		let [ min1, min2 ] = solveQuadratic(
-			f3rdDerivAtZero / 2,
-			f2ndDerivAtZero,
-			fDerivAtZero,
-		);
+		let [min1, min2] = solveQuadratic(f3rdDerivAtZero / 2, f2ndDerivAtZero, fDerivAtZero);
 
 		// If the quadratic has no solutions, approximate.
 		if (isNaN(min1)) {
@@ -153,7 +148,7 @@ export class QuadraticBezier extends BezierJSWrapper {
 	}
 
 	public override getPoints() {
-		return [ this.p0, this.p1, this.p2 ];
+		return [this.p0, this.p1, this.p2];
 	}
 }
 export default QuadraticBezier;

package/src/shapes/Rect2.test.ts

@@ -1,4 +1,3 @@
-
 import Rect2 from './Rect2';
 import { Vec2 } from '../Vec2';
 import Mat33 from '../Mat33';
@@ -7,42 +6,21 @@ describe('Rect2', () => {
 	it('width, height should always be positive', () => {
 		expect(new Rect2(-1, -2, -3, 4)).objEq(new Rect2(-4, -2, 3, 4));
 		expect(new Rect2(0, 0, 0, 0).size).objEq(Vec2.zero);
-		expect(Rect2.fromCorners(
-			Vec2.of(-3, -3),
-			Vec2.of(-1, -1)
-		)).objEq(new Rect2(
-			-3, -3,
-			2, 2
-		));
+		expect(Rect2.fromCorners(Vec2.of(-3, -3), Vec2.of(-1, -1))).objEq(new Rect2(-3, -3, 2, 2));
 	});
 
 	it('bounding boxes should be correctly computed', () => {
-		expect(Rect2.bboxOf([
-			Vec2.zero,
-		])).objEq(Rect2.empty);
-
-		expect(Rect2.bboxOf([
-			Vec2.of(-1, -1),
-			Vec2.of(1, 2),
-			Vec2.of(3, 4),
-			Vec2.of(1, -4),
-		])).objEq(new Rect2(
-			-1, -4,
-			4, 8
-		));
-
-		expect(Rect2.bboxOf([
-			Vec2.zero,
-		], 10)).objEq(new Rect2(
-			-10, -10,
-			20, 20
-		));
+		expect(Rect2.bboxOf([Vec2.zero])).objEq(Rect2.empty);
+
+		expect(Rect2.bboxOf([Vec2.of(-1, -1), Vec2.of(1, 2), Vec2.of(3, 4), Vec2.of(1, -4)])).objEq(
+			new Rect2(-1, -4, 4, 8),
+		);
+
+		expect(Rect2.bboxOf([Vec2.zero], 10)).objEq(new Rect2(-10, -10, 20, 20));
 	});
 
 	it('"union"s should contain both composite rectangles.', () => {
-		expect(new Rect2(0, 0, 1, 1).union(new Rect2(1, 1, 2, 2))).objEq(
-			new Rect2(0, 0, 3, 3)
-		);
+		expect(new Rect2(0, 0, 1, 1).union(new Rect2(1, 1, 2, 2))).objEq(new Rect2(0, 0, 3, 3));
 		expect(Rect2.empty.union(Rect2.empty)).objEq(Rect2.empty);
 	});
 
@@ -51,21 +29,15 @@ describe('Rect2', () => {
 	});
 
 	it('should correctly union multiple rectangles', () => {
-		expect(Rect2.union(new Rect2(0, 0, 1, 1), new Rect2(1, 1, 2, 2))).objEq(
-			new Rect2(0, 0, 3, 3)
-		);
+		expect(Rect2.union(new Rect2(0, 0, 1, 1), new Rect2(1, 1, 2, 2))).objEq(new Rect2(0, 0, 3, 3));
 
 		expect(
-			Rect2.union(new Rect2(-1, 0, 1, 1), new Rect2(1, 1, 2, 2), new Rect2(1, 10, 1, 0.1))
-		).objEq(
-			new Rect2(-1, 0, 4, 10.1)
-		);
+			Rect2.union(new Rect2(-1, 0, 1, 1), new Rect2(1, 1, 2, 2), new Rect2(1, 10, 1, 0.1)),
+		).objEq(new Rect2(-1, 0, 4, 10.1));
 
 		expect(
-			Rect2.union(new Rect2(-1, 0, 1, 1), new Rect2(1, -11.1, 2, 2), new Rect2(1, 10, 1, 0.1))
-		).objEq(
-			new Rect2(-1, -11.1, 4, 21.2)
-		);
+			Rect2.union(new Rect2(-1, 0, 1, 1), new Rect2(1, -11.1, 2, 2), new Rect2(1, 10, 1, 0.1)),
+		).objEq(new Rect2(-1, -11.1, 4, 21.2));
 	});
 
 	it('should contain points that are within a rectangle', () => {
@@ -112,17 +84,15 @@ describe('Rect2', () => {
 	});
 
 	it('should correctly compute the intersection of one rectangle and several others', () => {
-		const mainRect = new Rect2(334,156,333,179);
+		const mainRect = new Rect2(334, 156, 333, 179);
 		const shouldIntersect = [
 			new Rect2(400.8, 134.8, 8.4, 161.4),
-			new Rect2(324.8,93,164.4,75.2),
-			new Rect2(435.8,146.8,213.2,192.6),
-			new Rect2(550.8,211.8,3.4,3.4),
-			new Rect2(478.8,93.8,212.4,95.4),
-		];
-		const shouldNotIntersect = [
-			new Rect2(200, 200, 1, 1),
+			new Rect2(324.8, 93, 164.4, 75.2),
+			new Rect2(435.8, 146.8, 213.2, 192.6),
+			new Rect2(550.8, 211.8, 3.4, 3.4),
+			new Rect2(478.8, 93.8, 212.4, 95.4),
 		];
+		const shouldNotIntersect = [new Rect2(200, 200, 1, 1)];
 
 		for (const rect of shouldIntersect) {
 			expect(mainRect.intersects(rect)).toBe(true);
@@ -135,10 +105,10 @@ describe('Rect2', () => {
 	it('intersecting rectangles should have their intersections correctly computed', () => {
 		expect(new Rect2(-1, -1, 2, 2).intersection(Rect2.empty)).objEq(Rect2.empty);
 		expect(new Rect2(-1, -1, 2, 2).intersection(new Rect2(0, 0, 3, 3))).objEq(
-			new Rect2(0, 0, 1, 1)
+			new Rect2(0, 0, 1, 1),
 		);
 		expect(new Rect2(-2, 0, 1, 2).intersection(new Rect2(-3, 0, 2, 2))).objEq(
-			new Rect2(-2, 0, 1, 2)
+			new Rect2(-2, 0, 1, 2),
 		);
 		expect(new Rect2(-1, -1, 2, 2).intersection(new Rect2(3, 3, 10, 10))).toBe(null);
 	});
@@ -192,39 +162,38 @@ describe('Rect2', () => {
 
 	describe('divideIntoGrid', () => {
 		it('division of unit square', () => {
-			expect(Rect2.unitSquare.divideIntoGrid(2, 2)).toMatchObject(
-				[
-					new Rect2(0, 0, 0.5, 0.5), new Rect2(0.5, 0, 0.5, 0.5),
-					new Rect2(0, 0.5, 0.5, 0.5), new Rect2(0.5, 0.5, 0.5, 0.5),
-				]
-			);
+			expect(Rect2.unitSquare.divideIntoGrid(2, 2)).toMatchObject([
+				new Rect2(0, 0, 0.5, 0.5),
+				new Rect2(0.5, 0, 0.5, 0.5),
+				new Rect2(0, 0.5, 0.5, 0.5),
+				new Rect2(0.5, 0.5, 0.5, 0.5),
+			]);
 			expect(Rect2.unitSquare.divideIntoGrid(0, 0).length).toBe(0);
 			expect(Rect2.unitSquare.divideIntoGrid(100, 0).length).toBe(0);
-			expect(Rect2.unitSquare.divideIntoGrid(4, 1)).toMatchObject(
-				[
-					new Rect2(0, 0, 0.25, 1), new Rect2(0.25, 0, 0.25, 1),
-					new Rect2(0.5, 0, 0.25, 1), new Rect2(0.75, 0, 0.25, 1),
-				]
-			);
+			expect(Rect2.unitSquare.divideIntoGrid(4, 1)).toMatchObject([
+				new Rect2(0, 0, 0.25, 1),
+				new Rect2(0.25, 0, 0.25, 1),
+				new Rect2(0.5, 0, 0.25, 1),
+				new Rect2(0.75, 0, 0.25, 1),
+			]);
 		});
 		it('division of translated square', () => {
-			expect(new Rect2(3, -3, 4, 4).divideIntoGrid(2, 1)).toMatchObject(
-				[
-					new Rect2(3, -3, 2, 4), new Rect2(5, -3, 2, 4),
-				]
-			);
+			expect(new Rect2(3, -3, 4, 4).divideIntoGrid(2, 1)).toMatchObject([
+				new Rect2(3, -3, 2, 4),
+				new Rect2(5, -3, 2, 4),
+			]);
 		});
 		it('division of empty square', () => {
 			expect(Rect2.empty.divideIntoGrid(1000, 10000).length).toBe(1);
 		});
 
 		it('division of rectangle', () => {
-			expect(new Rect2(0, 0, 2, 1).divideIntoGrid(2, 2)).toMatchObject(
-				[
-					new Rect2(0, 0, 1, 0.5), new Rect2(1, 0, 1, 0.5),
-					new Rect2(0, 0.5, 1, 0.5), new Rect2(1, 0.5, 1, 0.5),
-				]
-			);
+			expect(new Rect2(0, 0, 2, 1).divideIntoGrid(2, 2)).toMatchObject([
+				new Rect2(0, 0, 1, 0.5),
+				new Rect2(1, 0, 1, 0.5),
+				new Rect2(0, 0.5, 1, 0.5),
+				new Rect2(1, 0.5, 1, 0.5),
+			]);
 		});
 	});
 

package/src/shapes/Rect2.ts

@@ -31,7 +31,7 @@ export class Rect2 extends Abstract2DShape {
 		public readonly x: number,
 		public readonly y: number,
 		public readonly w: number,
-		public readonly h: number
+		public readonly h: number,
 	) {
 		super();
 
@@ -61,14 +61,21 @@ export class Rect2 extends Abstract2DShape {
 	}
 
 	public override containsPoint(other: Point2): boolean {
-		return this.x <= other.x && this.y <= other.y
-			&& this.x + this.w >= other.x && this.y + this.h >= other.y;
+		return (
+			this.x <= other.x &&
+			this.y <= other.y &&
+			this.x + this.w >= other.x &&
+			this.y + this.h >= other.y
+		);
 	}
 
 	public containsRect(other: Rect2): boolean {
-		return this.x <= other.x && this.y <= other.y
-				&& this.x + this.w >= other.x + other.w
-				&& this.y + this.h >= other.y + other.h;
+		return (
+			this.x <= other.x &&
+			this.y <= other.y &&
+			this.x + this.w >= other.x + other.w &&
+			this.y + this.h >= other.y + other.h
+		);
 	}
 
 	/**
@@ -85,7 +92,6 @@ export class Rect2 extends Abstract2DShape {
 			return false;
 		}
 
-
 		const thisMinY = this.y;
 		const thisMaxY = thisMinY + this.h;
 		const otherMinY = other.y;
@@ -100,7 +106,7 @@ export class Rect2 extends Abstract2DShape {
 
 	// Returns the overlap of this and [other], or null, if no such
 	//          overlap exists
-	public intersection(other: Rect2): Rect2|null {
+	public intersection(other: Rect2): Rect2 | null {
 		if (!this.intersects(other)) {
 			return null;
 		}
@@ -151,10 +157,7 @@ export class Rect2 extends Abstract2DShape {
 	// [margin] is the minimum distance between the new point and the edge
 	// of the resultant rectangle.
 	public grownToPoint(point: Point2, margin: number = 0): Rect2 {
-		const otherRect = new Rect2(
-			point.x - margin, point.y - margin,
-			margin * 2, margin * 2
-		);
+		const otherRect = new Rect2(point.x - margin, point.y - margin, margin * 2, margin * 2);
 		return this.union(otherRect);
 	}
 
@@ -170,23 +173,23 @@ export class Rect2 extends Abstract2DShape {
 			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,
+				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
-		);
+		return new Rect2(this.x - margin, this.y - margin, this.w + margin * 2, this.h + margin * 2);
 	}
 
 	public getClosestPointOnBoundaryTo(target: Point2) {
-		const closestEdgePoints = this.getEdges().map(edge => {
+		const closestEdgePoints = this.getEdges().map((edge) => {
 			return edge.closestPointTo(target);
 		});
 
-		let closest: Point2|null = null;
-		let closestDist: number|null = null;
+		let closest: Point2 | null = null;
+		let closestDist: number | null = null;
 		for (const point of closestEdgePoints) {
 			const dist = point.distanceTo(target);
 			if (closestDist === null || dist < closestDist) {
@@ -211,16 +214,11 @@ export class Rect2 extends Abstract2DShape {
 		}
 
 		const squareRadius = radius * radius;
-		return this.corners.every(corner => corner.minus(point).magnitudeSquared() < squareRadius);
+		return this.corners.every((corner) => corner.minus(point).magnitudeSquared() < squareRadius);
 	}
 
 	public get corners(): Point2[] {
-		return [
-			this.bottomRight,
-			this.topRight,
-			this.topLeft,
-			this.bottomLeft,
-		];
+		return [this.bottomRight, this.topRight, this.topLeft, this.bottomLeft];
 	}
 
 	public get maxDimension() {
@@ -272,7 +270,7 @@ export class Rect2 extends Abstract2DShape {
 
 		for (const edge of this.getEdges()) {
 			const intersection = edge.intersectsLineSegment(lineSegment);
-			intersection.forEach(point => result.push(point));
+			intersection.forEach((point) => result.push(point));
 		}
 
 		return result;
@@ -295,7 +293,7 @@ export class Rect2 extends Abstract2DShape {
 	// [affineTransform] is a transformation matrix that both scales and **translates**.
 	// the bounding box of this' four corners after transformed by the given affine transformation.
 	public transformedBoundingBox(affineTransform: Mat33): Rect2 {
-		return Rect2.bboxOf(this.corners.map(corner => affineTransform.transformVec2(corner)));
+		return Rect2.bboxOf(this.corners.map((corner) => affineTransform.transformVec2(corner)));
 	}
 
 	/** @return true iff this is equal to `other ± tolerance` */
@@ -307,13 +305,12 @@ export class Rect2 extends Abstract2DShape {
 		return `Rect(point(${this.x}, ${this.y}), size(${this.w}, ${this.h}))`;
 	}
 
-
 	public static fromCorners(corner1: Point2, corner2: Point2) {
 		return new Rect2(
 			Math.min(corner1.x, corner2.x),
 			Math.min(corner1.y, corner2.y),
 			Math.abs(corner1.x - corner2.x),
-			Math.abs(corner1.y - corner2.y)
+			Math.abs(corner1.y - corner2.y),
 		);
 	}
 
@@ -344,7 +341,7 @@ export class Rect2 extends Abstract2DShape {
 
 		return Rect2.fromCorners(
 			Vec2.of(minX - margin, minY - margin),
-			Vec2.of(maxX + margin, maxY + margin)
+			Vec2.of(maxX + margin, maxY + margin),
 		);
 	}
 
@@ -369,9 +366,7 @@ export class Rect2 extends Abstract2DShape {
 			maxY = Math.max(maxY, rect.y + rect.h);
 		}
 
-		return new Rect2(
-			minX, minY, maxX - minX, maxY - minY,
-		);
+		return new Rect2(minX, minY, maxX - minX, maxY - minY);
 	}
 
 	public static of(template: RectTemplate) {

package/src/shapes/Triangle.test.ts

@@ -19,43 +19,45 @@ describe('Triangle', () => {
 			}
 		});
 
-		it('signed distance function should be the negative distance to the edge '
-			+ 'of the triangle on the interior of a shape, same as distance outside of shape', () => {
-			const testTriangle = Triangle.fromVertices(Vec2.of(-1, -1), Vec2.of(0, 1), Vec2.of(1, -1));
-
-			// A point vertically above the triangle: Outside, so positive SDF
-			expect(testTriangle.signedDistance(Vec2.of(0, 2))).toBeCloseTo(1);
+		it(
+			'signed distance function should be the negative distance to the edge ' +
+				'of the triangle on the interior of a shape, same as distance outside of shape',
+			() => {
+				const testTriangle = Triangle.fromVertices(Vec2.of(-1, -1), Vec2.of(0, 1), Vec2.of(1, -1));
 
-			// Similarly, a point vertically below the triangle is outside, so should have positive SDF
-			expect(testTriangle.signedDistance(Vec2.of(0, -2))).toBeCloseTo(1);
+				// A point vertically above the triangle: Outside, so positive SDF
+				expect(testTriangle.signedDistance(Vec2.of(0, 2))).toBeCloseTo(1);
 
-			// A point just above the left side (and outside the triangle) should also have positive SDF
-			expect(testTriangle.signedDistance(Vec2.of(-0.8, 0.8))).toBeGreaterThan(0);
+				// Similarly, a point vertically below the triangle is outside, so should have positive SDF
+				expect(testTriangle.signedDistance(Vec2.of(0, -2))).toBeCloseTo(1);
 
+				// A point just above the left side (and outside the triangle) should also have positive SDF
+				expect(testTriangle.signedDistance(Vec2.of(-0.8, 0.8))).toBeGreaterThan(0);
 
-			const firstSide = testTriangle.getEdges()[0];
-			const firstSideMidpoint = firstSide.at(0.5);
-			const firstSideNormal = firstSide.direction.orthog();
+				const firstSide = testTriangle.getEdges()[0];
+				const firstSideMidpoint = firstSide.at(0.5);
+				const firstSideNormal = firstSide.direction.orthog();
 
-			// Move a point towards the first side
-			for (let t = 0.5; t > -0.5; t -= 0.1) {
-				const point = firstSideMidpoint.minus(firstSideNormal.times(t));
-				const distFromSide1 = firstSide.distance(point);
-				const signedDist = testTriangle.signedDistance(point);
+				// Move a point towards the first side
+				for (let t = 0.5; t > -0.5; t -= 0.1) {
+					const point = firstSideMidpoint.minus(firstSideNormal.times(t));
+					const distFromSide1 = firstSide.distance(point);
+					const signedDist = testTriangle.signedDistance(point);
 
-				// Inside the shape
-				if (t > 0) {
 					// Inside the shape
-					expect(testTriangle.containsPoint(point)).toBe(true);
+					if (t > 0) {
+						// Inside the shape
+						expect(testTriangle.containsPoint(point)).toBe(true);
 
-					expect(signedDist).toBeCloseTo(-distFromSide1);
-				} else {
-					// Outside the shape
-					expect(testTriangle.containsPoint(point)).toBe(false);
+						expect(signedDist).toBeCloseTo(-distFromSide1);
+					} else {
+						// Outside the shape
+						expect(testTriangle.containsPoint(point)).toBe(false);
 
-					expect(signedDist).toBeCloseTo(distFromSide1);
+						expect(signedDist).toBeCloseTo(distFromSide1);
+					}
 				}
-			}
-		});
+			},
+		);
 	});
-});
+});

package/src/shapes/Triangle.ts

@@ -5,7 +5,7 @@ import Abstract2DShape from './Abstract2DShape';
 import LineSegment2 from './LineSegment2';
 import Rect2 from './Rect2';
 
-type TriangleBoundary = [ LineSegment2, LineSegment2, LineSegment2 ];
+type TriangleBoundary = [LineSegment2, LineSegment2, LineSegment2];
 
 export default class Triangle extends Abstract2DShape {
 	/**
@@ -27,30 +27,26 @@ export default class Triangle extends Abstract2DShape {
 		return new Triangle(vertex1, vertex2, vertex3);
 	}
 
-	public get vertices(): [ Point2, Point2, Point2 ] {
-		return [ this.vertex1, this.vertex2, this.vertex3 ];
+	public get vertices(): [Point2, Point2, Point2] {
+		return [this.vertex1, this.vertex2, this.vertex3];
 	}
 
-	public map(mapping: (vertex: Vec3)=>Vec3): Triangle {
-		return new Triangle(
-			mapping(this.vertex1),
-			mapping(this.vertex2),
-			mapping(this.vertex3),
-		);
+	public map(mapping: (vertex: Vec3) => Vec3): Triangle {
+		return new Triangle(mapping(this.vertex1), mapping(this.vertex2), mapping(this.vertex3));
 	}
 
 	// Transform, treating this as composed of 2D points.
 	public transformed2DBy(affineTransform: Mat33) {
-		return this.map(vertex => affineTransform.transformVec2(vertex));
+		return this.map((vertex) => affineTransform.transformVec2(vertex));
 	}
 
 	// Transforms this by a linear transform --- verticies are treated as
 	// 3D points.
 	public transformedBy(linearTransform: Mat33) {
-		return this.map(vertex => linearTransform.transformVec3(vertex));
+		return this.map((vertex) => linearTransform.transformVec3(vertex));
 	}
 
-	#sides: TriangleBoundary|undefined = undefined;
+	#sides: TriangleBoundary | undefined = undefined;
 
 	/**
 	 * Returns the sides of this triangle, as an array of `LineSegment2`s.
@@ -67,7 +63,7 @@ export default class Triangle extends Abstract2DShape {
 		const side2 = new LineSegment2(this.vertex2, this.vertex3);
 		const side3 = new LineSegment2(this.vertex3, this.vertex1);
 
-		const sides: TriangleBoundary = [ side1, side2, side3 ];
+		const sides: TriangleBoundary = [side1, side2, side3];
 		this.#sides = sides;
 		return sides;
 	}
@@ -76,15 +72,17 @@ export default class Triangle extends Abstract2DShape {
 		const result: Point2[] = [];
 
 		for (const edge of this.getEdges()) {
-			edge.intersectsLineSegment(lineSegment)
-				.forEach(point => result.push(point));
+			edge.intersectsLineSegment(lineSegment).forEach((point) => result.push(point));
 		}
 
 		return result;
 	}
 
 	/** @inheritdoc */
-	public override containsPoint(point: Vec3, epsilon: number = Abstract2DShape.smallValue): boolean {
+	public override containsPoint(
+		point: Vec3,
+		epsilon: number = Abstract2DShape.smallValue,
+	): boolean {
 		// Project `point` onto normals to each of this' sides.
 		// Uses the Separating Axis Theorem (https://en.wikipedia.org/wiki/Hyperplane_separation_theorem#Use_in_collision_detection)
 		const sides = this.getEdges();
@@ -103,7 +101,8 @@ export default class Triangle extends Abstract2DShape {
 
 			const projPoint = orthog.dot(point);
 
-			const inProjection = projPoint >= minProjVertex - epsilon && projPoint <= maxProjVertex + epsilon;
+			const inProjection =
+				projPoint >= minProjVertex - epsilon && projPoint <= maxProjVertex + epsilon;
 			if (!inProjection) {
 				return false;
 			}
@@ -120,7 +119,7 @@ export default class Triangle extends Abstract2DShape {
 	 */
 	public override signedDistance(point: Vec3): number {
 		const sides = this.getEdges();
-		const distances = sides.map(side => side.distance(point));
+		const distances = sides.map((side) => side.distance(point));
 		const distance = Math.min(...distances);
 
 		// If the point is in this' interior, signedDistance must return a negative