@js-draw/math 1.0.0

package/dist/mjs/Vec3.mjs

@@ -0,0 +1,199 @@
+/**
+ * A vector with three components, $\begin{pmatrix} x \\ y \\ z \end{pmatrix}$.
+ * Can also be used to represent a two-component vector.
+ *
+ * A `Vec3` is immutable.
+ *
+ * @example
+ *
+ * ```ts,runnable,console
+ * import { Vec3 } from '@js-draw/math';
+ *
+ * console.log('Vector addition:', Vec3.of(1, 2, 3).plus(Vec3.of(0, 1, 0)));
+ * console.log('Scalar multiplication:', Vec3.of(1, 2, 3).times(2));
+ * console.log('Cross products:', Vec3.unitX.cross(Vec3.unitY));
+ * console.log('Magnitude:', Vec3.of(1, 2, 3).length(), 'or', Vec3.of(1, 2, 3).magnitude());
+ * console.log('Square Magnitude:', Vec3.of(1, 2, 3).magnitudeSquared());
+ * console.log('As an array:', Vec3.unitZ.asArray());
+ * ```
+ */
+export 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,
+        };
+    }
+    /** Construct a vector from three components. */
+    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);
+    }
+    /**
+     * Like {@link normalized}, except returns zero if this has zero magnitude.
+     */
+    normalizedOrZero() {
+        if (this.eq(Vec3.zero)) {
+            return Vec3.zero;
+        }
+        return this.normalized();
+    }
+    /** @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/lib.d.ts

@@ -0,0 +1,27 @@
+/**
+ * ```ts,runnable,console
+ * import { Vec2, Mat33, Rect2 } from '@js-draw/math';
+ *
+ * // Example: Rotate a vector 90 degrees about the z-axis
+ * const rotate90Degrees = Mat33.zRotation(Math.PI/2); // π/2 radians = 90 deg
+ * const moveUp = Mat33.translation(Vec2.of(1, 0));
+ * const moveUpThenRotate = rotate90Degrees.rightMul(moveUp);
+ * console.log(moveUpThenRotate.transformVec2(Vec2.of(1, 2)));
+ *
+ * // Example: Bounding box of some points
+ * console.log(Rect2.bboxOf([
+ *   Vec2.of(1, 2), Vec2.of(3, 4), Vec2.of(-100, 1000),
+ * ]));
+ * ```
+ *
+ * @packageDocumentation
+ */
+export { LineSegment2 } from './shapes/LineSegment2';
+export { Path, PathCommandType, PathCommand, LinePathCommand, MoveToPathCommand, QuadraticBezierPathCommand, CubicBezierPathCommand, } from './shapes/Path';
+export { Rect2 } from './shapes/Rect2';
+export { QuadraticBezier } from './shapes/QuadraticBezier';
+export { Mat33, Mat33Array } from './Mat33';
+export { Point2, Vec2 } from './Vec2';
+export { Vec3 } from './Vec3';
+export { Color4 } from './Color4';
+export { toRoundedString } from './rounding';

package/dist/mjs/lib.mjs

@@ -0,0 +1,29 @@
+/**
+ * ```ts,runnable,console
+ * import { Vec2, Mat33, Rect2 } from '@js-draw/math';
+ *
+ * // Example: Rotate a vector 90 degrees about the z-axis
+ * const rotate90Degrees = Mat33.zRotation(Math.PI/2); // π/2 radians = 90 deg
+ * const moveUp = Mat33.translation(Vec2.of(1, 0));
+ * const moveUpThenRotate = rotate90Degrees.rightMul(moveUp);
+ * console.log(moveUpThenRotate.transformVec2(Vec2.of(1, 2)));
+ *
+ * // Example: Bounding box of some points
+ * console.log(Rect2.bboxOf([
+ *   Vec2.of(1, 2), Vec2.of(3, 4), Vec2.of(-100, 1000),
+ * ]));
+ * ```
+ *
+ * @packageDocumentation
+ */
+export  { LineSegment2 }  from './shapes/LineSegment2.mjs';
+export  { Path, PathCommandType, }  from './shapes/Path.mjs';
+export  { Rect2 }  from './shapes/Rect2.mjs';
+export  { QuadraticBezier }  from './shapes/QuadraticBezier.mjs';
+export  { Mat33 }  from './Mat33.mjs';
+export  { Vec2 }  from './Vec2.mjs';
+export  { Vec3 }  from './Vec3.mjs';
+export  { Color4 }  from './Color4.mjs';
+export  { toRoundedString }  from './rounding.mjs';
+// Note: All above exports cannot use `export { default as ... } from "..."` because this
+// breaks TypeDoc -- TypeDoc otherwise labels any imports of these classes as `default`.

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

