@js-draw/math 1.0.0

package/dist/mjs/shapes/PointShape2D.d.ts

@@ -0,0 +1,18 @@
+import { Point2 } from '../Vec2';
+import Vec3 from '../Vec3';
+import Abstract2DShape from './Abstract2DShape';
+import LineSegment2 from './LineSegment2';
+import Rect2 from './Rect2';
+/**
+ * Like a {@link Point2}, but with additional functionality (e.g. SDF).
+ *
+ * Access the internal `Point2` using the `p` property.
+ */
+declare class PointShape2D extends Abstract2DShape {
+    readonly p: Point2;
+    constructor(p: Point2);
+    signedDistance(point: Vec3): number;
+    intersectsLineSegment(lineSegment: LineSegment2, epsilon?: number): Vec3[];
+    getTightBoundingBox(): Rect2;
+}
+export default PointShape2D;

package/dist/mjs/shapes/PointShape2D.mjs

@@ -0,0 +1,26 @@
+import  Abstract2DShape  from './Abstract2DShape.mjs';
+import  Rect2  from './Rect2.mjs';
+/**
+ * Like a {@link Point2}, but with additional functionality (e.g. SDF).
+ *
+ * Access the internal `Point2` using the `p` property.
+ */
+class PointShape2D extends Abstract2DShape {
+    constructor(p) {
+        super();
+        this.p = p;
+    }
+    signedDistance(point) {
+        return this.p.minus(point).magnitude();
+    }
+    intersectsLineSegment(lineSegment, epsilon) {
+        if (lineSegment.containsPoint(this.p, epsilon)) {
+            return [this.p];
+        }
+        return [];
+    }
+    getTightBoundingBox() {
+        return new Rect2(this.p.x, this.p.y, 0, 0);
+    }
+}
+export default PointShape2D;

package/dist/mjs/shapes/QuadraticBezier.d.ts

@@ -0,0 +1,35 @@
+import { Point2, Vec2 } from '../Vec2';
+import BezierJSWrapper from './BezierJSWrapper';
+import Rect2 from './Rect2';
+/**
+ * A wrapper around `bezier-js`'s quadratic Bézier.
+ *
+ * This wrappper lazy-loads `bezier-js`'s Bézier and can perform some operations
+ * without loading it at all (e.g. `normal`, `at`, and `approximateDistance`).
+ */
+export declare class QuadraticBezier extends BezierJSWrapper {
+    readonly p0: Point2;
+    readonly p1: Point2;
+    readonly p2: Point2;
+    constructor(p0: Point2, p1: Point2, p2: Point2);
+    /**
+     * Returns a component of a quadratic Bézier curve at t, where p0,p1,p2 are either all x or
+     * all y components of the target curve.
+     */
+    private static componentAt;
+    private static derivativeComponentAt;
+    /**
+     * @returns the curve evaluated at `t`.
+     */
+    at(t: number): Point2;
+    derivativeAt(t: number): Point2;
+    normal(t: number): Vec2;
+    /** @returns an overestimate of this shape's bounding box. */
+    getLooseBoundingBox(): Rect2;
+    /**
+     * @returns the *approximate* distance from `point` to this curve.
+     */
+    approximateDistance(point: Point2): number;
+    getPoints(): import("../Vec3").Vec3[];
+}
+export default QuadraticBezier;

package/dist/mjs/shapes/QuadraticBezier.mjs

