@js-draw/math 1.21.3 → 1.23.1

package/build-config.json

@@ -1,4 +1,4 @@
 {
 	"inDirectory": "./src",
 	"outDirectory": "./dist"
-}
+}

package/dist/cjs/Color4.d.ts

@@ -28,9 +28,32 @@ export declare class Color4 {
      * Each component should be in the range [0, 1].
      */
     static ofRGB(red: number, green: number, blue: number): Color4;
+    /**
+     * Creates a color from red, green, blue, and transparency components. Each component should
+     * be in the range $[0, 1]$.
+     */
     static ofRGBA(red: number, green: number, blue: number, alpha: number): Color4;
+    /**
+     * Creates a color from an RGB (or RGBA) array.
+     *
+     * This is similar to {@link ofRGB} and {@link ofRGBA}, but, by default, takes values
+     * that range from 0 to 255.
+     *
+     * If the array values instead range from 0-1, pass `maxValue` as `1`.
+     */
+    static fromRGBArray(array: Uint8Array | Uint8ClampedArray | number[], maxValue?: number): Color4;
+    /**
+     * Creates a `Color4` from a three or four-component hexadecimal
+     * [color string](https://en.wikipedia.org/wiki/Web_colors#Hex_triplet).
+     *
+     * Example:
+     * ```ts,runnable,console
+     * import { Color4 } from '@js-draw/math';
+     * console.log(Color4.fromHex('#ff0'));
+     * ```
+     */
     static fromHex(hexString: string): Color4;
-    /** Like fromHex, but can handle additional colors if an `HTMLCanvasElement` is available. */
+    /** Like {@link fromHex}, but can handle additional colors if an `HTMLCanvasElement` is available. */
     static fromString(text: string): Color4;
     /** @returns true if `this` and `other` are approximately equal. */
     eq(other: Color4 | null | undefined): boolean;

package/dist/cjs/Color4.js

@@ -42,6 +42,10 @@ class Color4 {
     static ofRGB(red, green, blue) {
         return Color4.ofRGBA(red, green, blue, 1.0);
     }
+    /**
+     * Creates a color from red, green, blue, and transparency components. Each component should
+     * be in the range $[0, 1]$.
+     */
     static ofRGBA(red, green, blue, alpha) {
         red = Math.max(0, Math.min(red, 1));
         green = Math.max(0, Math.min(green, 1));
@@ -49,6 +53,34 @@ class Color4 {
         alpha = Math.max(0, Math.min(alpha, 1));
         return new Color4(red, green, blue, alpha);
     }
+    /**
+     * Creates a color from an RGB (or RGBA) array.
+     *
+     * This is similar to {@link ofRGB} and {@link ofRGBA}, but, by default, takes values
+     * that range from 0 to 255.
+     *
+     * If the array values instead range from 0-1, pass `maxValue` as `1`.
+     */
+    static fromRGBArray(array, maxValue = 255) {
+        const red = array[0];
+        const green = array[1] ?? red;
+        const blue = array[2] ?? red;
+        let alpha = 255;
+        if (3 < array.length) {
+            alpha = array[3];
+        }
+        return Color4.ofRGBA(red / maxValue, green / maxValue, blue / maxValue, alpha / maxValue);
+    }
+    /**
+     * Creates a `Color4` from a three or four-component hexadecimal
+     * [color string](https://en.wikipedia.org/wiki/Web_colors#Hex_triplet).
+     *
+     * Example:
+     * ```ts,runnable,console
+     * import { Color4 } from '@js-draw/math';
+     * console.log(Color4.fromHex('#ff0'));
+     * ```
+     */
     static fromHex(hexString) {
         // Remove starting '#' (if present)
         hexString = (hexString.match(/^[#]?(.*)$/) ?? [])[1];
@@ -61,7 +93,7 @@ class Color4 {
             // Each character is a component
             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) {
             // Alpha component
@@ -77,7 +109,7 @@ class Color4 {
         }
         return Color4.ofRGBA(components[0], components[1], components[2], components[3]);
     }
-    /** Like fromHex, but can handle additional colors if an `HTMLCanvasElement` is available. */
+    /** Like {@link fromHex}, but can handle additional colors if an `HTMLCanvasElement` is available. */
     static fromString(text) {
         if (text.startsWith('#')) {
             return Color4.fromHex(text);
@@ -171,7 +203,7 @@ class Color4 {
         // - https://www.w3.org/TR/2008/REC-WCAG20-20081211/#relativeluminancedef
         // - 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;
             }

package/dist/cjs/Mat33.d.ts

@@ -3,17 +3,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
  * a two-dimensional affine transformation. (An affine transformation scales/rotates/shears
@@ -216,6 +206,26 @@ export declare class Mat33 {
      * $$
      */
     static translation(amount: Vec2): Mat33;
+    /**
+     * 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),
+     * );
+     * ```
+     */
     static zRotation(radians: number, center?: Point2): Mat33;
     static scaling2D(amount: number | Vec2, center?: Point2): Mat33;
     /**

package/dist/cjs/Mat33.js

@@ -76,11 +76,7 @@ class Mat33 {
         this.c2 = c2;
         this.c3 = c3;
         this.cachedInverse = undefined;
-        this.rows = [
-            Vec3_1.default.of(a1, a2, a3),
-            Vec3_1.default.of(b1, b2, b3),
-            Vec3_1.default.of(c1, c2, c3),
-        ];
+        this.rows = [Vec3_1.default.of(a1, a2, a3), Vec3_1.default.of(b1, b2, b3), Vec3_1.default.of(c1, c2, c3)];
     }
     /**
      * Creates a matrix from the given rows:
@@ -112,16 +108,8 @@ class Mat33 {
         if (this.cachedInverse !== undefined) {
             return this.cachedInverse;
         }
-        const toIdentity = [
-            this.rows[0],
-            this.rows[1],
-            this.rows[2],
-        ];
-        const toResult = [
-            Vec3_1.default.unitX,
-            Vec3_1.default.unitY,
-            Vec3_1.default.unitZ,
-        ];
+        const toIdentity = [this.rows[0], this.rows[1], this.rows[2]];
+        const toResult = [Vec3_1.default.unitX, Vec3_1.default.unitY, Vec3_1.default.unitZ];
         // Convert toIdentity to the identity matrix and
         // toResult to the inverse through elementary row operations
         for (let cursor = 0; cursor < 3; cursor++) {
@@ -317,11 +305,7 @@ class Mat33 {
      * ```
      */
     toArray() {
-        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];
     }
     /**
      * Returns a new `Mat33` where each entry is the output of the function
@@ -378,6 +362,26 @@ class Mat33 {
         //   ...
         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),
+     * );
+     * ```
+     */
     static zRotation(radians, center = Vec2_1.Vec2.zero) {
         if (radians === 0) {
             return Mat33.identity;
@@ -427,7 +431,7 @@ class Mat33 {
             return Mat33.identity;
         }
         const parseArguments = (argumentString) => {
-            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;
@@ -438,7 +442,7 @@ class Mat33 {
                     argString = argString.substring(0, argString.length - 1);
                 }
                 // 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({
@@ -452,7 +456,7 @@ class Mat33 {
                 }
                 return argNumber;
             });
-            return parsed.filter(n => n !== null);
+            return parsed.filter((n) => n !== null);
         };
         const keywordToAction = {
             matrix: (matrixData) => {
@@ -502,7 +506,7 @@ 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 = null;
         while ((match = partRegex.exec(cssString)) !== null) {

package/dist/cjs/Vec3.d.ts

@@ -150,7 +150,7 @@ export interface Vec3 {
     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
@@ -200,12 +200,16 @@ declare class Vec2Impl implements Vec3 {
     toString(): string;
 }
 /**
- * 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 declare namespace Vec2 {
@@ -240,6 +244,7 @@ export declare namespace Vec2 {
     /** The zero vector: A vector with x=0, y=0. */
     const zero: Vec2Impl;
 }
+/** Contains static methods for constructing a {@link Vec3}. */
 export declare namespace Vec3 {
     /**
      * Construct a vector from three components.
@@ -248,11 +253,15 @@ export declare 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)));
      * ```
      */
     const of: (x: number, y: number, z: number) => Vec3;
+    /** A unit vector in the x direction (`[1, 0, 0]`). */
     const unitX: Vec2Impl;
+    /** A unit vector in the y direction (`[0, 1, 0]`). */
     const unitY: Vec2Impl;
+    /** The zero vector (`[0, 0, 0]`). */
     const zero: Vec2Impl;
     /** A vector of length 1 in the z direction. */
     const unitZ: Vec3;

package/dist/cjs/Vec3.js

@@ -106,9 +106,9 @@ class Vec3Impl {
         return [this.x, this.y, this.z];
     }
     eq(other, fuzz = defaultEqlTolerance) {
-        return (Math.abs(other.x - this.x) <= fuzz
-            && Math.abs(other.y - this.y) <= fuzz
-            && Math.abs(other.z - this.z) <= fuzz);
+        return (Math.abs(other.x - this.x) <= fuzz &&
+            Math.abs(other.y - this.y) <= fuzz &&
+            Math.abs(other.z - this.z) <= fuzz);
     }
     toString() {
         return `Vec(${this.x}, ${this.y}, ${this.z})`;
@@ -119,7 +119,9 @@ class Vec2Impl {
         this.x = x;
         this.y = y;
     }
-    get z() { return 0; }
+    get z() {
+        return 0;
+    }
     get xy() {
         // Useful for APIs that behave differently if .z is present.
         return {
@@ -216,21 +218,25 @@ class Vec2Impl {
         return [this.x, this.y, 0];
     }
     eq(other, fuzz = defaultEqlTolerance) {
-        return (Math.abs(other.x - this.x) <= fuzz
-            && Math.abs(other.y - this.y) <= fuzz
-            && Math.abs(other.z) <= fuzz);
+        return (Math.abs(other.x - this.x) <= fuzz &&
+            Math.abs(other.y - this.y) <= fuzz &&
+            Math.abs(other.z) <= fuzz);
     }
     toString() {
         return `Vec(${this.x}, ${this.y})`;
     }
 }
 /**
- * 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);
  * ```
  */
 var Vec2;
@@ -267,6 +273,7 @@ var Vec2;
     /** The zero vector: A vector with x=0, y=0. */
     Vec2.zero = Vec2.of(0, 0);
 })(Vec2 || (exports.Vec2 = Vec2 = {}));
+/** Contains static methods for constructing a {@link Vec3}. */
 var Vec3;
 (function (Vec3) {
     /**
@@ -276,6 +283,7 @@ var 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)));
      * ```
      */
     Vec3.of = (x, y, z) => {
@@ -286,8 +294,11 @@ var Vec3;
             return new Vec3Impl(x, y, z);
         }
     };
+    /** A unit vector in the x direction (`[1, 0, 0]`). */
     Vec3.unitX = Vec2.unitX;
+    /** A unit vector in the y direction (`[0, 1, 0]`). */
     Vec3.unitY = Vec2.unitY;
+    /** The zero vector (`[0, 0, 0]`). */
     Vec3.zero = Vec2.zero;
     /** A vector of length 1 in the z direction. */
     Vec3.unitZ = Vec3.of(0, 0, 1);

package/dist/cjs/lib.d.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';
  *

package/dist/cjs/lib.js

@@ -1,5 +1,8 @@
 "use strict";
 /**
+ * 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';
  *

package/dist/cjs/shapes/BezierJSWrapper.d.ts

@@ -29,8 +29,10 @@ export declare abstract class BezierJSWrapper extends Parameterized2DShape {
      * @returns the curve evaluated at `t`.
      */
     at(t: number): Point2;
+    /** @returns the curve's directional derivative at `t`. */
     derivativeAt(t: number): Point2;
     secondDerivativeAt(t: number): Point2;
+    /** @returns the [normal vector](https://en.wikipedia.org/wiki/Normal_(geometry)) to this curve at `t`. */
     normal(t: number): Vec2;
     normalAt(t: number): Vec2;
     tangentAt(t: number): Vec2;

package/dist/cjs/shapes/BezierJSWrapper.js

@@ -40,7 +40,7 @@ class BezierJSWrapper extends Parameterized2DShape_1.default {
     }
     getBezier() {
         if (!__classPrivateFieldGet(this, _BezierJSWrapper_bezierJs, "f")) {
-            __classPrivateFieldSet(this, _BezierJSWrapper_bezierJs, new bezier_js_1.Bezier(this.getPoints().map(p => p.xy)), "f");
+            __classPrivateFieldSet(this, _BezierJSWrapper_bezierJs, new bezier_js_1.Bezier(this.getPoints().map((p) => p.xy)), "f");
         }
         return __classPrivateFieldGet(this, _BezierJSWrapper_bezierJs, "f");
     }
@@ -63,12 +63,14 @@ class BezierJSWrapper extends Parameterized2DShape_1.default {
     at(t) {
         return Vec2_1.Vec2.ofXY(this.getBezier().get(t));
     }
+    /** @returns the curve's directional derivative at `t`. */
     derivativeAt(t) {
         return Vec2_1.Vec2.ofXY(this.getBezier().derivative(t));
     }
     secondDerivativeAt(t) {
         return Vec2_1.Vec2.ofXY(this.getBezier().dderivative(t));
     }
+    /** @returns the [normal vector](https://en.wikipedia.org/wiki/Normal_(geometry)) to this curve at `t`. */
     normal(t) {
         return Vec2_1.Vec2.ofXY(this.getBezier().normal(t));
     }
@@ -94,10 +96,12 @@ class BezierJSWrapper extends Parameterized2DShape_1.default {
         const asLine = LineSegment2_1.default.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 => {
+        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),
@@ -106,12 +110,12 @@ class BezierJSWrapper extends Parameterized2DShape_1.default {
             }
             const point = Vec2_1.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) {
+            if (point.distanceTo(line.p1) > line.length || point.distanceTo(line.p2) > line.length) {
                 return null;
             }
             return t;
-        }).filter(entry => entry !== null);
+        })
+            .filter((entry) => entry !== null);
     }
     splitAt(t) {
         if (t <= 0 || t >= 1) {
@@ -120,8 +124,8 @@ class BezierJSWrapper extends Parameterized2DShape_1.default {
         const bezier = this.getBezier();
         const split = bezier.split(t);
         return [
-            new BezierJSWrapperImpl(split.left.points.map(point => Vec2_1.Vec2.ofXY(point)), split.left),
-            new BezierJSWrapperImpl(split.right.points.map(point => Vec2_1.Vec2.ofXY(point)), split.right),
+            new BezierJSWrapperImpl(split.left.points.map((point) => Vec2_1.Vec2.ofXY(point)), split.left),
+            new BezierJSWrapperImpl(split.right.points.map((point) => Vec2_1.Vec2.ofXY(point)), split.right),
         ];
     }
     nearestPointTo(point) {
@@ -165,16 +169,19 @@ class BezierJSWrapper extends Parameterized2DShape_1.default {
             const b = this.at(t);
             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);
+            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);
         };
         // Because we're zeroing f'(t), we also need to be able to compute it:
         const derivativeAt = (t) => {
             // f'(t) = 2Bₓ(t)Bₓ'(t) - 2pₓBₓ'(t) + 2Bᵧ(t)Bᵧ'(t) - 2pᵧBᵧ'(t)
             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);
+            return (2 * b.x * bPrime.x - 2 * point.x * bPrime.x + 2 * b.y * bPrime.y - 2 * point.y * bPrime.y);
         };
         const iterate = () => {
             const slope = secondDerivativeAt(t);
@@ -225,7 +232,9 @@ class BezierJSWrapper extends Parameterized2DShape_1.default {
         return result;
     }
     toString() {
-        return `Bézier(${this.getPoints().map(point => point.toString()).join(', ')})`;
+        return `Bézier(${this.getPoints()
+            .map((point) => point.toString())
+            .join(', ')})`;
     }
 }
 exports.BezierJSWrapper = BezierJSWrapper;

package/dist/cjs/shapes/LineSegment2.js

@@ -46,7 +46,7 @@ class LineSegment2 extends Parameterized2DShape_1.default {
     static ofSmallestContainingPoints(points) {
         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) {
             if (!line.containsPoint(point)) {
@@ -96,10 +96,7 @@ class LineSegment2 extends Parameterized2DShape_1.default {
         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)];
     }
     /**
      * Returns the intersection of this with another line segment.
@@ -149,18 +146,17 @@ class LineSegment2 extends Parameterized2DShape_1.default {
                 return null;
             }
             const xIntersect = this.point1.x;
-            const yIntersect = (this.point1.x - other.point1.x) * other.direction.y / other.direction.x + other.point1.y;
+            const yIntersect = ((this.point1.x - other.point1.x) * other.direction.y) / other.direction.x + other.point1.y;
             resultPoint = Vec2_1.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) {
                 return null;
@@ -176,10 +172,10 @@ class LineSegment2 extends Parameterized2DShape_1.default {
         const resultToP2 = resultPoint.distanceTo(this.point2);
         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;
         }
         return {
@@ -264,8 +260,8 @@ class LineSegment2 extends Parameterized2DShape_1.default {
         }
         const tolerance = options?.tolerance;
         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)));
+        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)));
     }
 }
 exports.LineSegment2 = LineSegment2;

package/dist/cjs/shapes/Parameterized2DShape.js

@@ -13,7 +13,7 @@ const Abstract2DShape_1 = __importDefault(require("./Abstract2DShape"));
  */
 class Parameterized2DShape extends Abstract2DShape_1.default {
     intersectsLineSegment(line) {
-        return this.argIntersectsLineSegment(line).map(t => this.at(t));
+        return this.argIntersectsLineSegment(line).map((t) => this.at(t));
     }
 }
 exports.Parameterized2DShape = Parameterized2DShape;

package/dist/cjs/shapes/Path.d.ts

@@ -3,6 +3,7 @@ import Mat33 from '../Mat33';
 import Rect2 from './Rect2';
 import { Point2 } from '../Vec2';
 import Parameterized2DShape from './Parameterized2DShape';
+/** Identifiers for different path commands. These commands can make up a {@link Path}. */
 export declare enum PathCommandType {
     LineTo = 0,
     MoveTo = 1,