@@ -0,0 +1,9 @@
+/**
+ * Solves an equation of the form ax² + bx + c = 0.
+ * The larger solution is returned first.
+ *
+ * If there are no solutions, returns `[NaN, NaN]`. If there is one solution,
+ * repeats the solution twice in the result.
+ */
+declare const solveQuadratic: (a: number, b: number, c: number) => [number, number];
+export default solveQuadratic;

package/dist/mjs/polynomial/solveQuadratic.mjs

@@ -0,0 +1,37 @@
+/**
+ * Solves an equation of the form ax² + bx + c = 0.
+ * The larger solution is returned first.
+ *
+ * If there are no solutions, returns `[NaN, NaN]`. If there is one solution,
+ * repeats the solution twice in the result.
+ */
+const solveQuadratic = (a, b, c) => {
+    // See also https://en.wikipedia.org/wiki/Quadratic_formula
+    if (a === 0) {
+        let solution;
+        if (b === 0) {
+            solution = c === 0 ? 0 : NaN;
+        }
+        else {
+            // Then we have bx + c = 0
+            // which implies bx = -c.
+            // Thus, x = -c/b
+            solution = -c / b;
+        }
+        return [solution, solution];
+    }
+    const discriminant = b * b - 4 * a * c;
+    if (discriminant < 0) {
+        return [NaN, NaN];
+    }
+    const rootDiscriminant = Math.sqrt(discriminant);
+    const solution1 = (-b + rootDiscriminant) / (2 * a);
+    const solution2 = (-b - rootDiscriminant) / (2 * a);
+    if (solution1 > solution2) {
+        return [solution1, solution2];
+    }
+    else {
+        return [solution2, solution1];
+    }
+};
+export default solveQuadratic;

package/dist/mjs/rounding.d.ts

@@ -0,0 +1,15 @@
+export declare const cleanUpNumber: (text: string) => string;
+/**
+ * Converts `num` to a string, removing trailing digits that were likely caused by
+ * precision errors.
+ *
+ * @example
+ * ```ts,runnable,console
+ * import { toRoundedString } from '@js-draw/math';
+ *
+ * console.log('Rounded: ', toRoundedString(1.000000011));
+ * ```
+ */
+export declare const toRoundedString: (num: number) => string;
+export declare const getLenAfterDecimal: (numberAsString: string) => number;
+export declare const toStringOfSamePrecision: (num: number, ...references: string[]) => string;

package/dist/mjs/rounding.mjs

