@js-draw/math 1.21.3 → 1.23.1

package/src/Mat33.ts

@@ -4,11 +4,7 @@ import Vec3 from './Vec3';
 /**
  * See {@link Mat33.toArray}.
  */
-export type Mat33Array = [
-	number, number, number,
-	number, number, number,
-	number, number, number,
-];
+export type Mat33Array = [number, number, number, number, number, number, number, number, number];
 
 /**
  * Represents a three dimensional linear transformation or
@@ -82,13 +78,9 @@ export class Mat33 {
 
 		public readonly c1: number,
 		public readonly c2: number,
-		public readonly c3: number
+		public readonly c3: number,
 	) {
-		this.rows = [
-			Vec3.of(a1, a2, a3),
-			Vec3.of(b1, b2, b3),
-			Vec3.of(c1, c2, c3),
-		];
+		this.rows = [Vec3.of(a1, a2, a3), Vec3.of(b1, b2, b3), Vec3.of(c1, c2, c3)];
 	}
 
 	/**
@@ -102,19 +94,11 @@ export class Mat33 {
 	 * $$
 	 */
 	public static ofRows(r1: Vec3, r2: Vec3, r3: Vec3): Mat33 {
-		return new Mat33(
-			r1.x, r1.y, r1.z,
-			r2.x, r2.y, r2.z,
-			r3.x, r3.y, r3.z
-		);
+		return new Mat33(r1.x, r1.y, r1.z, r2.x, r2.y, r2.z, r3.x, r3.y, r3.z);
 	}
 
 	/** The 3x3 [identity matrix](https://en.wikipedia.org/wiki/Identity_matrix). */
-	public static identity = new Mat33(
-		1, 0, 0,
-		0, 1, 0,
-		0, 0, 1
-	);
+	public static identity = new Mat33(1, 0, 0, 0, 1, 0, 0, 0, 1);
 
 	/**
 	 * Either returns the inverse of this, or, if this matrix is singular/uninvertable,
@@ -131,23 +115,15 @@ export class Mat33 {
 		return this.computeInverse() !== null;
 	}
 
-	private cachedInverse: Mat33|undefined|null = undefined;
-	private computeInverse(): Mat33|null {
+	private cachedInverse: Mat33 | undefined | null = undefined;
+	private computeInverse(): Mat33 | null {
 		if (this.cachedInverse !== undefined) {
 			return this.cachedInverse;
 		}
 
-		const toIdentity = [
-			this.rows[0],
-			this.rows[1],
-			this.rows[2],
-		];
+		const toIdentity = [this.rows[0], this.rows[1], this.rows[2]];
 
-		const toResult = [
-			Vec3.unitX,
-			Vec3.unitY,
-			Vec3.unitZ,
-		];
+		const toResult = [Vec3.unitX, Vec3.unitY, Vec3.unitZ];
 
 		// Convert toIdentity to the identity matrix and
 		// toResult to the inverse through elementary row operations
@@ -199,29 +175,27 @@ export class Mat33 {
 			for (let i = 1; i <= 2; i++) {
 				const otherRowIdx = (cursor + i) % 3;
 				scale = -toIdentity[otherRowIdx].at(cursor);
-				toIdentity[otherRowIdx] = toIdentity[otherRowIdx].plus(
-					cursorToIdentityRow.times(scale)
-				);
-				toResult[otherRowIdx] = toResult[otherRowIdx].plus(
-					cursorToResultRow.times(scale)
-				);
+				toIdentity[otherRowIdx] = toIdentity[otherRowIdx].plus(cursorToIdentityRow.times(scale));
+				toResult[otherRowIdx] = toResult[otherRowIdx].plus(cursorToResultRow.times(scale));
 			}
 		}
 
-		const inverse = Mat33.ofRows(
-			toResult[0],
-			toResult[1],
-			toResult[2]
-		);
+		const inverse = Mat33.ofRows(toResult[0], toResult[1], toResult[2]);
 		this.cachedInverse = inverse;
 		return inverse;
 	}
 
 	public transposed(): Mat33 {
 		return new Mat33(
-			this.a1, this.b1, this.c1,
-			this.a2, this.b2, this.c2,
-			this.a3, this.b3, this.c3
+			this.a1,
+			this.b1,
+			this.c1,
+			this.a2,
+			this.b2,
+			this.c2,
+			this.a3,
+			this.b3,
+			this.c3,
 		);
 	}
 
@@ -256,9 +230,15 @@ export class Mat33 {
 		};
 
 		return new Mat33(
-			at(0, 0), at(0, 1), at(0, 2),
-			at(1, 0), at(1, 1), at(1, 2),
-			at(2, 0), at(2, 1), at(2, 2)
+			at(0, 0),
+			at(0, 1),
+			at(0, 2),
+			at(1, 0),
+			at(1, 1),
+			at(1, 2),
+			at(2, 0),
+			at(2, 1),
+			at(2, 2),
 		);
 	}
 
@@ -288,11 +268,7 @@ export class Mat33 {
 	 * This is the standard way of transforming vectors in ℝ³.
 	 */
 	public transformVec3(other: Vec3): Vec3 {
-		return Vec3.of(
-			this.rows[0].dot(other),
-			this.rows[1].dot(other),
-			this.rows[2].dot(other)
-		);
+		return Vec3.of(this.rows[0].dot(other), this.rows[1].dot(other), this.rows[2].dot(other));
 	}
 
 	/** @returns true iff this is the identity matrix. */
