js-draw 0.23.1 → 0.24.1

package/dist/mjs/src/math/Rect2.d.ts

@@ -1,52 +0,0 @@
-import LineSegment2 from './LineSegment2';
-import Mat33 from './Mat33';
-import { Point2, Vec2 } from './Vec2';
-/** 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 default class Rect2 {
-    readonly x: number;
-    readonly y: number;
-    readonly w: number;
-    readonly h: number;
-    readonly topLeft: Point2;
-    readonly size: Vec2;
-    readonly bottomRight: Point2;
-    readonly center: 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): import("./Vec3").default;
-    get corners(): Point2[];
-    get maxDimension(): number;
-    get topRight(): import("./Vec3").default;
-    get bottomLeft(): import("./Vec3").default;
-    get width(): number;
-    get height(): number;
-    getEdges(): LineSegment2[];
-    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;
-}

package/dist/mjs/src/math/Rect2.mjs

@@ -1,230 +0,0 @@
-import  LineSegment2  from './LineSegment2.mjs';
-import  { Vec2 }  from './Vec2.mjs';
-// invariant: w ≥ 0, h ≥ 0.
-class Rect2 {
-    constructor(x, y, w, h) {
-        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.center = this.topLeft.plus(this.size.times(0.5));
-        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;
-    }
-    // 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]),
-        ];
-    }
-    // [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) {
-        var _a, _b, _c, _d;
-        const width = (_b = (_a = template.width) !== null && _a !== void 0 ? _a : template.w) !== null && _b !== void 0 ? _b : 0;
-        const height = (_d = (_c = template.height) !== null && _c !== void 0 ? _c : template.h) !== null && _d !== void 0 ? _d : 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/src/math/Triangle.d.ts

@@ -1,11 +0,0 @@
-import Mat33 from './Mat33';
-import Vec3 from './Vec3';
-export default class Triangle {
-    readonly vertex1: Vec3;
-    readonly vertex2: Vec3;
-    readonly vertex3: Vec3;
-    constructor(vertex1: Vec3, vertex2: Vec3, vertex3: Vec3);
-    map(mapping: (vertex: Vec3) => Vec3): Triangle;
-    transformed2DBy(affineTransform: Mat33): Triangle;
-    transformedBy(linearTransform: Mat33): Triangle;
-}

package/dist/mjs/src/math/Triangle.mjs

@@ -1,19 +0,0 @@
-export default class Triangle {
-    constructor(vertex1, vertex2, vertex3) {
-        this.vertex1 = vertex1;
-        this.vertex2 = vertex2;
-        this.vertex3 = 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);
-    }
-}

package/dist/mjs/src/math/Vec2.mjs

@@ -1,33 +0,0 @@
-import  Vec3  from './Vec3.mjs';
-export var Vec2;
-(function (Vec2) {
-    /**
-     * Creates a `Vec2` from an x and y coordinate.
-     *
-     * For example,
-     * ```ts
-     * const v = Vec2.of(3, 4); // x=3, y=4.
-     * ```
-     */
-    Vec2.of = (x, y) => {
-        return Vec3.of(x, y, 0);
-    };
-    /**
-     * Creates a `Vec2` from an object containing x and y coordinates.
-     *
-     * For example,
-     * ```ts
-     * const v1 = Vec2.ofXY({ x: 3, y: 4.5 });
-     * const v2 = Vec2.ofXY({ x: -123.4, y: 1 });
-     * ```
-     */
-    Vec2.ofXY = ({ x, y }) => {
-        return Vec3.of(x, y, 0);
-    };
-    /** A vector of length 1 in the X direction (→). */
-    Vec2.unitX = Vec2.of(1, 0);
-    /** A vector of length 1 in the Y direction (↑). */
-    Vec2.unitY = Vec2.of(0, 1);
-    /** The zero vector: A vector with x=0, y=0. */
-    Vec2.zero = Vec2.of(0, 0);
-})(Vec2 || (Vec2 = {}));

package/dist/mjs/src/math/Vec3.mjs