@@ -0,0 +1,113 @@
+import  { Vec2 }  from '../Vec2.mjs';
+import  solveQuadratic  from '../polynomial/solveQuadratic.mjs';
+import  BezierJSWrapper  from './BezierJSWrapper.mjs';
+import  Rect2  from './Rect2.mjs';
+/**
+ * A wrapper around `bezier-js`'s quadratic Bézier.
+ *
+ * This wrappper lazy-loads `bezier-js`'s Bézier and can perform some operations
+ * without loading it at all (e.g. `normal`, `at`, and `approximateDistance`).
+ */
+export class QuadraticBezier extends BezierJSWrapper {
+    constructor(p0, p1, p2) {
+        super();
+        this.p0 = p0;
+        this.p1 = p1;
+        this.p2 = p2;
+    }
+    /**
+     * Returns a component of a quadratic Bézier curve at t, where p0,p1,p2 are either all x or
+     * all y components of the target curve.
+     */
+    static componentAt(t, p0, p1, p2) {
+        return p0 + t * (-2 * p0 + 2 * p1) + t * t * (p0 - 2 * p1 + p2);
+    }
+    static derivativeComponentAt(t, p0, p1, p2) {
+        return -2 * p0 + 2 * p1 + 2 * t * (p0 - 2 * p1 + p2);
+    }
+    /**
+     * @returns the curve evaluated at `t`.
+     */
+    at(t) {
+        const p0 = this.p0;
+        const p1 = this.p1;
+        const p2 = this.p2;
+        return Vec2.of(QuadraticBezier.componentAt(t, p0.x, p1.x, p2.x), QuadraticBezier.componentAt(t, p0.y, p1.y, p2.y));
+    }
+    derivativeAt(t) {
+        const p0 = this.p0;
+        const p1 = this.p1;
+        const p2 = this.p2;
+        return Vec2.of(QuadraticBezier.derivativeComponentAt(t, p0.x, p1.x, p2.x), QuadraticBezier.derivativeComponentAt(t, p0.y, p1.y, p2.y));
+    }
+    normal(t) {
+        const tangent = this.derivativeAt(t);
+        return tangent.orthog().normalized();
+    }
+    /** @returns an overestimate of this shape's bounding box. */
+    getLooseBoundingBox() {
+        return Rect2.bboxOf([this.p0, this.p1, this.p2]);
+    }
+    /**
+     * @returns the *approximate* distance from `point` to this curve.
+     */
+    approximateDistance(point) {
+        // We want to minimize f(t) = |B(t) - p|².
+        // Expanding,
+        //   f(t)  = (Bₓ(t) - pₓ)² + (Bᵧ(t) - pᵧ)²
+        // ⇒ f'(t) = Dₜ(Bₓ(t) - pₓ)² + Dₜ(Bᵧ(t) - pᵧ)²
+        //
+        // Considering just one component,
+        //  Dₜ(Bₓ(t) - pₓ)² = 2(Bₓ(t) - pₓ)(DₜBₓ(t))
+        //                  = 2(Bₓ(t)DₜBₓ(t) - pₓBₓ(t))
+        //   = 2(p0ₓ + (t)(-2p0ₓ + 2p1ₓ) + (t²)(p0ₓ - 2p1ₓ + p2ₓ) - pₓ)((-2p0ₓ + 2p1ₓ) + 2(t)(p0ₓ - 2p1ₓ + p2ₓ))
+        //     - (pₓ)((-2p0ₓ + 2p1ₓ) + (t)(p0ₓ - 2p1ₓ + p2ₓ))
+        const A = this.p0.x - point.x;
+        const B = -2 * this.p0.x + 2 * this.p1.x;
+        const C = this.p0.x - 2 * this.p1.x + this.p2.x;
+        // Let A = p0ₓ - pₓ, B = -2p0ₓ + 2p1ₓ, C = p0ₓ - 2p1ₓ + p2ₓ. We then have,
+        //  Dₜ(Bₓ(t) - pₓ)²
+        //    = 2(A + tB + t²C)(B + 2tC) - (pₓ)(B + 2tC)
+        //    = 2(AB + tB² + t²BC + 2tCA + 2tCtB + 2tCt²C) - pₓB - pₓ2tC
+        //    = 2(AB + tB² + 2tCA + t²BC + 2t²CB + 2C²t³) - pₓB - pₓ2tC
+        //    = 2AB + 2t(B² + 2CA) + 2t²(BC + 2CB) + 4C²t³ - pₓB - pₓ2tC
+        //    = 2AB + 2t(B² + 2CA - pₓC) + 2t²(BC + 2CB) + 4C²t³ - pₓB
+        //
+        const D = this.p0.y - point.y;
+        const E = -2 * this.p0.y + 2 * this.p1.y;
+        const F = this.p0.y - 2 * this.p1.y + this.p2.y;
+        // Using D = p0ᵧ - pᵧ, E = -2p0ᵧ + 2p1ᵧ, F = p0ᵧ - 2p1ᵧ + p2ᵧ, we thus have,
+        //  f'(t) = 2AB + 2t(B² + 2CA - pₓC) + 2t²(BC + 2CB) + 4C²t³ - pₓB
+        //        + 2DE + 2t(E² + 2FD - pᵧF) + 2t²(EF + 2FE) + 4F²t³ - pᵧE
+        const a = 2 * A * B + 2 * D * E - point.x * B - point.y * E;
+        const b = 2 * B * B + 2 * E * E + 2 * C * A + 2 * F * D - point.x * C - point.y * F;
+        const c = 2 * E * F + 2 * B * C + 2 * C * B + 2 * F * E;
+        //const d = 4 * C * C + 4 * F * F;
+        // Thus,
+        // f'(t) = a + bt + ct² + dt³
+        const fDerivAtZero = a;
+        const f2ndDerivAtZero = b;
+        const f3rdDerivAtZero = 2 * c;
+        // Using the first few terms of a Maclaurin series to approximate f'(t),
+        // f'(t) ≈ f'(0) + t f''(0) + t² f'''(0) / 2
+        let [min1, min2] = solveQuadratic(f3rdDerivAtZero / 2, f2ndDerivAtZero, fDerivAtZero);
+        // If the quadratic has no solutions, approximate.
+        if (isNaN(min1)) {
+            min1 = 0.25;
+        }
+        if (isNaN(min2)) {
+            min2 = 0.75;
+        }
+        const at1 = this.at(min1);
+        const at2 = this.at(min2);
+        const sqrDist1 = at1.minus(point).magnitudeSquared();
+        const sqrDist2 = at2.minus(point).magnitudeSquared();
+        const sqrDist3 = this.at(0).minus(point).magnitudeSquared();
+        const sqrDist4 = this.at(1).minus(point).magnitudeSquared();
+        return Math.sqrt(Math.min(sqrDist1, sqrDist2, sqrDist3, sqrDist4));
+    }
+    getPoints() {
+        return [this.p0, this.p1, this.p2];
+    }
+}
+export default QuadraticBezier;

