@js-draw/math 1.21.3 → 1.22.0

package/dist/mjs/Color4.mjs

@@ -55,7 +55,7 @@ export 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
@@ -165,7 +165,7 @@ export 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/mjs/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

package/dist/mjs/Mat33.mjs

@@ -70,11 +70,7 @@ export class Mat33 {
         this.c2 = c2;
         this.c3 = c3;
         this.cachedInverse = undefined;
-        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)];
     }
     /**
      * Creates a matrix from the given rows:
@@ -106,16 +102,8 @@ export class Mat33 {
         if (this.cachedInverse !== undefined) {
             return this.cachedInverse;
         }
-        const toIdentity = [
-            this.rows[0],
-            this.rows[1],
-            this.rows[2],
-        ];
-        const toResult = [
-            Vec3.unitX,
-            Vec3.unitY,
-            Vec3.unitZ,
-        ];
+        const toIdentity = [this.rows[0], this.rows[1], this.rows[2]];
+        const toResult = [Vec3.unitX, Vec3.unitY, Vec3.unitZ];
         // Convert toIdentity to the identity matrix and
         // toResult to the inverse through elementary row operations
         for (let cursor = 0; cursor < 3; cursor++) {
@@ -311,11 +299,7 @@ export 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
@@ -421,7 +405,7 @@ export 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;
@@ -432,7 +416,7 @@ export 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({
@@ -446,7 +430,7 @@ export class Mat33 {
                 }
                 return argNumber;
             });
-            return parsed.filter(n => n !== null);
+            return parsed.filter((n) => n !== null);
         };
         const keywordToAction = {
             matrix: (matrixData) => {
@@ -496,7 +480,7 @@ 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 = null;
         while ((match = partRegex.exec(cssString)) !== null) {

package/dist/mjs/Vec3.mjs

@@ -103,9 +103,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})`;
@@ -116,7 +116,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 {
@@ -213,9 +215,9 @@ 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})`;

package/dist/mjs/shapes/BezierJSWrapper.mjs

@@ -34,7 +34,7 @@ export class BezierJSWrapper extends Parameterized2DShape {
     }
     getBezier() {
         if (!__classPrivateFieldGet(this, _BezierJSWrapper_bezierJs, "f")) {
-            __classPrivateFieldSet(this, _BezierJSWrapper_bezierJs, new Bezier(this.getPoints().map(p => p.xy)), "f");
+            __classPrivateFieldSet(this, _BezierJSWrapper_bezierJs, new Bezier(this.getPoints().map((p) => p.xy)), "f");
         }
         return __classPrivateFieldGet(this, _BezierJSWrapper_bezierJs, "f");
     }
@@ -88,10 +88,12 @@ export 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 => {
+        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),
@@ -100,12 +102,12 @@ export class BezierJSWrapper extends Parameterized2DShape {
             }
             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) {
+            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) {
@@ -114,8 +116,8 @@ export class BezierJSWrapper extends Parameterized2DShape {
         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),
         ];
     }
     nearestPointTo(point) {
@@ -159,16 +161,19 @@ export class BezierJSWrapper extends Parameterized2DShape {
             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);
@@ -219,7 +224,9 @@ export class BezierJSWrapper extends Parameterized2DShape {
         return result;
     }
     toString() {
-        return `Bézier(${this.getPoints().map(point => point.toString()).join(', ')})`;
+        return `Bézier(${this.getPoints()
+            .map((point) => point.toString())
+            .join(', ')})`;
     }
 }
 _BezierJSWrapper_bezierJs = new WeakMap();

package/dist/mjs/shapes/LineSegment2.mjs

@@ -40,7 +40,7 @@ export class LineSegment2 extends Parameterized2DShape {
     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)) {
@@ -90,10 +90,7 @@ export class LineSegment2 extends Parameterized2DShape {
         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.
@@ -143,18 +140,17 @@ export class LineSegment2 extends Parameterized2DShape {
                 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.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;
@@ -170,10 +166,10 @@ export class LineSegment2 extends Parameterized2DShape {
         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 {
@@ -258,8 +254,8 @@ export class LineSegment2 extends Parameterized2DShape {
         }
         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)));
     }
 }
 export default LineSegment2;

package/dist/mjs/shapes/Parameterized2DShape.mjs

@@ -7,7 +7,7 @@ import  Abstract2DShape  from './Abstract2DShape.mjs';
  */
 export class Parameterized2DShape extends Abstract2DShape {
     intersectsLineSegment(line) {
-        return this.argIntersectsLineSegment(line).map(t => this.at(t));
+        return this.argIntersectsLineSegment(line).map((t) => this.at(t));
     }
 }
 export default Parameterized2DShape;