@@ -1,175 +0,0 @@
-/**
- * A vector with three components. Can also be used to represent a two-component vector.
- *
- * A `Vec3` is immutable.
- */
-class Vec3 {
-    constructor(x, y, z) {
-        this.x = x;
-        this.y = y;
-        this.z = z;
-    }
-    /** Returns the x, y components of this. */
-    get xy() {
-        // Useful for APIs that behave differently if .z is present.
-        return {
-            x: this.x,
-            y: this.y,
-        };
-    }
-    static of(x, y, z) {
-        return new Vec3(x, y, z);
-    }
-    /** Returns this' `idx`th component. For example, `Vec3.of(1, 2, 3).at(1) → 2`. */
-    at(idx) {
-        if (idx === 0)
-            return this.x;
-        if (idx === 1)
-            return this.y;
-        if (idx === 2)
-            return this.z;
-        throw new Error(`${idx} out of bounds!`);
-    }
-    /** Alias for this.magnitude. */
-    length() {
-        return this.magnitude();
-    }
-    magnitude() {
-        return Math.sqrt(this.dot(this));
-    }
-    magnitudeSquared() {
-        return this.dot(this);
-    }
-    /**
-     * Return this' angle in the XY plane (treats this as a Vec2).
-     *
-     * This is equivalent to `Math.atan2(vec.y, vec.x)`.
-     */
-    angle() {
-        return Math.atan2(this.y, this.x);
-    }
-    /**
-     * Returns a unit vector in the same direction as this.
-     *
-     * If `this` has zero length, the resultant vector has `NaN` components.
-     */
-    normalized() {
-        const norm = this.magnitude();
-        return Vec3.of(this.x / norm, this.y / norm, this.z / norm);
-    }
-    /** @returns A copy of `this` multiplied by a scalar. */
-    times(c) {
-        return Vec3.of(this.x * c, this.y * c, this.z * c);
-    }
-    plus(v) {
-        return Vec3.of(this.x + v.x, this.y + v.y, this.z + v.z);
-    }
-    minus(v) {
-        return Vec3.of(this.x - v.x, this.y - v.y, this.z - v.z);
-    }
-    dot(other) {
-        return this.x * other.x + this.y * other.y + this.z * other.z;
-    }
-    cross(other) {
-        // | 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 - other.y * this.z, other.x * this.z - this.x * other.z, this.x * other.y - other.x * this.y);
-    }
-    /**
-     * If `other` is a `Vec3`, multiplies `this` component-wise by `other`. Otherwise,
-     * if `other is a `number`, returns the result of scalar multiplication.
-     *
-     * @example
-     * ```
-     * Vec3.of(1, 2, 3).scale(Vec3.of(2, 4, 6)); // → Vec3(2, 8, 18)
-     * ```
-     */
-    scale(other) {
-        if (typeof other === 'number') {
-            return this.times(other);
-        }
-        return Vec3.of(this.x * other.x, this.y * other.y, this.z * other.z);
-    }
-    /**
-     * Returns a vector orthogonal to this. If this is a Vec2, returns `this` rotated
-     * 90 degrees counter-clockwise.
-     */
-    orthog() {
-        // If parallel to the z-axis
-        if (this.dot(Vec3.unitX) === 0 && this.dot(Vec3.unitY) === 0) {
-            return this.dot(Vec3.unitX) === 0 ? Vec3.unitX : this.cross(Vec3.unitX).normalized();
-        }
-        return this.cross(Vec3.unitZ.times(-1)).normalized();
-    }
-    /** Returns this plus a vector of length `distance` in `direction`. */
-    extend(distance, direction) {
-        return this.plus(direction.normalized().times(distance));
-    }
-    /** Returns a vector `fractionTo` of the way to target from this. */
-    lerp(target, fractionTo) {
-        return this.times(1 - fractionTo).plus(target.times(fractionTo));
-    }
-    /**
-     * `zip` Maps a component of this and a corresponding component of
-     * `other` to a component of the output vector.
-     *
-     * @example
-     * ```
-     * const a = Vec3.of(1, 2, 3);
-     * const b = Vec3.of(0.5, 2.1, 2.9);
-     *
-     * const zipped = a.zip(b, (aComponent, bComponent) => {
-     *   return Math.min(aComponent, bComponent);
-     * });
-     *
-     * console.log(zipped.toString()); // → Vec(0.5, 2, 2.9)
-     * ```
-     */
-    zip(other, zip) {
-        return Vec3.of(zip(other.x, this.x), zip(other.y, this.y), zip(other.z, this.z));
-    }
-    /**
-     * Returns a vector with each component acted on by `fn`.
-     *
-     * @example
-     * ```
-     * console.log(Vec3.of(1, 2, 3).map(val => val + 1)); // → Vec(2, 3, 4)
-     * ```
-     */
-    map(fn) {
-        return Vec3.of(fn(this.x, 0), fn(this.y, 1), fn(this.z, 2));
-    }
-    asArray() {
-        return [this.x, this.y, this.z];
-    }
-    /**
-     * [fuzz] The maximum difference between two components for this and [other]
-     * to be considered equal.
-     *
-     * @example
-     * ```
-     * Vec3.of(1, 2, 3).eq(Vec3.of(4, 5, 6), 100);  // → true
-     * Vec3.of(1, 2, 3).eq(Vec3.of(4, 5, 6), 0.1);  // → false
-     * Vec3.of(1, 2, 3).eq(Vec3.of(4, 5, 6), 3);    // → true
-     * Vec3.of(1, 2, 3).eq(Vec3.of(4, 5, 6), 3.01); // → true
-     * Vec3.of(1, 2, 3).eq(Vec3.of(4, 5, 6), 2.99); // → false
-     * ```
-     */
-    eq(other, fuzz = 1e-10) {
-        for (let i = 0; i < 3; i++) {
-            if (Math.abs(other.at(i) - this.at(i)) > fuzz) {
-                return false;
-            }
-        }
-        return true;
-    }
-    toString() {
-        return `Vec(${this.x}, ${this.y}, ${this.z})`;
-    }
-}
-Vec3.unitX = Vec3.of(1, 0, 0);
-Vec3.unitY = Vec3.of(0, 1, 0);
-Vec3.unitZ = Vec3.of(0, 0, 1);
-Vec3.zero = Vec3.of(0, 0, 0);
-export default Vec3;