package/dist/mjs/shapes/Rect2.d.ts

@@ -0,0 +1,58 @@
+import LineSegment2 from './LineSegment2';
+import Mat33 from '../Mat33';
+import { Point2, Vec2 } from '../Vec2';
+import Abstract2DShape from './Abstract2DShape';
+import Vec3 from '../Vec3';
+/** An object that can be converted to a Rect2. */
+export interface RectTemplate {
+    x: number;
+    y: number;
+    w?: number;
+    h?: number;
+    width?: number;
+    height?: number;
+}
+export declare class Rect2 extends Abstract2DShape {
+    readonly x: number;
+    readonly y: number;
+    readonly w: number;
+    readonly h: number;
+    readonly topLeft: Point2;
+    readonly size: Vec2;
+    readonly bottomRight: Point2;
+    readonly area: number;
+    constructor(x: number, y: number, w: number, h: number);
+    translatedBy(vec: Vec2): Rect2;
+    resizedTo(size: Vec2): Rect2;
+    containsPoint(other: Point2): boolean;
+    containsRect(other: Rect2): boolean;
+    intersects(other: Rect2): boolean;
+    intersection(other: Rect2): Rect2 | null;
+    union(other: Rect2): Rect2;
+    divideIntoGrid(columns: number, rows: number): Rect2[];
+    grownToPoint(point: Point2, margin?: number): Rect2;
+    grownBy(margin: number): Rect2;
+    getClosestPointOnBoundaryTo(target: Point2): Vec3;
+    get corners(): Point2[];
+    get maxDimension(): number;
+    get topRight(): Vec3;
+    get bottomLeft(): Vec3;
+    get width(): number;
+    get height(): number;
+    get center(): Vec3;
+    getEdges(): LineSegment2[];
+    intersectsLineSegment(lineSegment: LineSegment2): Point2[];
+    signedDistance(point: Vec3): number;
+    getTightBoundingBox(): Rect2;
+    transformedBoundingBox(affineTransform: Mat33): Rect2;
+    /** @return true iff this is equal to [other] ± fuzz */
+    eq(other: Rect2, fuzz?: number): boolean;
+    toString(): string;
+    static fromCorners(corner1: Point2, corner2: Point2): Rect2;
+    static bboxOf(points: Point2[], margin?: number): Rect2;
+    static union(...rects: Rect2[]): Rect2;
+    static of(template: RectTemplate): Rect2;
+    static empty: Rect2;
+    static unitSquare: Rect2;
+}
+export default Rect2;