@@ -0,0 +1,139 @@
+// @packageDocumentation @internal
+// Clean up stringified numbers
+export const cleanUpNumber = (text) => {
+    // Regular expression substitions can be somewhat expensive. Only do them
+    // if necessary.
+    if (text.indexOf('e') > 0) {
+        // Round to zero.
+        if (text.match(/[eE][-]\d{2,}$/)) {
+            return '0';
+        }
+    }
+    const lastChar = text.charAt(text.length - 1);
+    if (lastChar === '0' || lastChar === '.') {
+        // Remove trailing zeroes
+        text = text.replace(/([.]\d*[^0]+)0+$/, '$1');
+        text = text.replace(/[.]0+$/, '.');
+        // Remove trailing period
+        text = text.replace(/[.]$/, '');
+    }
+    const firstChar = text.charAt(0);
+    if (firstChar === '0' || firstChar === '-') {
+        // Remove unnecessary leading zeroes.
+        text = text.replace(/^(0+)[.]/, '.');
+        text = text.replace(/^-(0+)[.]/, '-.');
+        text = text.replace(/^(-?)0+$/, '$10');
+    }
+    if (text === '-0') {
+        return '0';
+    }
+    return text;
+};
+/**
+ * Converts `num` to a string, removing trailing digits that were likely caused by
+ * precision errors.
+ *
+ * @example
+ * ```ts,runnable,console
+ * import { toRoundedString } from '@js-draw/math';
+ *
+ * console.log('Rounded: ', toRoundedString(1.000000011));
+ * ```
+ */
+export const toRoundedString = (num) => {
+    // Try to remove rounding errors. If the number ends in at least three/four zeroes
+    // (or nines) just one or two digits, it's probably a rounding error.
+    const fixRoundingUpExp = /^([-]?\d*\.\d{3,})0{4,}\d{1,4}$/;
+    const hasRoundingDownExp = /^([-]?)(\d*)\.(\d{3,}9{4,})\d{1,4}$/;
+    let text = num.toString(10);
+    if (text.indexOf('.') === -1) {
+        return text;
+    }
+    const roundingDownMatch = hasRoundingDownExp.exec(text);
+    if (roundingDownMatch) {
+        const negativeSign = roundingDownMatch[1];
+        const postDecimalString = roundingDownMatch[3];
+        const lastDigit = parseInt(postDecimalString.charAt(postDecimalString.length - 1), 10);
+        const postDecimal = parseInt(postDecimalString, 10);
+        const preDecimal = parseInt(roundingDownMatch[2], 10);
+        const origPostDecimalString = roundingDownMatch[3];
+        let newPostDecimal = (postDecimal + 10 - lastDigit).toString();
+        let carry = 0;
+        if (newPostDecimal.length > postDecimal.toString().length) {
+            // Left-shift
+            newPostDecimal = newPostDecimal.substring(1);
+            carry = 1;
+        }
+        // parseInt(...).toString() removes leading zeroes. Add them back.
+        while (newPostDecimal.length < origPostDecimalString.length) {
+            newPostDecimal = carry.toString(10) + newPostDecimal;
+            carry = 0;
+        }
+        text = `${negativeSign + (preDecimal + carry).toString()}.${newPostDecimal}`;
+    }
+    text = text.replace(fixRoundingUpExp, '$1');
+    return cleanUpNumber(text);
+};
+const numberExp = /^([-]?)(\d*)[.](\d+)$/;
+export const getLenAfterDecimal = (numberAsString) => {
+    const numberMatch = numberExp.exec(numberAsString);
+    if (!numberMatch) {
+        // If not a match, either the number is exponential notation (or is something
+        // like NaN or Infinity)
+        if (numberAsString.search(/[eE]/) !== -1 || /^[a-zA-Z]+$/.exec(numberAsString)) {
+            return -1;
+            // Or it has no decimal point
+        }
+        else {
+            return 0;
+        }
+    }
+    const afterDecimalLen = numberMatch[3].length;
+    return afterDecimalLen;
+};
+// [reference] should be a string representation of a base-10 number (no exponential (e.g. 10e10))
+export const toStringOfSamePrecision = (num, ...references) => {
+    const text = num.toString(10);
+    const textMatch = numberExp.exec(text);
+    if (!textMatch) {
+        return text;
+    }
+    let decimalPlaces = -1;
+    for (const reference of references) {
+        decimalPlaces = Math.max(getLenAfterDecimal(reference), decimalPlaces);
+    }
+    if (decimalPlaces === -1) {
+        return toRoundedString(num);
+    }
+    // Make text's after decimal length match [afterDecimalLen].
+    let postDecimal = textMatch[3].substring(0, decimalPlaces);
+    let preDecimal = textMatch[2];
+    const nextDigit = textMatch[3].charAt(decimalPlaces);
+    if (nextDigit !== '') {
+        const asNumber = parseInt(nextDigit, 10);
+        if (asNumber >= 5) {
+            // Don't attempt to parseInt() an empty string.
+            if (postDecimal.length > 0) {
+                const leadingZeroMatch = /^(0+)(\d*)$/.exec(postDecimal);
+                let leadingZeroes = '';
+                let postLeading = postDecimal;
+                if (leadingZeroMatch) {
+                    leadingZeroes = leadingZeroMatch[1];
+                    postLeading = leadingZeroMatch[2];
+                }
+                postDecimal = (parseInt(postDecimal) + 1).toString();
+                // If postDecimal got longer, remove leading zeroes if possible
+                if (postDecimal.length > postLeading.length && leadingZeroes.length > 0) {
+                    leadingZeroes = leadingZeroes.substring(1);
+                }
+                postDecimal = leadingZeroes + postDecimal;
+            }
+            if (postDecimal.length === 0 || postDecimal.length > decimalPlaces) {
+                preDecimal = (parseInt(preDecimal) + 1).toString();
+                postDecimal = postDecimal.substring(1);
+            }
+        }
+    }
+    const negativeSign = textMatch[1];
+    return cleanUpNumber(`${negativeSign}${preDecimal}.${postDecimal}`);
+};

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