@@ -326,7 +302,7 @@ export class Mat33 {
 	 */
 	public toString(): string {
 		let result = '';
-		const maxColumnLens = [ 0, 0, 0 ];
+		const maxColumnLens = [0, 0, 0];
 
 		// Determine the longest item in each column so we can pad the others to that
 		// length.
@@ -390,11 +366,7 @@ export class Mat33 {
 	 * ```
 	 */
 	public toArray(): Mat33Array {
-		return [
-			this.a1, this.a2, this.a3,
-			this.b1, this.b2, this.b3,
-			this.c1, this.c2, this.c3,
-		];
+		return [this.a1, this.a2, this.a3, this.b1, this.b2, this.b3, this.c1, this.c2, this.c3];
 	}
 
 	/**
@@ -413,11 +385,17 @@ export class Mat33 {
 	 * //   ⎣ 6, 7, 8 ⎦
 	 * ```
 	 */
-	public mapEntries(mapping: (component: number, rowcol: [number, number])=>number): Mat33 {
+	public mapEntries(mapping: (component: number, rowcol: [number, number]) => number): Mat33 {
 		return new Mat33(
-			mapping(this.a1, [0, 0]), mapping(this.a2, [0, 1]), mapping(this.a3, [0, 2]),
-			mapping(this.b1, [1, 0]), mapping(this.b2, [1, 1]), mapping(this.b3, [1, 2]),
-			mapping(this.c1, [2, 0]), mapping(this.c2, [2, 1]), mapping(this.c3, [2, 2]),
+			mapping(this.a1, [0, 0]),
+			mapping(this.a2, [0, 1]),
+			mapping(this.a3, [0, 2]),
+			mapping(this.b1, [1, 0]),
+			mapping(this.b2, [1, 1]),
+			mapping(this.b3, [1, 2]),
+			mapping(this.c1, [2, 0]),
+			mapping(this.c2, [2, 1]),
+			mapping(this.c3, [2, 2]),
 		);
 	}
 
@@ -428,11 +406,7 @@ export class Mat33 {
 
 	/** 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),
-		);
+		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 */
@@ -463,13 +437,29 @@ export class Mat33 {
 		// Vec2s z = 1. As such,
 		//   outVec2.x = inVec2.x * 1 + inVec2.y * 0 + 1 * amount.x
 		//   ...
-		return new Mat33(
-			1, 0, amount.x,
-			0, 1, amount.y,
-			0, 0, 1
-		);
+		return new Mat33(1, 0, amount.x, 0, 1, amount.y, 0, 0, 1);
 	}
 
+	/**
+	 * Creates a matrix for rotating `Vec2`s about `center` by some number of `radians`.
+	 *
+	 * For this function, {@link Vec2}s are considered to be points in 2D space.
+	 *
+	 * For example,
+	 * ```ts,runnable,console
+	 * import { Mat33, Vec2 } from '@js-draw/math';
+	 *
+	 * const halfCircle = Math.PI; // PI radians = 180 degrees = 1/2 circle
+	 * const center = Vec2.of(1, 1); // The point (1,1)
+	 * const rotationMatrix = Mat33.zRotation(halfCircle, center);
+	 *
+	 * console.log(
+	 *   'Rotating (0,0) 180deg about', center, 'results in',
+	 *   // Rotates (0,0)
+	 *   rotationMatrix.transformVec2(Vec2.zero),
+	 * );
+	 * ```
+	 */
 	public static zRotation(radians: number, center: Point2 = Vec2.zero): Mat33 {
 		if (radians === 0) {
 			return Mat33.identity;
@@ -481,15 +471,11 @@ export class Mat33 {
 		// Translate everything so that rotation is about the origin
 		let result = Mat33.translation(center);
 
-		result = result.rightMul(new Mat33(
-			cos, -sin, 0,
-			sin, cos, 0,
-			0, 0, 1
-		));
+		result = result.rightMul(new Mat33(cos, -sin, 0, sin, cos, 0, 0, 0, 1));
 		return result.rightMul(Mat33.translation(center.times(-1)));
 	}
 
-	public static scaling2D(amount: number|Vec2, center: Point2 = Vec2.zero): Mat33 {
+	public static scaling2D(amount: number | Vec2, center: Point2 = Vec2.zero): Mat33 {
 		let result = Mat33.translation(center);
 		let xAmount, yAmount;
 
@@ -501,11 +487,7 @@ export class Mat33 {
 			yAmount = amount.y;
 		}
 
-		result = result.rightMul(new Mat33(
-			xAmount, 0, 0,
-			0, yAmount, 0,
-			0, 0, 1
-		));
+		result = result.rightMul(new Mat33(xAmount, 0, 0, 0, yAmount, 0, 0, 0, 1));
 
 		// Translate such that [center] goes to (0, 0)
 		return result.rightMul(Mat33.translation(center.times(-1)));
@@ -536,7 +518,7 @@ export class Mat33 {
 		}
 
 		const parseArguments = (argumentString: string): number[] => {
-			const parsed = argumentString.split(/[, \t\n]+/g).map(argString => {
+			const parsed = argumentString.split(/[, \t\n]+/g).map((argString) => {
 				// Handle trailing spaces/commands
 				if (argString.trim() === '') {
 					return null;
@@ -549,18 +531,16 @@ export class Mat33 {
 				}
 
 				// Remove trailing px units.
-				argString = argString.replace(/px$/ig, '');
+				argString = argString.replace(/px$/gi, '');
 
 				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,
-							})
-						})`
+						`All arguments to transform functions must be numeric (state: ${JSON.stringify({
+							currentArgument: argString,
+							allArguments: argumentString,
+						})})`,
 					);
 				}
 
@@ -572,10 +552,9 @@ export class Mat33 {
 
 				return argNumber;
 			});
-			return parsed.filter(n => n !== null);
+			return parsed.filter((n) => n !== null);
 		};
 
-
 		const keywordToAction = {
 			matrix: (matrixData: number[]) => {
 				if (matrixData.length !== 6) {
@@ -589,11 +568,7 @@ export class Mat33 {
 				const e = matrixData[4];
 				const f = matrixData[5];
 
-				const transform = new Mat33(
-					a, c, e,
-					b, d, f,
-					0, 0, 1
-				);
+				const transform = new Mat33(a, c, e, b, d, f, 0, 0, 1);
 				return transform;
 			},
 
@@ -623,7 +598,9 @@ export class Mat33 {
 					translateX = translateArgs[0];
 					translateY = translateArgs[1];
 				} else {
-					throw new Error(`The translate() function requires either 1 or 2 arguments. Given ${translateArgs}`);
+					throw new Error(
+						`The translate() function requires either 1 or 2 arguments. Given ${translateArgs}`,
+					);
 				}
 
 				return Mat33.translation(Vec2.of(translateX, translateY));
@@ -632,9 +609,9 @@ export class Mat33 {
 
 		// A command (\w+)
 		// followed by a set of arguments ([ \t\n0-9eE.,\-%]+)
-		const partRegex = /\s*(\w+)\s*\(([^)]*)\)/ig;
+		const partRegex = /\s*(\w+)\s*\(([^)]*)\)/gi;
 		let match;
-		let matrix: Mat33|null = null;
+		let matrix: Mat33 | null = null;
 
 		while ((match = partRegex.exec(cssString)) !== null) {
 			const action = match[1].toLowerCase();

package/src/Vec2.test.ts

@@ -17,11 +17,11 @@ describe('Vec2', () => {
 	});
 
 	it('More complicated expressions', () => {
-		expect((Vec2.of(1, 2).plus(Vec2.of(3, 4))).times(2)).objEq(Vec2.of(8, 12));
+		expect(Vec2.of(1, 2).plus(Vec2.of(3, 4)).times(2)).objEq(Vec2.of(8, 12));
 	});
 
 	it('Angle', () => {
-		expect(Vec2.of(-1, 1).angle()).toBeCloseTo(3 * Math.PI / 4);
+		expect(Vec2.of(-1, 1).angle()).toBeCloseTo((3 * Math.PI) / 4);
 	});
 
 	it('Perpindicular', () => {
@@ -29,4 +29,4 @@ describe('Vec2', () => {
 		expect(Vec2.unitX.cross(Vec3.unitZ)).objEq(Vec2.unitY.times(-1), tolerance);
 		expect(Vec2.unitX.orthog()).objEq(Vec2.unitY, tolerance);
 	});
-});
+});

package/src/Vec3.test.ts

@@ -1,4 +1,3 @@
-
 import Vec3 from './Vec3';
 
 describe('Vec3', () => {
@@ -60,7 +59,7 @@ describe('Vec3', () => {
 		{ from: Vec3.of(-1, -10, 0), to: Vec3.of(1, 2, 0), expected: 148 },
 	])(
 		'.squareDistanceTo and .distanceTo should return correct square and euclidean distances (%j)',
-		({ from , to, expected }) => {
+		({ from, to, expected }) => {
 			expect(from.squareDistanceTo(to)).toBe(expected);
 			expect(to.squareDistanceTo(from)).toBe(expected);
 			expect(to.distanceTo(from)).toBeCloseTo(Math.sqrt(expected));
@@ -83,4 +82,4 @@ describe('Vec3', () => {
 		expect(a.eq(b, tolerance)).toBe(eq);
 		expect(b.eq(a, tolerance)).toBe(eq);
 	});
-});
+});

package/src/Vec3.ts

@@ -1,5 +1,3 @@
-
-
 /**
  * A vector with three components, $\begin{pmatrix} x \\ y \\ z \end{pmatrix}$.
  * Can also be used to represent a two-component vector.
@@ -28,7 +26,7 @@ export interface Vec3 {
 	 * Returns the x, y components of this.
 	 * May be implemented as a getter method.
 	 */
-	readonly xy: { x: number, y: number };
+	readonly xy: { x: number; y: number };
 
 	/** Returns the vector's `idx`th component. For example, `Vec3.of(1, 2, 3).at(1) → 2`. */
 	at(i: number): number;
@@ -124,7 +122,7 @@ export interface Vec3 {
 	 * Vec3.of(1, 2, 3).scale(Vec3.of(2, 4, 6)); // → Vec3(2, 8, 18)
 	 * ```
 	 */
-	scale(other: Vec3|number): Vec3;
+	scale(other: Vec3 | number): Vec3;
 
 	/**
 	 * Returns a vector orthogonal to this. If this is a Vec2, returns `this` rotated
@@ -154,9 +152,7 @@ export interface Vec3 {
 	 * console.log(zipped.toString()); // → Vec(0.5, 2, 2.9)
 	 * ```
 	 */
-	zip(
-		other: Vec3, zip: (componentInThis: number, componentInOther: number)=> number
-	): Vec3;
+	zip(other: Vec3, zip: (componentInThis: number, componentInOther: number) => number): Vec3;
 
 	/**
 	 * Returns a vector with each component acted on by `fn`.
@@ -167,13 +163,12 @@ export interface Vec3 {
 	 * console.log(Vec3.of(1, 2, 3).map(val => val + 1)); // → Vec(2, 3, 4)
 	 * ```
 	 */
-	map(fn: (component: number, index: number)=> number): Vec3;
-
-	asArray(): [ number, number, number ];
+	map(fn: (component: number, index: number) => number): Vec3;
 
+	asArray(): [number, number, number];
 
 	/**
-	 * [fuzz] The maximum difference between two components for this and [other]
+	 * @param tolerance The maximum difference between two components for this and [other]
 	 * to be considered equal.
 	 *
 	 * @example
@@ -196,9 +191,8 @@ class Vec3Impl implements Vec3 {
 	public constructor(
 		public readonly x: number,
 		public readonly y: number,
-		public readonly z: number
-	) {
-	}
+		public readonly z: number,
+	) {}
 
 	public get xy(): { x: number; y: number } {
 		// Useful for APIs that behave differently if .z is present.
@@ -288,16 +282,12 @@ class Vec3Impl implements Vec3 {
 		);
 	}
 
-	public scale(other: Vec3|number): Vec3 {
+	public scale(other: Vec3 | number): Vec3 {
 		if (typeof other === 'number') {
 			return this.times(other);
 		}
 
-		return Vec3.of(
-			this.x * other.x,
-			this.y * other.y,
-			this.z * other.z,
-		);
+		return Vec3.of(this.x * other.x, this.y * other.y, this.z * other.z);
 	}
 
 	public orthog(): Vec3 {
@@ -318,28 +308,25 @@ class Vec3Impl implements Vec3 {
 	}
 
 	public zip(
-		other: Vec3, zip: (componentInThis: number, componentInOther: number)=> number
+		other: Vec3,
+		zip: (componentInThis: number, componentInOther: number) => number,
 	): Vec3 {
-		return Vec3.of(
-			zip(other.x, this.x),
-			zip(other.y, this.y),
-			zip(other.z, this.z)
-		);
+		return Vec3.of(zip(other.x, this.x), zip(other.y, this.y), zip(other.z, this.z));
 	}
 
-	public map(fn: (component: number, index: number)=> number): Vec3 {
+	public map(fn: (component: number, index: number) => number): Vec3 {
 		return Vec3.of(fn(this.x, 0), fn(this.y, 1), fn(this.z, 2));
 	}
 
-	public asArray(): [ number, number, number ] {
+	public asArray(): [number, number, number] {
 		return [this.x, this.y, this.z];
 	}
 
 	public eq(other: Vec3, fuzz: number = defaultEqlTolerance): boolean {
 		return (
-			Math.abs(other.x - this.x) <= fuzz
-			&& Math.abs(other.y - this.y) <= fuzz
-			&& Math.abs(other.z - this.z) <= fuzz
+			Math.abs(other.x - this.x) <= fuzz &&
+			Math.abs(other.y - this.y) <= fuzz &&
+			Math.abs(other.z - this.z) <= fuzz
 		);
 	}
 
@@ -352,10 +339,11 @@ class Vec2Impl implements Vec3 {
 	public constructor(
 		public readonly x: number,
 		public readonly y: number,
-	) {
-	}
+	) {}
 
-	public get z() { return 0; }
+	public get z() {
+		return 0;
+	}
 
 	public get xy(): { x: number; y: number } {
 		// Useful for APIs that behave differently if .z is present.
@@ -436,22 +424,15 @@ class Vec2Impl implements Vec3 {
 		// | i  j  k |
 		// | x1 y1 z1| = (i)(y1z2 - y2z1) - (j)(x1z2 - x2z1) + (k)(x1y2 - x2y1)
 		// | x2 y2 z2|
-		return Vec3.of(
-			this.y * other.z,
-			-this.x * other.z,
-			this.x * other.y - other.x * this.y,
-		);
+		return Vec3.of(this.y * other.z, -this.x * other.z, this.x * other.y - other.x * this.y);
 	}
 
-	public scale(other: Vec3|number): Vec3 {
+	public scale(other: Vec3 | number): Vec3 {
 		if (typeof other === 'number') {
 			return this.times(other);
 		}
 
-		return Vec2.of(
-			this.x * other.x,
-			this.y * other.y,
-		);
+		return Vec2.of(this.x * other.x, this.y * other.y);
 	}
 
 	public orthog(): Vec3 {
@@ -472,30 +453,25 @@ class Vec2Impl implements Vec3 {
 	}
 
 	public zip(
-		other: Vec3, zip: (componentInThis: number, componentInOther: number)=> number
+		other: Vec3,
+		zip: (componentInThis: number, componentInOther: number) => number,
 	): Vec3 {
-		return Vec3.of(
-			zip(other.x, this.x),
-			zip(other.y, this.y),
-			zip(other.z, 0),
-		);
+		return Vec3.of(zip(other.x, this.x), zip(other.y, this.y), zip(other.z, 0));
 	}
 
-	public map(fn: (component: number, index: number)=> number): Vec3 {
-		return Vec3.of(
-			fn(this.x, 0), fn(this.y, 1), fn(0, 2)
-		);
+	public map(fn: (component: number, index: number) => number): Vec3 {
+		return Vec3.of(fn(this.x, 0), fn(this.y, 1), fn(0, 2));
 	}
 
-	public asArray(): [ number, number, number ] {
+	public asArray(): [number, number, number] {
 		return [this.x, this.y, 0];
 	}
 
 	public eq(other: Vec3, fuzz: number = defaultEqlTolerance): boolean {
 		return (
-			Math.abs(other.x - this.x) <= fuzz
-			&& Math.abs(other.y - this.y) <= fuzz
-			&& Math.abs(other.z) <= fuzz
+			Math.abs(other.x - this.x) <= fuzz &&
+			Math.abs(other.y - this.y) <= fuzz &&
+			Math.abs(other.z) <= fuzz
 		);
 	}
 
@@ -505,12 +481,16 @@ class Vec2Impl implements Vec3 {
 }
 
 /**
- * A `Vec2` is a `Vec3` optimized for working in a plane. As such, they have an
+ * A `Vec2` is a {@link Vec3} optimized for working in a plane. `Vec2`s have an
  * always-zero `z` component.
  *
  * ```ts,runnable,console
  * import { Vec2 } from '@js-draw/math';
- * console.log(Vec2.of(1, 2));
+ *
+ * const v = Vec2.of(1, 2);
+ * console.log('a Vec2:', v);
+ * console.log('x component:', v.x);
+ * console.log('z component:', v.z);
  * ```
  */
 export namespace Vec2 {
@@ -537,7 +517,7 @@ export namespace Vec2 {
 	 * const v2 = Vec2.ofXY({ x: -123.4, y: 1 });
 	 * ```
 	 */
-	export const ofXY = ({x, y}: {x: number, y: number}) => {
+	export const ofXY = ({ x, y }: { x: number; y: number }) => {
 		return Vec2.of(x, y);
 	};
 
@@ -551,6 +531,7 @@ export namespace Vec2 {
 	export const zero = Vec2.of(0, 0);
 }
 
+/** Contains static methods for constructing a {@link Vec3}. */
 export namespace Vec3 {
 	/**
 	 * Construct a vector from three components.
@@ -559,6 +540,7 @@ export namespace Vec3 {
 	 * ```ts,runnable,console
 	 * import { Vec3 } from '@js-draw/math';
 	 * const v1 = Vec3.of(1, 2, 3);
+	 * console.log(v1.plus(Vec3.of(0, 100, 0)));
 	 * ```
 	 */
 	export const of = (x: number, y: number, z: number): Vec3 => {
@@ -569,8 +551,11 @@ export namespace Vec3 {
 		}
 	};
 
+	/** A unit vector in the x direction (`[1, 0, 0]`). */
 	export const unitX = Vec2.unitX;
+	/** A unit vector in the y direction (`[0, 1, 0]`). */
 	export const unitY = Vec2.unitY;
+	/** The zero vector (`[0, 0, 0]`). */
 	export const zero = Vec2.zero;
 
 	/** A vector of length 1 in the z direction. */

package/src/lib.ts

@@ -1,4 +1,7 @@
 /**
+ * This package contains general math utilities used by `js-draw`.
+ * These include 2D and 3D vectors, 2D paths, and 3x3 matrices.
+ *
  * ```ts,runnable,console
  * import { Vec2, Mat33, Rect2 } from '@js-draw/math';
  *
@@ -20,7 +23,6 @@
 export { LineSegment2 } from './shapes/LineSegment2';
 export {
 	Path,
-
 	IntersectionResult as PathIntersectionResult,
 	CurveIndexRecord as PathCurveIndex,
 	stepCurveIndexBy as stepPathIndexBy,
@@ -43,6 +45,5 @@ export { Vec3 } from './Vec3';
 export { Color4 } from './Color4';
 export * from './rounding/lib';
 
-
 // Note: All above exports cannot use `export { default as ... } from "..."` because this
 // breaks TypeDoc -- TypeDoc otherwise labels any imports of these classes as `default`.