package/dist/mjs/shapes/Rect2.mjs

@@ -0,0 +1,252 @@
+import  LineSegment2  from './LineSegment2.mjs';
+import  { Vec2 }  from '../Vec2.mjs';
+import  Abstract2DShape  from './Abstract2DShape.mjs';
+// invariant: w ≥ 0, h ≥ 0, immutable
+export class Rect2 extends Abstract2DShape {
+    constructor(x, y, w, h) {
+        super();
+        this.x = x;
+        this.y = y;
+        this.w = w;
+        this.h = h;
+        if (w < 0) {
+            this.x += w;
+            this.w = Math.abs(w);
+        }
+        if (h < 0) {
+            this.y += h;
+            this.h = Math.abs(h);
+        }
+        // Precompute/store vector forms.
+        this.topLeft = Vec2.of(this.x, this.y);
+        this.size = Vec2.of(this.w, this.h);
+        this.bottomRight = this.topLeft.plus(this.size);
+        this.area = this.w * this.h;
+    }
+    translatedBy(vec) {
+        return new Rect2(vec.x + this.x, vec.y + this.y, this.w, this.h);
+    }
+    // Returns a copy of this with the given size (but same top-left).
+    resizedTo(size) {
+        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;
+    }
+    containsRect(other) {
+        return this.x <= other.x && this.y <= other.y
+            && this.bottomRight.x >= other.bottomRight.x
+            && this.bottomRight.y >= other.bottomRight.y;
+    }
+    intersects(other) {
+        // Project along x/y axes.
+        const thisMinX = this.x;
+        const thisMaxX = thisMinX + this.w;
+        const otherMinX = other.x;
+        const otherMaxX = other.x + other.w;
+        if (thisMaxX < otherMinX || thisMinX > otherMaxX) {
+            return false;
+        }
+        const thisMinY = this.y;
+        const thisMaxY = thisMinY + this.h;
+        const otherMinY = other.y;
+        const otherMaxY = other.y + other.h;
+        if (thisMaxY < otherMinY || thisMinY > otherMaxY) {
+            return false;
+        }
+        return true;
+    }
+    // Returns the overlap of this and [other], or null, if no such
+    //          overlap exists
+    intersection(other) {
+        if (!this.intersects(other)) {
+            return null;
+        }
+        const topLeft = this.topLeft.zip(other.topLeft, Math.max);
+        const bottomRight = this.bottomRight.zip(other.bottomRight, Math.min);
+        return Rect2.fromCorners(topLeft, bottomRight);
+    }
+    // Returns a new rectangle containing both [this] and [other].
+    union(other) {
+        return Rect2.union(this, other);
+    }
+    // Returns a the subdivision of this into [columns] columns
+    // and [rows] rows. For example,
+    //	 Rect2.unitSquare.divideIntoGrid(2, 2)
+    //		-> [ Rect2(0, 0, 0.5, 0.5), Rect2(0.5, 0, 0.5, 0.5), Rect2(0, 0.5, 0.5, 0.5), Rect2(0.5, 0.5, 0.5, 0.5) ]
+    // The rectangles are ordered in row-major order.
+    divideIntoGrid(columns, rows) {
+        const result = [];
+        if (columns <= 0 || rows <= 0) {
+            return result;
+        }
+        const eachRectWidth = this.w / columns;
+        const eachRectHeight = this.h / rows;
+        if (eachRectWidth === 0) {
+            columns = 1;
+        }
+        if (eachRectHeight === 0) {
+            rows = 1;
+        }
+        for (let j = 0; j < rows; j++) {
+            for (let i = 0; i < columns; i++) {
+                const x = eachRectWidth * i + this.x;
+                const y = eachRectHeight * j + this.y;
+                result.push(new Rect2(x, y, eachRectWidth, eachRectHeight));
+            }
+        }
+        return result;
+    }
+    // Returns a rectangle containing this and [point].
+    // [margin] is the minimum distance between the new point and the edge
+    // of the resultant rectangle.
+    grownToPoint(point, margin = 0) {
+        const otherRect = new Rect2(point.x - margin, point.y - margin, margin * 2, margin * 2);
+        return this.union(otherRect);
+    }
+    // Returns this grown by [margin] in both the x and y directions.
+    grownBy(margin) {
+        if (margin === 0) {
+            return this;
+        }
+        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 => {
+            return edge.closestPointTo(target);
+        });
+        let closest = null;
+        let closestDist = null;
+        for (const point of closestEdgePoints) {
+            const dist = point.minus(target).length();
+            if (closestDist === null || dist < closestDist) {
+                closest = point;
+                closestDist = dist;
+            }
+        }
+        return closest;
+    }
+    get corners() {
+        return [
+            this.bottomRight,
+            this.topRight,
+            this.topLeft,
+            this.bottomLeft,
+        ];
+    }
+    get maxDimension() {
+        return Math.max(this.w, this.h);
+    }
+    get topRight() {
+        return this.bottomRight.plus(Vec2.of(0, -this.h));
+    }
+    get bottomLeft() {
+        return this.topLeft.plus(Vec2.of(0, this.h));
+    }
+    get width() {
+        return this.w;
+    }
+    get height() {
+        return this.h;
+    }
+    get center() {
+        return this.topLeft.plus(this.size.times(0.5));
+    }
+    // Returns edges in the order
+    // [ rightEdge, topEdge, leftEdge, bottomEdge ]
+    getEdges() {
+        const corners = this.corners;
+        return [
+            new LineSegment2(corners[0], corners[1]),
+            new LineSegment2(corners[1], corners[2]),
+            new LineSegment2(corners[2], corners[3]),
+            new LineSegment2(corners[3], corners[0]),
+        ];
+    }
+    intersectsLineSegment(lineSegment) {
+        const result = [];
+        for (const edge of this.getEdges()) {
+            const intersection = edge.intersectsLineSegment(lineSegment);
+            intersection.forEach(point => result.push(point));
+        }
+        return result;
+    }
+    signedDistance(point) {
+        const closestBoundaryPoint = this.getClosestPointOnBoundaryTo(point);
+        const dist = point.minus(closestBoundaryPoint).magnitude();
+        if (this.containsPoint(point)) {
+            return -dist;
+        }
+        return dist;
+    }
+    getTightBoundingBox() {
+        return this;
+    }
+    // [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 true iff this is equal to [other] ± fuzz */
+    eq(other, fuzz = 0) {
+        return this.topLeft.eq(other.topLeft, fuzz) && this.size.eq(other.size, fuzz);
+    }
+    toString() {
+        return `Rect(point(${this.x}, ${this.y}), size(${this.w}, ${this.h}))`;
+    }
+    static fromCorners(corner1, corner2) {
+        return new Rect2(Math.min(corner1.x, corner2.x), Math.min(corner1.y, corner2.y), Math.abs(corner1.x - corner2.x), Math.abs(corner1.y - corner2.y));
+    }
+    // Returns a box that contains all points in [points] with at least [margin]
+    // between each point and the edge of the box.
+    static bboxOf(points, margin = 0) {
+        let minX = 0;
+        let minY = 0;
+        let maxX = 0;
+        let maxY = 0;
+        let isFirst = true;
+        for (const point of points) {
+            if (isFirst) {
+                minX = point.x;
+                minY = point.y;
+                maxX = point.x;
+                maxY = point.y;
+                isFirst = false;
+            }
+            minX = Math.min(minX, point.x);
+            minY = Math.min(minY, point.y);
+            maxX = Math.max(maxX, point.x);
+            maxY = Math.max(maxY, point.y);
+        }
+        return Rect2.fromCorners(Vec2.of(minX - margin, minY - margin), Vec2.of(maxX + margin, maxY + margin));
+    }
+    // @returns a rectangle that contains all of the given rectangles, the bounding box
+    //     of the given rectangles.
+    static union(...rects) {
+        if (rects.length === 0) {
+            return Rect2.empty;
+        }
+        const firstRect = rects[0];
+        let minX = firstRect.topLeft.x;
+        let minY = firstRect.topLeft.y;
+        let maxX = firstRect.bottomRight.x;
+        let maxY = firstRect.bottomRight.y;
+        for (let i = 1; i < rects.length; i++) {
+            const rect = rects[i];
+            minX = Math.min(minX, rect.topLeft.x);
+            minY = Math.min(minY, rect.topLeft.y);
+            maxX = Math.max(maxX, rect.bottomRight.x);
+            maxY = Math.max(maxY, rect.bottomRight.y);
+        }
+        return new Rect2(minX, minY, maxX - minX, maxY - minY);
+    }
+    static of(template) {
+        const width = template.width ?? template.w ?? 0;
+        const height = template.height ?? template.h ?? 0;
+        return new Rect2(template.x, template.y, width, height);
+    }
+}
+Rect2.empty = new Rect2(0, 0, 0, 0);
+Rect2.unitSquare = new Rect2(0, 0, 1, 1);
+export default Rect2;