package/dist/mjs/src/math/lib.d.ts

@@ -1,7 +0,0 @@
-import LineSegment2 from './LineSegment2';
-import Mat33 from './Mat33';
-import Path from './Path';
-import Rect2 from './Rect2';
-import { Vec2 } from './Vec2';
-import Vec3 from './Vec3';
-export { LineSegment2, Mat33, Path, Rect2, Vec3, Vec2, };

package/dist/mjs/src/math/lib.mjs

@@ -1,7 +0,0 @@
-import  LineSegment2  from './LineSegment2.mjs';
-import  Mat33  from './Mat33.mjs';
-import  Path  from './Path.mjs';
-import  Rect2  from './Rect2.mjs';
-import  { Vec2 }  from './Vec2.mjs';
-import  Vec3  from './Vec3.mjs';
-export { LineSegment2, Mat33, Path, Rect2, Vec3, Vec2, };

package/dist/mjs/src/math/polynomial/QuadraticBezier.d.ts

@@ -1,28 +0,0 @@
-import { Point2, Vec2 } from '../Vec2';
-export default class QuadraticBezier {
-    readonly p0: Point2;
-    readonly p1: Point2;
-    readonly p2: Point2;
-    private bezierJs;
-    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;
-    /**
-     * @returns the approximate distance from `point` to this curve.
-     */
-    approximateDistance(point: Point2): number;
-    /**
-     * @returns the (more) exact distance from `point` to this.
-     */
-    distance(point: Point2): number;
-    normal(t: number): Vec2;
-}

package/dist/mjs/src/math/polynomial/QuadraticBezier.mjs

@@ -1,108 +0,0 @@
-import { Bezier } from 'bezier-js';
-import  { Vec2 }  from '../Vec2.mjs';
-import  solveQuadratic  from './solveQuadratic.mjs';
-export default class QuadraticBezier {
-    constructor(p0, p1, p2) {
-        this.p0 = p0;
-        this.p1 = p1;
-        this.p2 = p2;
-        this.bezierJs = null;
-    }
-    /**
-     * 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));
-    }
-    /**
-     * @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));
-    }
-    /**
-     * @returns the (more) exact distance from `point` to this.
-     */
-    distance(point) {
-        if (!this.bezierJs) {
-            this.bezierJs = new Bezier([this.p0.xy, this.p1.xy, this.p2.xy]);
-        }
-        // .d: Distance
-        return this.bezierJs.project(point.xy).d;
-    }
-    normal(t) {
-        const tangent = this.derivativeAt(t);
-        return tangent.orthog().normalized();
-    }
-}

package/dist/mjs/src/math/polynomial/solveQuadratic.d.ts

@@ -1,6 +0,0 @@
-/**
- * Solves an equation of the form ax² + bx + c = 0.
- * The larger solution is returned first.
- */
-declare const solveQuadratic: (a: number, b: number, c: number) => [number, number];
-export default solveQuadratic;