@@ -0,0 +1,49 @@
+import LineSegment2 from './LineSegment2';
+import { Point2 } from '../Vec2';
+import Rect2 from './Rect2';
+declare abstract class Abstract2DShape {
+    protected static readonly smallValue = 1e-12;
+    /**
+     * @returns the distance from `point` to this shape. If `point` is within this shape,
+     * this returns the distance from `point` to the edge of this shape.
+     *
+     * @see {@link signedDistance}
+     */
+    distance(point: Point2): number;
+    /**
+     * Computes the [signed distance function](https://en.wikipedia.org/wiki/Signed_distance_function)
+     * for this shape.
+     */
+    abstract signedDistance(point: Point2): number;
+    /**
+     * @returns points at which this shape intersects the given `lineSegment`.
+     *
+     * If this is a closed shape, returns points where the given `lineSegment` intersects
+     * the **boundary** of this.
+     */
+    abstract intersectsLineSegment(lineSegment: LineSegment2): Point2[];
+    /**
+     * Returns `true` if and only if the given `point` is contained within this shape.
+     *
+     * `epsilon` is a small number used to counteract floating point error. Thus, if
+     * `point` is within `epsilon` of the inside of this shape, `containsPoint` may also
+     * return `true`.
+     *
+     * The default implementation relies on `signedDistance`.
+     * Subclasses may override this method to provide a more efficient implementation.
+     */
+    containsPoint(point: Point2, epsilon?: number): boolean;
+    /**
+     * Returns a bounding box that precisely fits the content of this shape.
+     */
+    abstract getTightBoundingBox(): Rect2;
+    /**
+     * Returns a bounding box that **loosely** fits the content of this shape.
+     *
+     * The result of this call can be larger than the result of {@link getTightBoundingBox},
+     * **but should not be smaller**. Thus, a call to `getLooseBoundingBox` can be significantly
+     * faster than a call to {@link getTightBoundingBox} for some shapes.
+     */
+    getLooseBoundingBox(): Rect2;
+}
+export default Abstract2DShape;

package/dist/mjs/shapes/Abstract2DShape.mjs

@@ -0,0 +1,36 @@
+class Abstract2DShape {
+    /**
+     * @returns the distance from `point` to this shape. If `point` is within this shape,
+     * this returns the distance from `point` to the edge of this shape.
+     *
+     * @see {@link signedDistance}
+     */
+    distance(point) {
+        return Math.abs(this.signedDistance(point));
+    }
+    /**
+     * Returns `true` if and only if the given `point` is contained within this shape.
+     *
+     * `epsilon` is a small number used to counteract floating point error. Thus, if
+     * `point` is within `epsilon` of the inside of this shape, `containsPoint` may also
+     * return `true`.
+     *
+     * The default implementation relies on `signedDistance`.
+     * Subclasses may override this method to provide a more efficient implementation.
+     */
+    containsPoint(point, epsilon = Abstract2DShape.smallValue) {
+        return this.signedDistance(point) < epsilon;
+    }
+    /**
+     * Returns a bounding box that **loosely** fits the content of this shape.
+     *
+     * The result of this call can be larger than the result of {@link getTightBoundingBox},
+     * **but should not be smaller**. Thus, a call to `getLooseBoundingBox` can be significantly
+     * faster than a call to {@link getTightBoundingBox} for some shapes.
+     */
+    getLooseBoundingBox() {
+        return this.getTightBoundingBox();
+    }
+}
+Abstract2DShape.smallValue = 1e-12;
+export default Abstract2DShape;

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