package/dist/mjs/shapes/Triangle.d.ts

@@ -0,0 +1,46 @@
+import Mat33 from '../Mat33';
+import { Point2 } from '../Vec2';
+import Vec3 from '../Vec3';
+import Abstract2DShape from './Abstract2DShape';
+import LineSegment2 from './LineSegment2';
+import Rect2 from './Rect2';
+type TriangleBoundary = [LineSegment2, LineSegment2, LineSegment2];
+export default class Triangle extends Abstract2DShape {
+    #private;
+    readonly vertex1: Vec3;
+    readonly vertex2: Vec3;
+    readonly vertex3: Vec3;
+    /**
+     * @see {@link fromVertices}
+     */
+    protected constructor(vertex1: Vec3, vertex2: Vec3, vertex3: Vec3);
+    /**
+     * Creates a triangle from its three corners. Corners may be stored in a different
+     * order than given.
+     */
+    static fromVertices(vertex1: Vec3, vertex2: Vec3, vertex3: Vec3): Triangle;
+    get vertices(): [Point2, Point2, Point2];
+    map(mapping: (vertex: Vec3) => Vec3): Triangle;
+    transformed2DBy(affineTransform: Mat33): Triangle;
+    transformedBy(linearTransform: Mat33): Triangle;
+    /**
+     * Returns the sides of this triangle, as an array of `LineSegment2`s.
+     *
+     * The first side is from `vertex1` to `vertex2`, the next from `vertex2` to `vertex3`,
+     * and the last from `vertex3` to `vertex1`.
+     */
+    getEdges(): TriangleBoundary;
+    intersectsLineSegment(lineSegment: LineSegment2): Vec3[];
+    /** @inheritdoc */
+    containsPoint(point: Vec3, epsilon?: number): boolean;
+    /**
+     * @returns the signed distance from `point` to the closest edge of this triangle.
+     *
+     * If `point` is inside `this`, the result is negative, otherwise, the result is
+     * positive.
+     */
+    signedDistance(point: Vec3): number;
+    /** @inheritdoc */
+    getTightBoundingBox(): Rect2;
+}
+export {};

