@js-draw/math 1.21.3 → 1.23.1

package/src/polynomial/solveQuadratic.test.ts

@@ -1,9 +1,8 @@
-
 import solveQuadratic from './solveQuadratic';
 
 describe('solveQuadratic', () => {
 	it('should solve linear equations', () => {
-		expect(solveQuadratic(0, 1, 2)).toMatchObject([ -2, -2 ]);
+		expect(solveQuadratic(0, 1, 2)).toMatchObject([-2, -2]);
 		expect(solveQuadratic(0, 0, 2)[0]).toBeNaN();
 	});
 
@@ -11,21 +10,48 @@ describe('solveQuadratic', () => {
 		type TestCase = [[number, number, number], [number, number]];
 
 		const testCases: TestCase[] = [
-			[ [ 1, 0, 0 ], [ 0, 0 ] ],
-			[ [ 2, 0, 0 ], [ 0, 0 ] ],
+			[
+				[1, 0, 0],
+				[0, 0],
+			],
+			[
+				[2, 0, 0],
+				[0, 0],
+			],
 
-			[ [ 1, 0, -1 ], [ 1, -1 ] ],
-			[ [ 1, 0, -4 ], [ 2, -2 ] ],
-			[ [ 1, 0, 4 ], [ NaN, NaN ] ],
+			[
+				[1, 0, -1],
+				[1, -1],
+			],
+			[
+				[1, 0, -4],
+				[2, -2],
+			],
+			[
+				[1, 0, 4],
+				[NaN, NaN],
+			],
 
-			[ [ 1, 1, 0 ], [ 0, -1 ] ],
-			[ [ 1, 2, 0 ], [ 0, -2 ] ],
+			[
+				[1, 1, 0],
+				[0, -1],
+			],
+			[
+				[1, 2, 0],
+				[0, -2],
+			],
 
-			[ [ 1, 2, 1 ], [ -1, -1 ] ],
-			[ [ -9, 2, 1/3 ], [ 1/3, -1/9 ] ],
+			[
+				[1, 2, 1],
+				[-1, -1],
+			],
+			[
+				[-9, 2, 1 / 3],
+				[1 / 3, -1 / 9],
+			],
 		];
 
-		for (const [ testCase, solution ] of testCases) {
+		for (const [testCase, solution] of testCases) {
 			const foundSolutions = solveQuadratic(...testCase);
 			for (let i = 0; i < 2; i++) {
 				if (isNaN(solution[i]) && isNaN(foundSolutions[i])) {
@@ -36,4 +62,4 @@ describe('solveQuadratic', () => {
 			}
 		}
 	});
-});
+});

package/src/polynomial/solveQuadratic.ts

@@ -1,4 +1,3 @@
-
 /**
  * Solves an equation of the form ax² + bx + c = 0.
  * The larger solution is returned first.
@@ -21,13 +20,13 @@ const solveQuadratic = (a: number, b: number, c: number): [number, number] => {
 			solution = -c / b;
 		}
 
-		return [ solution, solution ];
+		return [solution, solution];
 	}
 
 	const discriminant = b * b - 4 * a * c;
 
 	if (discriminant < 0) {
-		return [ NaN, NaN ];
+		return [NaN, NaN];
 	}
 
 	const rootDiscriminant = Math.sqrt(discriminant);
@@ -35,9 +34,9 @@ const solveQuadratic = (a: number, b: number, c: number): [number, number] => {
 	const solution2 = (-b - rootDiscriminant) / (2 * a);
 
 	if (solution1 > solution2) {
-		return [ solution1, solution2 ];
+		return [solution1, solution2];
 	} else {
-		return [ solution2, solution1 ];
+		return [solution2, solution1];
 	}
 };
-export default solveQuadratic;
+export default solveQuadratic;

package/src/rounding/cleanUpNumber.test.ts

@@ -12,4 +12,4 @@ it('cleanUpNumber', () => {
 	expect(cleanUpNumber('1234.5')).toBe('1234.5');
 	expect(cleanUpNumber('1234.500')).toBe('1234.5');
 	expect(cleanUpNumber('1.1368683772161603e-13')).toBe('0');
-});
+});

package/src/rounding/constants.ts

@@ -1,3 +1 @@
-
-
-export const numberRegex = /^([-]?)(\d*)[.](\d+)$/;
+export const numberRegex = /^([-]?)(\d*)[.](\d+)$/;

package/src/rounding/getLenAfterDecimal.ts

@@ -1,6 +1,5 @@
 import { numberRegex } from './constants';
 
-
 /**
  * Returns the length of `numberAsString` after a decimal point.
  *
@@ -16,7 +15,7 @@ export const getLenAfterDecimal = (numberAsString: string) => {
 		// like NaN or Infinity)
 		if (numberAsString.search(/[eE]/) !== -1 || /^[a-zA-Z]+$/.exec(numberAsString)) {
 			return -1;
-		// Or it has no decimal point
+			// Or it has no decimal point
 		} else {
 			return 0;
 		}

package/src/rounding/lib.ts

@@ -1,2 +1 @@
-
-export { toRoundedString } from './toRoundedString';
+export { toRoundedString } from './toRoundedString';

package/src/rounding/toRoundedString.test.ts

@@ -29,4 +29,4 @@ describe('toRoundedString', () => {
 		expect(toRoundedString(-10.123499)).toBe('-10.123499');
 		expect(toRoundedString(0.00123499)).toBe('.00123499');
 	});
-});
+});

package/src/rounding/toStringOfSamePrecision.test.ts

@@ -1,6 +1,5 @@
 import { toStringOfSamePrecision } from './toStringOfSamePrecision';
 
-
 it('toStringOfSamePrecision', () => {
 	expect(toStringOfSamePrecision(1.23456, '1.12')).toBe('1.23');
 	expect(toStringOfSamePrecision(1.23456, '1.120')).toBe('1.235');
@@ -18,4 +17,4 @@ it('toStringOfSamePrecision', () => {
 	expect(toStringOfSamePrecision(-0.9999999999999432, '291.3')).toBe('-1');
 	expect(toStringOfSamePrecision(9998.9, '.1', '-11')).toBe('9998.9');
 	expect(toStringOfSamePrecision(-14.20000000000002, '.000001', '-11')).toBe('-14.2');
-});
+});

package/src/rounding/toStringOfSamePrecision.ts

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

package/src/shapes/BezierJSWrapper.ts

@@ -14,11 +14,9 @@ import Parameterized2DShape from './Parameterized2DShape';
  * @internal
  */
 export abstract class BezierJSWrapper extends Parameterized2DShape {
-	#bezierJs: Bezier|null = null;
+	#bezierJs: Bezier | null = null;
 
-	protected constructor(
-		bezierJsBezier?: Bezier
-	) {
+	protected constructor(bezierJsBezier?: Bezier) {
 		super();
 
 		if (bezierJsBezier) {
@@ -31,7 +29,7 @@ export abstract class BezierJSWrapper extends Parameterized2DShape {
 
 	protected getBezier() {
 		if (!this.#bezierJs) {
-			this.#bezierJs = new Bezier(this.getPoints().map(p => p.xy));
+			this.#bezierJs = new Bezier(this.getPoints().map((p) => p.xy));
 		}
 		return this.#bezierJs;
 	}
@@ -58,6 +56,7 @@ export abstract class BezierJSWrapper extends Parameterized2DShape {
 		return Vec2.ofXY(this.getBezier().get(t));
 	}
 
+	/** @returns the curve's directional derivative at `t`. */
 	public derivativeAt(t: number): Point2 {
 		return Vec2.ofXY(this.getBezier().derivative(t));
 	}
@@ -66,6 +65,7 @@ export abstract class BezierJSWrapper extends Parameterized2DShape {
 		return Vec2.ofXY((this.getBezier() as any).dderivative(t));
 	}
 
+	/** @returns the [normal vector](https://en.wikipedia.org/wiki/Normal_(geometry)) to this curve at `t`. */
 	public normal(t: number): Vec2 {
 		return Vec2.ofXY(this.getBezier().normal(t));
 	}
@@ -96,41 +96,49 @@ export abstract class BezierJSWrapper extends Parameterized2DShape {
 		const asLine = LineSegment2.ofSmallestContainingPoints(this.getPoints());
 		if (asLine) {
 			const intersection = asLine.intersectsLineSegment(line);
-			return intersection.map(p => this.nearestPointTo(p).parameterValue);
+			return intersection.map((p) => this.nearestPointTo(p).parameterValue);
 		}
 
 		const bezier = this.getBezier();
 
-		return bezier.intersects(line).map(t => {
-			// We're using the .intersects(line) function, which is documented
-			// to always return numbers. However, to satisfy the type checker (and
-			// possibly improperly-defined types),
-			if (typeof t === 'string') {
-				t = parseFloat(t);
-			}
-
-			const point = Vec2.ofXY(this.at(t));
-
-			// Ensure that the intersection is on the line segment
-			if (point.distanceTo(line.p1) > line.length
-					|| point.distanceTo(line.p2) > line.length) {
-				return null;
-			}
-
-			return t;
-		}).filter(entry => entry !== null);
+		return bezier
+			.intersects(line)
+			.map((t) => {
+				// We're using the .intersects(line) function, which is documented
+				// to always return numbers. However, to satisfy the type checker (and
+				// possibly improperly-defined types),
+				if (typeof t === 'string') {
+					t = parseFloat(t);
+				}
+
+				const point = Vec2.ofXY(this.at(t));
+
+				// Ensure that the intersection is on the line segment
+				if (point.distanceTo(line.p1) > line.length || point.distanceTo(line.p2) > line.length) {
+					return null;
+				}
+
+				return t;
+			})
+			.filter((entry) => entry !== null);
 	}
 
 	public override splitAt(t: number): [BezierJSWrapper] | [BezierJSWrapper, BezierJSWrapper] {
 		if (t <= 0 || t >= 1) {
-			return [ this ];
+			return [this];
 		}
 
 		const bezier = this.getBezier();
 		const split = bezier.split(t);
 		return [
-			new BezierJSWrapperImpl(split.left.points.map(point => Vec2.ofXY(point)), split.left),
-			new BezierJSWrapperImpl(split.right.points.map(point => Vec2.ofXY(point)), split.right),
+			new BezierJSWrapperImpl(
+				split.left.points.map((point) => Vec2.ofXY(point)),
+				split.left,
+			),
+			new BezierJSWrapperImpl(
+				split.right.points.map((point) => Vec2.ofXY(point)),
+				split.right,
+			),
 		];
 	}
 
@@ -162,7 +170,7 @@ export abstract class BezierJSWrapper extends Parameterized2DShape {
 
 		// Start by testing a few points:
 		const pointsToTest = 4;
-		for (let i = 0; i < pointsToTest; i ++) {
+		for (let i = 0; i < pointsToTest; i++) {
 			const testT = i / (pointsToTest - 1);
 			const testMinSqrDist = sqrDistAt(testT);
 
@@ -181,8 +189,12 @@ export abstract class BezierJSWrapper extends Parameterized2DShape {
 			const bPrime = this.derivativeAt(t);
 			const bPrimePrime = this.secondDerivativeAt(t);
 			return (
-				2 * bPrime.x * bPrime.x  +  2 * b.x * bPrimePrime.x  -  2 * point.x * bPrimePrime.x
-				+ 2 * bPrime.y * bPrime.y  +  2 * b.y * bPrimePrime.y  -  2 * point.y * bPrimePrime.y
+				2 * bPrime.x * bPrime.x +
+				2 * b.x * bPrimePrime.x -
+				2 * point.x * bPrimePrime.x +
+				2 * bPrime.y * bPrime.y +
+				2 * b.y * bPrimePrime.y -
+				2 * point.y * bPrimePrime.y
 			);
 		};
 		// Because we're zeroing f'(t), we also need to be able to compute it:
@@ -191,8 +203,7 @@ export abstract class BezierJSWrapper extends Parameterized2DShape {
 			const b = this.at(t);
 			const bPrime = this.derivativeAt(t);
 			return (
-				2 * b.x * bPrime.x - 2 * point.x * bPrime.x
-				+ 2 * b.y * bPrime.y - 2 * point.y * bPrime.y
+				2 * b.x * bPrime.x - 2 * point.x * bPrime.x + 2 * b.y * bPrime.y - 2 * point.y * bPrime.y
 			);
 		};
 
@@ -226,7 +237,10 @@ export abstract class BezierJSWrapper extends Parameterized2DShape {
 	}
 
 	public intersectsBezier(other: BezierJSWrapper) {
-		const intersections = this.getBezier().intersects(other.getBezier()) as (string[] | null | undefined);
+		const intersections = this.getBezier().intersects(other.getBezier()) as
+			| string[]
+			| null
+			| undefined;
 		if (!intersections || intersections.length === 0) {
 			return [];
 		}
@@ -239,7 +253,7 @@ export abstract class BezierJSWrapper extends Parameterized2DShape {
 
 			if (!match) {
 				throw new Error(
-					`Incorrect format returned by .intersects: ${intersections} should be array of "number/number"!`
+					`Incorrect format returned by .intersects: ${intersections} should be array of "number/number"!`,
 				);
 			}
 
@@ -253,7 +267,9 @@ export abstract class BezierJSWrapper extends Parameterized2DShape {
 	}
 
 	public override toString() {
-		return `Bézier(${this.getPoints().map(point => point.toString()).join(', ')})`;
+		return `Bézier(${this.getPoints()
+			.map((point) => point.toString())
+			.join(', ')})`;
 	}
 }
 
@@ -262,7 +278,10 @@ export abstract class BezierJSWrapper extends Parameterized2DShape {
  * around a `Bezier`.
  */
 class BezierJSWrapperImpl extends BezierJSWrapper {
-	public constructor(private controlPoints: readonly Point2[], curve?: Bezier) {
+	public constructor(
+		private controlPoints: readonly Point2[],
+		curve?: Bezier,
+	) {
 		super(curve);
 	}
 
@@ -271,4 +290,4 @@ class BezierJSWrapperImpl extends BezierJSWrapper {
 	}
 }
 
-export default BezierJSWrapper;
+export default BezierJSWrapper;

package/src/shapes/CubicBezier.ts

@@ -23,13 +23,13 @@ class CubicBezier extends BezierJSWrapper {
 	}
 
 	public override getPoints() {
-		return [ this.p0, this.p1, this.p2, this.p3 ];
+		return [this.p0, this.p1, this.p2, this.p3];
 	}
 
 	/** Returns an overestimate of this shape's bounding box. */
 	public override getLooseBoundingBox(): Rect2 {
-		return Rect2.bboxOf([ this.p0, this.p1, this.p2, this.p3 ]);
+		return Rect2.bboxOf([this.p0, this.p1, this.p2, this.p3]);
 	}
 }
 
-export default CubicBezier;
+export default CubicBezier;

package/src/shapes/LineSegment2.test.ts

@@ -2,7 +2,6 @@ import LineSegment2 from './LineSegment2';
 import { Vec2 } from '../Vec2';
 import Mat33 from '../Mat33';
 
-
 describe('Line2', () => {
 	it('x and y axes should intersect at (0, 0)', () => {
 		const xAxis = new LineSegment2(Vec2.of(-10, 0), Vec2.of(10, 0));
@@ -65,7 +64,7 @@ describe('Line2', () => {
 		// Points taken from issue observed directly in editor
 		const p1 = Vec2.of(769.6126045442547, 221.037877485765);
 		const p2 = Vec2.of(770.3873954557453, 224.962122514235);
-		const p3 = Vec2.of( 763.3590010920082, 223.66723995850086);
+		const p3 = Vec2.of(763.3590010920082, 223.66723995850086);
 		const p4 = Vec2.of(763.5494167642871, 223.66723995850086);
 
 		const line1 = new LineSegment2(p1, p2);
@@ -115,7 +114,7 @@ describe('Line2', () => {
 		// Halving
 		//
 		expect(lineSegment.at(0.5)).objEq(midpoint);
-		const [ firstHalf, secondHalf ] = lineSegment.splitAt(0.5);
+		const [firstHalf, secondHalf] = lineSegment.splitAt(0.5);
 
 		if (!secondHalf) {
 			throw new Error('Splitting a line segment in half should yield two line segments.');
@@ -136,24 +135,32 @@ describe('Line2', () => {
 	it('equivalence check should allow ignoring direction', () => {
 		expect(new LineSegment2(Vec2.zero, Vec2.unitX)).objEq(new LineSegment2(Vec2.zero, Vec2.unitX));
 		expect(new LineSegment2(Vec2.zero, Vec2.unitX)).objEq(new LineSegment2(Vec2.unitX, Vec2.zero));
-		expect(new LineSegment2(Vec2.zero, Vec2.unitX)).not.objEq(new LineSegment2(Vec2.unitX, Vec2.zero), { ignoreDirection: false });
+		expect(new LineSegment2(Vec2.zero, Vec2.unitX)).not.objEq(
+			new LineSegment2(Vec2.unitX, Vec2.zero),
+			{ ignoreDirection: false },
+		);
 	});
 
 	it('should support creating from a collection of points', () => {
 		expect(LineSegment2.ofSmallestContainingPoints([])).toBeNull();
 		expect(LineSegment2.ofSmallestContainingPoints([Vec2.of(1, 1)])).toBeNull();
-		expect(LineSegment2.ofSmallestContainingPoints(
-			[Vec2.of(1, 1), Vec2.of(1, 2), Vec2.of(3, 3)]
-		)).toBeNull();
-
-		expect(LineSegment2.ofSmallestContainingPoints(
-			[Vec2.of(1, 1), Vec2.of(1, 2)]
-		)).objEq(new LineSegment2(Vec2.of(1, 1), Vec2.of(1, 2)));
-		expect(LineSegment2.ofSmallestContainingPoints(
-			[Vec2.of(1, 1), Vec2.of(2, 2), Vec2.of(3, 3)]
-		)).objEq(new LineSegment2(Vec2.of(1, 1), Vec2.of(3, 3)));
-		expect(LineSegment2.ofSmallestContainingPoints(
-			[Vec2.of(3, 3), Vec2.of(2, 2), Vec2.of(2.4, 2.4), Vec2.of(3, 3)]
-		)).objEq(new LineSegment2(Vec2.of(2, 2), Vec2.of(3, 3)));
+		expect(
+			LineSegment2.ofSmallestContainingPoints([Vec2.of(1, 1), Vec2.of(1, 2), Vec2.of(3, 3)]),
+		).toBeNull();
+
+		expect(LineSegment2.ofSmallestContainingPoints([Vec2.of(1, 1), Vec2.of(1, 2)])).objEq(
+			new LineSegment2(Vec2.of(1, 1), Vec2.of(1, 2)),
+		);
+		expect(
+			LineSegment2.ofSmallestContainingPoints([Vec2.of(1, 1), Vec2.of(2, 2), Vec2.of(3, 3)]),
+		).objEq(new LineSegment2(Vec2.of(1, 1), Vec2.of(3, 3)));
+		expect(
+			LineSegment2.ofSmallestContainingPoints([
+				Vec2.of(3, 3),
+				Vec2.of(2, 2),
+				Vec2.of(2.4, 2.4),
+				Vec2.of(3, 3),
+			]),
+		).objEq(new LineSegment2(Vec2.of(2, 2), Vec2.of(3, 3)));
 	});
 });

package/src/shapes/LineSegment2.ts

@@ -42,7 +42,7 @@ export class LineSegment2 extends Parameterized2DShape {
 	/** Creates a new `LineSegment2` from its endpoints. */
 	public constructor(
 		private readonly point1: Point2,
-		private readonly point2: Point2
+		private readonly point2: Point2,
 	) {
 		super();
 
@@ -70,7 +70,7 @@ export class LineSegment2 extends Parameterized2DShape {
 	public static ofSmallestContainingPoints(points: readonly Point2[]) {
 		if (points.length <= 1) return null;
 
-		const sorted = [...points].sort((a, b) => a.x !== b.x ? a.x - b.x : a.y - b.y);
+		const sorted = [...points].sort((a, b) => (a.x !== b.x ? a.x - b.x : a.y - b.y));
 		const line = new LineSegment2(sorted[0], sorted[sorted.length - 1]);
 
 		for (const point of sorted) {
@@ -127,15 +127,12 @@ export class LineSegment2 extends Parameterized2DShape {
 		return this.direction;
 	}
 
-	public splitAt(t: number): [LineSegment2]|[LineSegment2,LineSegment2] {
+	public splitAt(t: number): [LineSegment2] | [LineSegment2, LineSegment2] {
 		if (t <= 0 || t >= 1) {
 			return [this];
 		}
 
-		return [
-			new LineSegment2(this.point1, this.at(t)),
-			new LineSegment2(this.at(t), this.point2),
-		];
+		return [new LineSegment2(this.point1, this.at(t)), new LineSegment2(this.at(t), this.point2)];
 	}
 
 	/**
@@ -146,7 +143,7 @@ export class LineSegment2 extends Parameterized2DShape {
 	 *              This will change in a future release.
 	 * @deprecated
 	 */
-	public intersection(other: LineSegment2): IntersectionResult|null {
+	public intersection(other: LineSegment2): IntersectionResult | null {
 		// TODO(v2.0.0): Make this return a `t` value from `0` to `1`.
 
 		// We want x₁(t) = x₂(t) and y₁(t) = y₂(t)
@@ -191,21 +188,18 @@ export class LineSegment2 extends Parameterized2DShape {
 
 			const xIntersect = this.point1.x;
 			const yIntersect =
-				(this.point1.x - other.point1.x) * other.direction.y / other.direction.x + other.point1.y;
+				((this.point1.x - other.point1.x) * other.direction.y) / other.direction.x + other.point1.y;
 			resultPoint = Vec2.of(xIntersect, yIntersect);
 			resultT = (yIntersect - this.point1.y) / this.direction.y;
 		} else {
 			// From above,
 			// x = ((o₁ᵧ - o₂ᵧ)(d₁ₓd₂ₓ) + (d₂ᵧd₁ₓ)(o₂ₓ) - (d₁ᵧd₂ₓ)(o₁ₓ))/(d₂ᵧd₁ₓ - d₁ᵧd₂ₓ)
-			const numerator = (
-				(this.point1.y - other.point1.y) * this.direction.x * other.direction.x
-				+ this.direction.x * other.direction.y * other.point1.x
-				- this.direction.y * other.direction.x * this.point1.x
-			);
-			const denominator = (
-				other.direction.y * this.direction.x
-				- this.direction.y * other.direction.x
-			);
+			const numerator =
+				(this.point1.y - other.point1.y) * this.direction.x * other.direction.x +
+				this.direction.x * other.direction.y * other.point1.x -
+				this.direction.y * other.direction.x * this.point1.x;
+			const denominator =
+				other.direction.y * this.direction.x - this.direction.y * other.direction.x;
 
 			// Avoid dividing by zero. It means there is no intersection
 			if (denominator === 0) {
@@ -225,10 +219,12 @@ export class LineSegment2 extends Parameterized2DShape {
 		const resultToP3 = resultPoint.distanceTo(other.point1);
 		const resultToP4 = resultPoint.distanceTo(other.point2);
 
-		if (resultToP1 > this.length
-			|| resultToP2 > this.length
-			|| resultToP3 > other.length
-			|| resultToP4 > other.length) {
+		if (
+			resultToP1 > this.length ||
+			resultToP2 > this.length ||
+			resultToP3 > other.length ||
+			resultToP4 > other.length
+		) {
 			return null;
 		}
 
@@ -246,7 +242,7 @@ export class LineSegment2 extends Parameterized2DShape {
 		const intersection = this.intersection(lineSegment);
 
 		if (intersection) {
-			return [ intersection.t / this.length ];
+			return [intersection.t / this.length];
 		}
 		return [];
 	}
@@ -263,7 +259,7 @@ export class LineSegment2 extends Parameterized2DShape {
 		const intersection = this.intersection(lineSegment);
 
 		if (intersection) {
-			return [ intersection.point ];
+			return [intersection.point];
 		}
 		return [];
 	}
@@ -273,7 +269,7 @@ export class LineSegment2 extends Parameterized2DShape {
 		return this.nearestPointTo(target).point;
 	}
 
-	public override nearestPointTo(target: Vec3): { point: Vec3; parameterValue: number; } {
+	public override nearestPointTo(target: Vec3): { point: Vec3; parameterValue: number } {
 		// Distance from P1 along this' direction.
 		const projectedDistFromP1 = target.minus(this.p1).dot(this.direction);
 		const projectedDistFromP2 = this.length - projectedDistFromP1;
@@ -304,7 +300,8 @@ export class LineSegment2 extends Parameterized2DShape {
 	/** Returns a copy of this line segment transformed by the given `affineTransfm`. */
 	public transformedBy(affineTransfm: Mat33): LineSegment2 {
 		return new LineSegment2(
-			affineTransfm.transformVec2(this.p1), affineTransfm.transformVec2(this.p2)
+			affineTransfm.transformVec2(this.p1),
+			affineTransfm.transformVec2(this.p2),
 		);
 	}
 
@@ -324,7 +321,7 @@ export class LineSegment2 extends Parameterized2DShape {
 	 * - `tolerance`: The maximum difference between endpoints. (Default: 0)
 	 * - `ignoreDirection`: Allow matching a version of `this` with opposite direction. (Default: `true`)
 	 */
-	public eq(other: LineSegment2, options?: { tolerance?: number, ignoreDirection?: boolean }) {
+	public eq(other: LineSegment2, options?: { tolerance?: number; ignoreDirection?: boolean }) {
 		if (!(other instanceof LineSegment2)) {
 			return false;
 		}
@@ -333,8 +330,8 @@ export class LineSegment2 extends Parameterized2DShape {
 		const ignoreDirection = options?.ignoreDirection ?? true;
 
 		return (
-			(other.p1.eq(this.p1, tolerance) && other.p2.eq(this.p2, tolerance))
-			|| (ignoreDirection && other.p1.eq(this.p2, tolerance) && other.p2.eq(this.p1, tolerance))
+			(other.p1.eq(this.p1, tolerance) && other.p2.eq(this.p2, tolerance)) ||
+			(ignoreDirection && other.p1.eq(this.p2, tolerance) && other.p2.eq(this.p1, tolerance))
 		);
 	}
 }

package/src/shapes/Parameterized2DShape.ts

@@ -20,13 +20,15 @@ export abstract class Parameterized2DShape extends Abstract2DShape {
 	/**
 	 * Divides this shape into two separate shapes at parameter value $t$.
 	 */
-	abstract splitAt(t: number): [ Parameterized2DShape ] | [ Parameterized2DShape, Parameterized2DShape ];
+	abstract splitAt(
+		t: number,
+	): [Parameterized2DShape] | [Parameterized2DShape, Parameterized2DShape];
 
 	/**
 	 * Returns the nearest point on `this` to `point` and the `parameterValue` at which
 	 * that point occurs.
 	 */
-	abstract nearestPointTo(point: Point2): { point: Point2, parameterValue: number };
+	abstract nearestPointTo(point: Point2): { point: Point2; parameterValue: number };
 
 	/**
 	 * Returns the **parameter values** at which `lineSegment` intersects this shape.
@@ -35,9 +37,8 @@ export abstract class Parameterized2DShape extends Abstract2DShape {
 	 */
 	public abstract argIntersectsLineSegment(lineSegment: LineSegment2): number[];
 
-
 	public override intersectsLineSegment(line: LineSegment2): Point2[] {
-		return this.argIntersectsLineSegment(line).map(t => this.at(t));
+		return this.argIntersectsLineSegment(line).map((t) => this.at(t));
 	}
 }
 

package/src/shapes/Path.fromString.test.ts

@@ -27,7 +27,7 @@ describe('Path.fromString', () => {
 			},
 			{
 				kind: PathCommandType.MoveTo,
-				point: Vec2.of(3,3),
+				point: Vec2.of(3, 3),
 			},
 		]);
 		expect(path3.startPoint).toMatchObject(Vec2.of(1, 1));
@@ -71,7 +71,7 @@ describe('Path.fromString', () => {
 		const path1 = Path.fromString('m3,3 l1,2 l1,1 z');
 		const path2 = Path.fromString('m3,3 l1,2 l1,1 Z');
 
-		expect(path1.startPoint).toMatchObject(Vec2.of(3,3));
+		expect(path1.startPoint).toMatchObject(Vec2.of(3, 3));
 		expect(path2.startPoint).toMatchObject(path1.startPoint);
 		expect(path1.parts).toMatchObject(path2.parts);
 		expect(path1.parts).toMatchObject([
@@ -86,7 +86,7 @@ describe('Path.fromString', () => {
 			{
 				kind: PathCommandType.LineTo,
 				point: path1.startPoint,
-			}
+			},
 		]);
 	});
 
@@ -128,7 +128,7 @@ describe('Path.fromString', () => {
 				controlPoint1: Vec2.of(1, 1),
 				controlPoint2: Vec2.of(0.1, 0.1),
 				endPoint: Vec2.zero,
-			}
+			},
 		]);
 	});
 
@@ -220,4 +220,4 @@ describe('Path.fromString', () => {
 		]);
 		expect(path.startPoint).toMatchObject(Vec2.of(5, 10));
 	});
-});
+});