@@ -0,0 +1,36 @@
+import { Bezier } from 'bezier-js';
+import { Point2, Vec2 } from '../Vec2';
+import Abstract2DShape from './Abstract2DShape';
+import LineSegment2 from './LineSegment2';
+import Rect2 from './Rect2';
+/**
+ * A lazy-initializing wrapper around Bezier-js.
+ *
+ * Subclasses may override `at`, `derivativeAt`, and `normal` with functions
+ * that do not initialize a `bezier-js` `Bezier`.
+ *
+ * Do not use this class directly. It may be removed/replaced in a future release.
+ * @internal
+ */
+declare abstract class BezierJSWrapper extends Abstract2DShape {
+    #private;
+    /** Returns the start, control points, and end point of this Bézier. */
+    abstract getPoints(): Point2[];
+    protected getBezier(): Bezier;
+    signedDistance(point: Point2): number;
+    /**
+     * @returns the (more) exact distance from `point` to this.
+     *
+     * @see {@link approximateDistance}
+     */
+    distance(point: Point2): number;
+    /**
+     * @returns the curve evaluated at `t`.
+     */
+    at(t: number): Point2;
+    derivativeAt(t: number): Point2;
+    normal(t: number): Vec2;
+    getTightBoundingBox(): Rect2;
+    intersectsLineSegment(line: LineSegment2): Point2[];
+}
+export default BezierJSWrapper;

package/dist/mjs/shapes/BezierJSWrapper.mjs

@@ -0,0 +1,89 @@
+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 _BezierJSWrapper_bezierJs;
+import { Bezier } from 'bezier-js';
+import  { Vec2 }  from '../Vec2.mjs';
+import  Abstract2DShape  from './Abstract2DShape.mjs';
+import  Rect2  from './Rect2.mjs';
+/**
+ * A lazy-initializing wrapper around Bezier-js.
+ *
+ * Subclasses may override `at`, `derivativeAt`, and `normal` with functions
+ * that do not initialize a `bezier-js` `Bezier`.
+ *
+ * Do not use this class directly. It may be removed/replaced in a future release.
+ * @internal
+ */
+class BezierJSWrapper extends Abstract2DShape {
+    constructor() {
+        super(...arguments);
+        _BezierJSWrapper_bezierJs.set(this, null);
+    }
+    getBezier() {
+        if (!__classPrivateFieldGet(this, _BezierJSWrapper_bezierJs, "f")) {
+            __classPrivateFieldSet(this, _BezierJSWrapper_bezierJs, new Bezier(this.getPoints().map(p => p.xy)), "f");
+        }
+        return __classPrivateFieldGet(this, _BezierJSWrapper_bezierJs, "f");
+    }
+    signedDistance(point) {
+        // .d: Distance
+        return this.getBezier().project(point.xy).d;
+    }
+    /**
+     * @returns the (more) exact distance from `point` to this.
+     *
+     * @see {@link approximateDistance}
+     */
+    distance(point) {
+        // A Bézier curve has no interior, thus, signed distance is the same as distance.
+        return this.signedDistance(point);
+    }
+    /**
+     * @returns the curve evaluated at `t`.
+     */
+    at(t) {
+        return Vec2.ofXY(this.getBezier().get(t));
+    }
+    derivativeAt(t) {
+        return Vec2.ofXY(this.getBezier().derivative(t));
+    }
+    normal(t) {
+        return Vec2.ofXY(this.getBezier().normal(t));
+    }
+    getTightBoundingBox() {
+        const bbox = this.getBezier().bbox();
+        const width = bbox.x.max - bbox.x.min;
+        const height = bbox.y.max - bbox.y.min;
+        return new Rect2(bbox.x.min, bbox.y.min, width, height);
+    }
+    intersectsLineSegment(line) {
+        const bezier = this.getBezier();
+        const intersectionPoints = 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),
+            if (typeof t === 'string') {
+                t = parseFloat(t);
+            }
+            const point = Vec2.ofXY(bezier.get(t));
+            // Ensure that the intersection is on the line segment
+            if (point.minus(line.p1).magnitude() > line.length
+                || point.minus(line.p2).magnitude() > line.length) {
+                return null;
+            }
+            return point;
+        }).filter(entry => entry !== null);
+        return intersectionPoints;
+    }
+}
+_BezierJSWrapper_bezierJs = new WeakMap();
+export default BezierJSWrapper;