package/dist/mjs/shapes/Triangle.mjs

@@ -0,0 +1,121 @@
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var _Triangle_sides;
+import  Abstract2DShape  from './Abstract2DShape.mjs';
+import  LineSegment2  from './LineSegment2.mjs';
+import  Rect2  from './Rect2.mjs';
+class Triangle extends Abstract2DShape {
+    /**
+     * @see {@link fromVertices}
+     */
+    constructor(vertex1, vertex2, vertex3) {
+        super();
+        this.vertex1 = vertex1;
+        this.vertex2 = vertex2;
+        this.vertex3 = vertex3;
+        _Triangle_sides.set(this, undefined);
+    }
+    /**
+     * Creates a triangle from its three corners. Corners may be stored in a different
+     * order than given.
+     */
+    static fromVertices(vertex1, vertex2, vertex3) {
+        return new Triangle(vertex1, vertex2, vertex3);
+    }
+    get vertices() {
+        return [this.vertex1, this.vertex2, this.vertex3];
+    }
+    map(mapping) {
+        return new Triangle(mapping(this.vertex1), mapping(this.vertex2), mapping(this.vertex3));
+    }
+    // Transform, treating this as composed of 2D points.
+    transformed2DBy(affineTransform) {
+        return this.map(affineTransform.transformVec2);
+    }
+    // Transforms this by a linear transform --- verticies are treated as
+    // 3D points.
+    transformedBy(linearTransform) {
+        return this.map(linearTransform.transformVec3);
+    }
+    /**
+     * Returns the sides of this triangle, as an array of `LineSegment2`s.
+     *
+     * The first side is from `vertex1` to `vertex2`, the next from `vertex2` to `vertex3`,
+     * and the last from `vertex3` to `vertex1`.
+     */
+    getEdges() {
+        if (__classPrivateFieldGet(this, _Triangle_sides, "f")) {
+            return __classPrivateFieldGet(this, _Triangle_sides, "f");
+        }
+        const side1 = new LineSegment2(this.vertex1, this.vertex2);
+        const side2 = new LineSegment2(this.vertex2, this.vertex3);
+        const side3 = new LineSegment2(this.vertex3, this.vertex1);
+        const sides = [side1, side2, side3];
+        __classPrivateFieldSet(this, _Triangle_sides, sides, "f");
+        return sides;
+    }
+    intersectsLineSegment(lineSegment) {
+        const result = [];
+        for (const edge of this.getEdges()) {
+            edge.intersectsLineSegment(lineSegment)
+                .forEach(point => result.push(point));
+        }
+        return result;
+    }
+    /** @inheritdoc */
+    containsPoint(point, epsilon = Abstract2DShape.smallValue) {
+        // Project `point` onto normals to each of this' sides.
+        // Uses the Separating Axis Theorem (https://en.wikipedia.org/wiki/Hyperplane_separation_theorem#Use_in_collision_detection)
+        const sides = this.getEdges();
+        for (const side of sides) {
+            const orthog = side.direction.orthog();
+            // Project all three vertices
+            // TODO: Performance can be improved here (two vertices will always have the same projection)
+            const projv1 = orthog.dot(this.vertex1);
+            const projv2 = orthog.dot(this.vertex2);
+            const projv3 = orthog.dot(this.vertex3);
+            const minProjVertex = Math.min(projv1, projv2, projv3);
+            const maxProjVertex = Math.max(projv1, projv2, projv3);
+            const projPoint = orthog.dot(point);
+            const inProjection = projPoint >= minProjVertex - epsilon && projPoint <= maxProjVertex + epsilon;
+            if (!inProjection) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * @returns the signed distance from `point` to the closest edge of this triangle.
+     *
+     * If `point` is inside `this`, the result is negative, otherwise, the result is
+     * positive.
+     */
+    signedDistance(point) {
+        const sides = this.getEdges();
+        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.
+        if (this.containsPoint(point, 0)) {
+            return -distance;
+        }
+        else {
+            return distance;
+        }
+    }
+    /** @inheritdoc */
+    getTightBoundingBox() {
+        return Rect2.bboxOf(this.vertices);
+    }
+}
+_Triangle_sides = new WeakMap();
+export default Triangle;