package/dist/mjs/shapes/Path.mjs

@@ -319,9 +319,7 @@ export class Path {
         const maxRaymarchSteps = 8;
         // Start raymarching from each of these points. This allows detection of multiple
         // intersections.
-        const startPoints = [
-            line.p1, ...additionalRaymarchStartPoints, line.p2
-        ];
+        const startPoints = [line.p1, ...additionalRaymarchStartPoints, line.p2];
         // Converts a point ON THE LINE to a parameter
         const pointToParameter = (point) => {
             // Because line.direction is a unit vector, this computes the length
@@ -427,7 +425,9 @@ export class Path {
             return [];
         }
         if (this.parts.length === 0) {
-            return new Path(this.startPoint, [{ kind: PathCommandType.MoveTo, point: this.startPoint }]).intersection(line, strokeRadius);
+            return new Path(this.startPoint, [
+                { kind: PathCommandType.MoveTo, point: this.startPoint },
+            ]).intersection(line, strokeRadius);
         }
         let index = 0;
         for (const part of this.geometry) {
@@ -448,7 +448,7 @@ export class Path {
         const doRaymarching = strokeRadius && strokeRadius > 1e-8;
         if (doRaymarching) {
             // Starting points for raymarching (in addition to the end points of the line).
-            const startPoints = result.map(intersection => intersection.point);
+            const startPoints = result.map((intersection) => intersection.point);
             result = this.raymarchIntersectionWith(line, strokeRadius, startPoints);
         }
         return result;
@@ -501,7 +501,8 @@ export class Path {
      */
     spliced(deleteFrom, deleteTo, insert, options) {
         const isBeforeOrEqual = (a, b) => {
-            return a.curveIndex < b.curveIndex || (a.curveIndex === b.curveIndex && a.parameterValue <= b.parameterValue);
+            return (a.curveIndex < b.curveIndex ||
+                (a.curveIndex === b.curveIndex && a.parameterValue <= b.parameterValue));
         };
         if (isBeforeOrEqual(deleteFrom, deleteTo)) {
             //          deleteFrom        deleteTo
@@ -539,15 +540,15 @@ export class Path {
         //
         // Bounds checking & reversal.
         //
-        while (splitAt.length > 0
-            && splitAt[splitAt.length - 1].curveIndex >= this.parts.length - 1
-            && splitAt[splitAt.length - 1].parameterValue >= 1) {
+        while (splitAt.length > 0 &&
+            splitAt[splitAt.length - 1].curveIndex >= this.parts.length - 1 &&
+            splitAt[splitAt.length - 1].parameterValue >= 1) {
             splitAt.pop();
         }
         splitAt.reverse(); // .reverse() <-- We're `.pop`ing from the end
-        while (splitAt.length > 0
-            && splitAt[splitAt.length - 1].curveIndex <= 0
-            && splitAt[splitAt.length - 1].parameterValue <= 0) {
+        while (splitAt.length > 0 &&
+            splitAt[splitAt.length - 1].curveIndex <= 0 &&
+            splitAt[splitAt.length - 1].parameterValue <= 0) {
             splitAt.pop();
         }
         if (splitAt.length === 0 || this.parts.length === 0) {
@@ -738,7 +739,7 @@ export class Path {
         if (affineTransfm.isIdentity()) {
             return this;
         }
-        return this.mapPoints(point => affineTransfm.transformVec2(point));
+        return this.mapPoints((point) => affineTransfm.transformVec2(point));
     }
     /**
      * @internal
@@ -827,11 +828,10 @@ export class Path {
                     });
                     lastPoint = part.endPoint;
                     break;
-                default:
-                    {
-                        const exhaustivenessCheck = part;
-                        return exhaustivenessCheck;
-                    }
+                default: {
+                    const exhaustivenessCheck = part;
+                    return exhaustivenessCheck;
+                }
             }
         }
         newParts.reverse();
@@ -843,7 +843,8 @@ export class Path {
             return this.startPoint;
         }
         const lastPart = this.parts[this.parts.length - 1];
-        if (lastPart.kind === PathCommandType.QuadraticBezierTo || lastPart.kind === PathCommandType.CubicBezierTo) {
+        if (lastPart.kind === PathCommandType.QuadraticBezierTo ||
+            lastPart.kind === PathCommandType.CubicBezierTo) {
             return lastPart.endPoint;
         }
         else {
@@ -952,9 +953,9 @@ export class Path {
                     if (part1.kind !== part2.kind) {
                         return false;
                     }
-                    else if (!part1.controlPoint1.eq(part2.controlPoint1, tolerance)
-                        || !part1.controlPoint2.eq(part2.controlPoint2, tolerance)
-                        || !part1.endPoint.eq(part2.endPoint, tolerance)) {
+                    else if (!part1.controlPoint1.eq(part2.controlPoint1, tolerance) ||
+                        !part1.controlPoint2.eq(part2.controlPoint2, tolerance) ||
+                        !part1.endPoint.eq(part2.endPoint, tolerance)) {
                         return false;
                     }
                     break;
@@ -962,16 +963,15 @@ export class Path {
                     if (part1.kind !== part2.kind) {
                         return false;
                     }
-                    else if (!part1.controlPoint.eq(part2.controlPoint, tolerance)
-                        || !part1.endPoint.eq(part2.endPoint, tolerance)) {
+                    else if (!part1.controlPoint.eq(part2.controlPoint, tolerance) ||
+                        !part1.endPoint.eq(part2.endPoint, tolerance)) {
                         return false;
                     }
                     break;
-                default:
-                    {
-                        const exhaustivenessCheck = part1;
-                        return exhaustivenessCheck;
-                    }
+                default: {
+                    const exhaustivenessCheck = part1;
+                    return exhaustivenessCheck;
+                }
             }
         }
         return true;
@@ -993,11 +993,7 @@ export class Path {
             const cornerToEdge = Vec2.of(lineWidth, lineWidth).times(0.5);
             const innerRect = Rect2.fromCorners(rect.topLeft.plus(cornerToEdge), rect.bottomRight.minus(cornerToEdge));
             const outerRect = Rect2.fromCorners(rect.topLeft.minus(cornerToEdge), rect.bottomRight.plus(cornerToEdge));
-            corners = [
-                innerRect.corners[3],
-                ...innerRect.corners,
-                ...outerRect.corners.reverse(),
-            ];
+            corners = [innerRect.corners[3], ...innerRect.corners, ...outerRect.corners.reverse()];
             startPoint = outerRect.corners[3];
         }
         else {
@@ -1180,19 +1176,23 @@ export class Path {
             });
         };
         const commandArgCounts = {
-            'm': 1,
-            'l': 1,
-            'c': 3,
-            'q': 2,
-            'z': 0,
-            'h': 1,
-            'v': 1,
+            m: 1,
+            l: 1,
+            c: 3,
+            q: 2,
+            z: 0,
+            h: 1,
+            v: 1,
         };
         // Each command: Command character followed by anything that isn't a command character
-        const commandExp = /([MZLHVCSQTA])\s*([^MZLHVCSQTA]*)/ig;
+        const commandExp = /([MZLHVCSQTA])\s*([^MZLHVCSQTA]*)/gi;
         let current;
         while ((current = commandExp.exec(pathString)) !== null) {
-            const argParts = current[2].trim().split(/[^0-9Ee.-]/).filter(part => part.length > 0).reduce((accumualtor, current) => {
+            const argParts = current[2]
+                .trim()
+                .split(/[^0-9Ee.-]/)
+                .filter((part) => part.length > 0)
+                .reduce((accumualtor, current) => {
                 // As of 09/2022, iOS Safari doesn't support support lookbehind in regular
                 // expressions. As such, we need an alternative.
                 // Because '-' can be used as a path separator, unless preceeded by an 'e' (as in 1e-5),
@@ -1202,10 +1202,10 @@ export class Path {
                 if (parts[0] !== '') {
                     accumualtor.push(parts[0]);
                 }
-                accumualtor.push(...parts.slice(1).map(part => `-${part}`));
+                accumualtor.push(...parts.slice(1).map((part) => `-${part}`));
                 return accumualtor;
             }, []);
-            let numericArgs = argParts.map(arg => parseFloat(arg));
+            let numericArgs = argParts.map((arg) => parseFloat(arg));
             let commandChar = current[1].toLowerCase();
             let uppercaseCommand = current[1] !== commandChar;
             // Convert commands that don't take points into commands that do.
@@ -1233,7 +1233,8 @@ export class Path {
                 commandChar = 'l';
             }
             const commandArgCount = commandArgCounts[commandChar] ?? 0;
-            const allArgs = numericArgs.reduce((accumulator, current, index, parts) => {
+            const allArgs = numericArgs
+                .reduce((accumulator, current, index, parts) => {
                 if (index % 2 !== 0) {
                     const currentAsFloat = current;
                     const prevAsFloat = parts[index - 1];
@@ -1242,7 +1243,8 @@ export class Path {
                 else {
                     return accumulator;
                 }
-            }, []).map((coordinate, index) => {
+            }, [])
+                .map((coordinate, index) => {
                 // Lowercase commands are relative, uppercase commands use absolute
                 // positioning
                 let newPos;

package/dist/mjs/shapes/Rect2.mjs

@@ -34,13 +34,16 @@ export class Rect2 extends Abstract2DShape {
         return new Rect2(this.x, this.y, size.x, size.y);
     }
     containsPoint(other) {
-        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);
     }
     containsRect(other) {
-        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);
     }
     /**
      * @returns true iff this and `other` overlap
@@ -125,7 +128,7 @@ export class Rect2 extends Abstract2DShape {
         return new Rect2(this.x - margin, this.y - margin, this.w + margin * 2, this.h + margin * 2);
     }
     getClosestPointOnBoundaryTo(target) {
-        const closestEdgePoints = this.getEdges().map(edge => {
+        const closestEdgePoints = this.getEdges().map((edge) => {
             return edge.closestPointTo(target);
         });
         let closest = null;
@@ -152,15 +155,10 @@ export class Rect2 extends Abstract2DShape {
             return false;
         }
         const squareRadius = radius * radius;
-        return this.corners.every(corner => corner.minus(point).magnitudeSquared() < squareRadius);
+        return this.corners.every((corner) => corner.minus(point).magnitudeSquared() < squareRadius);
     }
     get corners() {
-        return [
-            this.bottomRight,
-            this.topRight,
-            this.topLeft,
-            this.bottomLeft,
-        ];
+        return [this.bottomRight, this.topRight, this.topLeft, this.bottomLeft];
     }
     get maxDimension() {
         return Math.max(this.w, this.h);
@@ -201,7 +199,7 @@ export class Rect2 extends Abstract2DShape {
         const result = [];
         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;
     }
@@ -219,7 +217,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.
     transformedBoundingBox(affineTransform) {
-        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` */
     eq(other, tolerance = 0) {

package/dist/mjs/shapes/Triangle.mjs

@@ -39,12 +39,12 @@ class Triangle extends Abstract2DShape {
     }
     // Transform, treating this as composed of 2D points.
     transformed2DBy(affineTransform) {
-        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.
     transformedBy(linearTransform) {
-        return this.map(vertex => linearTransform.transformVec3(vertex));
+        return this.map((vertex) => linearTransform.transformVec3(vertex));
     }
     /**
      * Returns the sides of this triangle, as an array of `LineSegment2`s.
@@ -66,8 +66,7 @@ class Triangle extends Abstract2DShape {
     intersectsLineSegment(lineSegment) {
         const result = [];
         for (const edge of this.getEdges()) {
-            edge.intersectsLineSegment(lineSegment)
-                .forEach(point => result.push(point));
+            edge.intersectsLineSegment(lineSegment).forEach((point) => result.push(point));
         }
         return result;
     }
@@ -101,7 +100,7 @@ class Triangle extends Abstract2DShape {
      */
     signedDistance(point) {
         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
         // number.

package/dist/mjs/utils/convexHull2Of.mjs

@@ -10,9 +10,9 @@ const convexHull2Of = (points) => {
         return [];
     }
     // 1. Start with a vertex on the hull
-    const lowestPoint = points.reduce((lowest, current) => current.y < lowest.y ? current : lowest, points[0]);
+    const lowestPoint = points.reduce((lowest, current) => (current.y < lowest.y ? current : lowest), points[0]);
     const vertices = [lowestPoint];
-    let toProcess = [...points.filter(p => !p.eq(lowestPoint))];
+    let toProcess = [...points.filter((p) => !p.eq(lowestPoint))];
     let lastBaseDirection = Vec2.of(-1, 0);
     // 2. Find the point with greatest angle from the vertex:
     //
@@ -38,7 +38,7 @@ const convexHull2Of = (points) => {
                 smallestDotProductSoFar = currentDotProduct;
             }
         }
-        toProcess = toProcess.filter(p => !p.eq(furthestPointSoFar));
+        toProcess = toProcess.filter((p) => !p.eq(furthestPointSoFar));
         const newBaseDirection = furthestPointSoFar.minus(lastVertex).normalized();
         // If the last vertex is on the same edge as the current, there's no need to include
         // the previous one.

package/dist-test/test_imports/test-require.cjs

@@ -12,4 +12,4 @@ if (!Mat33.identity) {
 
 if (!Color4.red) {
 	throw new Error('Failed to import Color4 from js-draw');
-}
+}