@js-draw/math 1.11.1 → 1.17.0

package/dist/cjs/Vec3.d.ts

@@ -35,11 +35,31 @@ export declare class Vec3 {
     length(): number;
     magnitude(): number;
     magnitudeSquared(): number;
+    /**
+     * Interpreting this vector as a point in ℝ^3, computes the square distance
+     * to another point, `p`.
+     *
+     * Equivalent to `.minus(p).magnitudeSquared()`.
+     */
+    squareDistanceTo(p: Vec3): number;
+    /**
+     * Interpreting this vector as a point in ℝ³, returns the distance to the point
+     * `p`.
+     *
+     * Equivalent to `.minus(p).magnitude()`.
+     */
+    distanceTo(p: Vec3): number;
     /**
      * Returns the entry of this with the greatest magnitude.
      *
      * In other words, returns $\max \{ |x| : x \in {\bf v} \}$, where ${\bf v}$ is the set of
      * all entries of this vector.
+     *
+     * **Example**:
+     * ```ts,runnable,console
+     * import { Vec3 } from '@js-draw/math';
+     * console.log(Vec3.of(-1, -10, 8).maximumEntryMagnitude()); // -> 10
+     * ```
      */
     maximumEntryMagnitude(): number;
     /**
@@ -50,6 +70,7 @@ export declare class Vec3 {
      * As such, observing that `Math.atan2(-0, -1)` $\approx -\pi$ and `Math.atan2(0, -1)`$\approx \pi$
      * the resultant angle is in the range $[-\pi, pi]$.
      *
+     * **Example**:
      * ```ts,runnable,console
      * import { Vec2 } from '@js-draw/math';
      * console.log(Vec2.of(-1, -0).angle()); // atan2(-0, -1)

package/dist/cjs/Vec3.js

@@ -58,11 +58,38 @@ class Vec3 {
     magnitudeSquared() {
         return this.dot(this);
     }
+    /**
+     * Interpreting this vector as a point in ℝ^3, computes the square distance
+     * to another point, `p`.
+     *
+     * Equivalent to `.minus(p).magnitudeSquared()`.
+     */
+    squareDistanceTo(p) {
+        const dx = this.x - p.x;
+        const dy = this.y - p.y;
+        const dz = this.z - p.z;
+        return dx * dx + dy * dy + dz * dz;
+    }
+    /**
+     * Interpreting this vector as a point in ℝ³, returns the distance to the point
+     * `p`.
+     *
+     * Equivalent to `.minus(p).magnitude()`.
+     */
+    distanceTo(p) {
+        return Math.sqrt(this.squareDistanceTo(p));
+    }
     /**
      * Returns the entry of this with the greatest magnitude.
      *
      * In other words, returns $\max \{ |x| : x \in {\bf v} \}$, where ${\bf v}$ is the set of
      * all entries of this vector.
+     *
+     * **Example**:
+     * ```ts,runnable,console
+     * import { Vec3 } from '@js-draw/math';
+     * console.log(Vec3.of(-1, -10, 8).maximumEntryMagnitude()); // -> 10
+     * ```
      */
     maximumEntryMagnitude() {
         return Math.max(Math.abs(this.x), Math.max(Math.abs(this.y), Math.abs(this.z)));
@@ -75,6 +102,7 @@ class Vec3 {
      * As such, observing that `Math.atan2(-0, -1)` $\approx -\pi$ and `Math.atan2(0, -1)`$\approx \pi$
      * the resultant angle is in the range $[-\pi, pi]$.
      *
+     * **Example**:
      * ```ts,runnable,console
      * import { Vec2 } from '@js-draw/math';
      * console.log(Vec2.of(-1, -0).angle()); // atan2(-0, -1)

package/dist/cjs/lib.d.ts

@@ -17,7 +17,7 @@
  * @packageDocumentation
  */
 export { LineSegment2 } from './shapes/LineSegment2';
-export { Path, PathCommandType, PathCommand, LinePathCommand, MoveToPathCommand, QuadraticBezierPathCommand, CubicBezierPathCommand, } from './shapes/Path';
+export { Path, IntersectionResult as PathIntersectionResult, CurveIndexRecord as PathCurveIndex, PathCommandType, PathCommand, LinePathCommand, MoveToPathCommand, QuadraticBezierPathCommand, CubicBezierPathCommand, } from './shapes/Path';
 export { Rect2 } from './shapes/Rect2';
 export { QuadraticBezier } from './shapes/QuadraticBezier';
 export { Abstract2DShape } from './shapes/Abstract2DShape';
@@ -25,4 +25,4 @@ export { Mat33, Mat33Array } from './Mat33';
 export { Point2, Vec2 } from './Vec2';
 export { Vec3 } from './Vec3';
 export { Color4 } from './Color4';
-export { toRoundedString } from './rounding';
+export * from './rounding/lib';

package/dist/cjs/lib.js

@@ -17,8 +17,22 @@
  *
  * @packageDocumentation
  */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.toRoundedString = exports.Color4 = exports.Vec3 = exports.Vec2 = exports.Mat33 = exports.Abstract2DShape = exports.QuadraticBezier = exports.Rect2 = exports.PathCommandType = exports.Path = exports.LineSegment2 = void 0;
+exports.Color4 = exports.Vec3 = exports.Vec2 = exports.Mat33 = exports.Abstract2DShape = exports.QuadraticBezier = exports.Rect2 = exports.PathCommandType = exports.Path = exports.LineSegment2 = void 0;
 var LineSegment2_1 = require("./shapes/LineSegment2");
 Object.defineProperty(exports, "LineSegment2", { enumerable: true, get: function () { return LineSegment2_1.LineSegment2; } });
 var Path_1 = require("./shapes/Path");
@@ -38,7 +52,6 @@ var Vec3_1 = require("./Vec3");
 Object.defineProperty(exports, "Vec3", { enumerable: true, get: function () { return Vec3_1.Vec3; } });
 var Color4_1 = require("./Color4");
 Object.defineProperty(exports, "Color4", { enumerable: true, get: function () { return Color4_1.Color4; } });
-var rounding_1 = require("./rounding");
-Object.defineProperty(exports, "toRoundedString", { enumerable: true, get: function () { return rounding_1.toRoundedString; } });
+__exportStar(require("./rounding/lib"), exports);
 // 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/cjs/rounding/cleanUpNumber.d.ts

@@ -0,0 +1,3 @@
+/** Cleans up stringified numbers */
+export declare const cleanUpNumber: (text: string) => string;
+export default cleanUpNumber;

package/dist/cjs/rounding/cleanUpNumber.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cleanUpNumber = void 0;
+/** Cleans up stringified numbers */
+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;
+};
+exports.cleanUpNumber = cleanUpNumber;
+exports.default = exports.cleanUpNumber;

package/dist/cjs/rounding/constants.d.ts

@@ -0,0 +1 @@
+export declare const numberRegex: RegExp;

package/dist/cjs/rounding/constants.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.numberRegex = void 0;
+exports.numberRegex = /^([-]?)(\d*)[.](\d+)$/;

package/dist/cjs/rounding/getLenAfterDecimal.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Returns the length of `numberAsString` after a decimal point.
+ *
+ * For example,
+ * ```ts
+ * getLenAfterDecimal('1.001') // -> 3
+ * ```
+ */
+export declare const getLenAfterDecimal: (numberAsString: string) => number;
+export default getLenAfterDecimal;

package/dist/cjs/rounding/getLenAfterDecimal.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLenAfterDecimal = void 0;
+const constants_1 = require("./constants");
+/**
+ * Returns the length of `numberAsString` after a decimal point.
+ *
+ * For example,
+ * ```ts
+ * getLenAfterDecimal('1.001') // -> 3
+ * ```
+ */
+const getLenAfterDecimal = (numberAsString) => {
+    const numberMatch = constants_1.numberRegex.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;
+};
+exports.getLenAfterDecimal = getLenAfterDecimal;
+exports.default = exports.getLenAfterDecimal;

package/dist/cjs/rounding/lib.d.ts

@@ -0,0 +1 @@
+export { toRoundedString } from './toRoundedString';

package/dist/cjs/rounding/lib.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toRoundedString = void 0;
+var toRoundedString_1 = require("./toRoundedString");
+Object.defineProperty(exports, "toRoundedString", { enumerable: true, get: function () { return toRoundedString_1.toRoundedString; } });

package/dist/cjs/{rounding.d.ts → rounding/toRoundedString.d.ts}

@@ -1,4 +1,3 @@
-export declare const cleanUpNumber: (text: string) => string;
 /**
  * Converts `num` to a string, removing trailing digits that were likely caused by
  * precision errors.
@@ -11,5 +10,4 @@ export declare const cleanUpNumber: (text: string) => string;
  * ```
  */
 export declare const toRoundedString: (num: number) => string;
-export declare const getLenAfterDecimal: (numberAsString: string) => number;
-export declare const toStringOfSamePrecision: (num: number, ...references: string[]) => string;
+export default toRoundedString;

package/dist/cjs/rounding/toRoundedString.js

@@ -0,0 +1,54 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toRoundedString = void 0;
+const cleanUpNumber_1 = __importDefault(require("./cleanUpNumber"));
+/**
+ * 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));
+ * ```
+ */
+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 (0, cleanUpNumber_1.default)(text);
+};
+exports.toRoundedString = toRoundedString;
+exports.default = exports.toRoundedString;

package/dist/cjs/rounding/toStringOfSamePrecision.d.ts

@@ -0,0 +1,2 @@
+export declare const toStringOfSamePrecision: (num: number, ...references: string[]) => string;
+export default toStringOfSamePrecision;

package/dist/cjs/rounding/toStringOfSamePrecision.js

@@ -0,0 +1,58 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toStringOfSamePrecision = void 0;
+const cleanUpNumber_1 = __importDefault(require("./cleanUpNumber"));
+const constants_1 = require("./constants");
+const getLenAfterDecimal_1 = __importDefault(require("./getLenAfterDecimal"));
+const toRoundedString_1 = __importDefault(require("./toRoundedString"));
+// [reference] should be a string representation of a base-10 number (no exponential (e.g. 10e10))
+const toStringOfSamePrecision = (num, ...references) => {
+    const text = num.toString(10);
+    const textMatch = constants_1.numberRegex.exec(text);
+    if (!textMatch) {
+        return text;
+    }
+    let decimalPlaces = -1;
+    for (const reference of references) {
+        decimalPlaces = Math.max((0, getLenAfterDecimal_1.default)(reference), decimalPlaces);
+    }
+    if (decimalPlaces === -1) {
+        return (0, toRoundedString_1.default)(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 (0, cleanUpNumber_1.default)(`${negativeSign}${preDecimal}.${postDecimal}`);
+};
+exports.toStringOfSamePrecision = toStringOfSamePrecision;
+exports.default = exports.toStringOfSamePrecision;

package/dist/cjs/rounding/toStringOfSamePrecision.test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -38,6 +38,9 @@ export declare abstract class Abstract2DShape {
     containsPoint(point: Point2, epsilon?: number): boolean;
     /**
      * Returns a bounding box that precisely fits the content of this shape.
+     *
+     * **Note**: This bounding box should aligned with the x/y axes. (Thus, it may be
+     * possible to find a tighter bounding box not axes-aligned).
      */
     abstract getTightBoundingBox(): Rect2;
     /**

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

@@ -1,21 +1,22 @@
 import { Bezier } from 'bezier-js';
 import { Point2, Vec2 } from '../Vec2';
-import Abstract2DShape from './Abstract2DShape';
 import LineSegment2 from './LineSegment2';
 import Rect2 from './Rect2';
+import Parameterized2DShape from './Parameterized2DShape';
 /**
  * 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.
+ * **Do not use this class directly.** It may be removed/replaced in a future release.
  * @internal
  */
-declare abstract class BezierJSWrapper extends Abstract2DShape {
+export declare abstract class BezierJSWrapper extends Parameterized2DShape {
     #private;
+    protected constructor(bezierJsBezier?: Bezier);
     /** Returns the start, control points, and end point of this Bézier. */
-    abstract getPoints(): Point2[];
+    abstract getPoints(): readonly Point2[];
     protected getBezier(): Bezier;
     signedDistance(point: Point2): number;
     /**
@@ -29,8 +30,17 @@ declare abstract class BezierJSWrapper extends Abstract2DShape {
      */
     at(t: number): Point2;
     derivativeAt(t: number): Point2;
+    secondDerivativeAt(t: number): Point2;
     normal(t: number): Vec2;
+    normalAt(t: number): Vec2;
+    tangentAt(t: number): Vec2;
     getTightBoundingBox(): Rect2;
-    intersectsLineSegment(line: LineSegment2): Point2[];
+    argIntersectsLineSegment(line: LineSegment2): number[];
+    splitAt(t: number): [BezierJSWrapper] | [BezierJSWrapper, BezierJSWrapper];
+    nearestPointTo(point: Point2): {
+        parameterValue: number;
+        point: import("../Vec3").Vec3;
+    };
+    toString(): string;
 }
 export default BezierJSWrapper;

package/dist/cjs/shapes/BezierJSWrapper.js

@@ -1,37 +1,41 @@
 "use strict";
-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 __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 __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 var _BezierJSWrapper_bezierJs;
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.BezierJSWrapper = void 0;
 const bezier_js_1 = require("bezier-js");
 const Vec2_1 = require("../Vec2");
-const Abstract2DShape_1 = __importDefault(require("./Abstract2DShape"));
 const Rect2_1 = __importDefault(require("./Rect2"));
+const Parameterized2DShape_1 = __importDefault(require("./Parameterized2DShape"));
 /**
  * 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.
+ * **Do not use this class directly.** It may be removed/replaced in a future release.
  * @internal
  */
-class BezierJSWrapper extends Abstract2DShape_1.default {
-    constructor() {
-        super(...arguments);
+class BezierJSWrapper extends Parameterized2DShape_1.default {
+    constructor(bezierJsBezier) {
+        super();
         _BezierJSWrapper_bezierJs.set(this, null);
+        if (bezierJsBezier) {
+            __classPrivateFieldSet(this, _BezierJSWrapper_bezierJs, bezierJsBezier, "f");
+        }
     }
     getBezier() {
         if (!__classPrivateFieldGet(this, _BezierJSWrapper_bezierJs, "f")) {
@@ -41,7 +45,7 @@ class BezierJSWrapper extends Abstract2DShape_1.default {
     }
     signedDistance(point) {
         // .d: Distance
-        return this.getBezier().project(point.xy).d;
+        return this.nearestPointTo(point).point.distanceTo(point);
     }
     /**
      * @returns the (more) exact distance from `point` to this.
@@ -61,34 +65,147 @@ class BezierJSWrapper extends Abstract2DShape_1.default {
     derivativeAt(t) {
         return Vec2_1.Vec2.ofXY(this.getBezier().derivative(t));
     }
+    secondDerivativeAt(t) {
+        return Vec2_1.Vec2.ofXY(this.getBezier().dderivative(t));
+    }
     normal(t) {
         return Vec2_1.Vec2.ofXY(this.getBezier().normal(t));
     }
+    normalAt(t) {
+        return this.normal(t);
+    }
+    tangentAt(t) {
+        return this.derivativeAt(t).normalized();
+    }
     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_1.default(bbox.x.min, bbox.y.min, width, height);
     }
-    intersectsLineSegment(line) {
+    argIntersectsLineSegment(line) {
         const bezier = this.getBezier();
-        const intersectionPoints = 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),
             if (typeof t === 'string') {
                 t = parseFloat(t);
             }
-            const point = Vec2_1.Vec2.ofXY(bezier.get(t));
+            const point = Vec2_1.Vec2.ofXY(this.at(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) {
+            if (point.distanceTo(line.p1) > line.length
+                || point.distanceTo(line.p2) > line.length) {
                 return null;
             }
-            return point;
+            return t;
         }).filter(entry => entry !== null);
-        return intersectionPoints;
+    }
+    splitAt(t) {
+        if (t <= 0 || t >= 1) {
+            return [this];
+        }
+        const bezier = this.getBezier();
+        const split = bezier.split(t);
+        return [
+            new BezierJSWrapperImpl(split.left.points.map(point => Vec2_1.Vec2.ofXY(point)), split.left),
+            new BezierJSWrapperImpl(split.right.points.map(point => Vec2_1.Vec2.ofXY(point)), split.right),
+        ];
+    }
+    nearestPointTo(point) {
+        // One implementation could be similar to this:
+        //   const projection = this.getBezier().project(point);
+        //   return {
+        //    point: Vec2.ofXY(projection),
+        //    parameterValue: projection.t!,
+        //   };
+        // However, Bezier-js is rather impercise (and relies on a lookup table).
+        // Thus, we instead use Newton's Method:
+        // We want to find t such that f(t) = |B(t) - p|² is minimized.
+        // Expanding,
+        //   f(t)  = (Bₓ(t) - pₓ)² + (Bᵧ(t) - pᵧ)²
+        // ⇒ f'(t) = Dₜ(Bₓ(t) - pₓ)² + Dₜ(Bᵧ(t) - pᵧ)²
+        // ⇒ f'(t) = 2(Bₓ(t) - pₓ)(Bₓ'(t)) + 2(Bᵧ(t) - pᵧ)(Bᵧ'(t))
+        //         = 2Bₓ(t)Bₓ'(t) - 2pₓBₓ'(t) + 2Bᵧ(t)Bᵧ'(t) - 2pᵧBᵧ'(t)
+        // ⇒ f''(t)= 2Bₓ'(t)Bₓ'(t) + 2Bₓ(t)Bₓ''(t) - 2pₓBₓ''(t) + 2Bᵧ'(t)Bᵧ'(t)
+        //         + 2Bᵧ(t)Bᵧ''(t) - 2pᵧBᵧ''(t)
+        // Because f'(t) = 0 at relative extrema, we can use Newton's Method
+        // to improve on an initial guess.
+        const sqrDistAt = (t) => point.squareDistanceTo(this.at(t));
+        const yIntercept = sqrDistAt(0);
+        let t = 0;
+        let minSqrDist = yIntercept;
+        // Start by testing a few points:
+        const pointsToTest = 4;
+        for (let i = 0; i < pointsToTest; i++) {
+            const testT = i / (pointsToTest - 1);
+            const testMinSqrDist = sqrDistAt(testT);
+            if (testMinSqrDist < minSqrDist) {
+                t = testT;
+                minSqrDist = testMinSqrDist;
+            }
+        }
+        // To use Newton's Method, we need to evaluate the second derivative of the distance
+        // function:
+        const secondDerivativeAt = (t) => {
+            // f''(t) = 2Bₓ'(t)Bₓ'(t) + 2Bₓ(t)Bₓ''(t) - 2pₓBₓ''(t)
+            //        + 2Bᵧ'(t)Bᵧ'(t) + 2Bᵧ(t)Bᵧ''(t) - 2pᵧBᵧ''(t)
+            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);
+        };
+        // 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);
+        };
+        const iterate = () => {
+            const slope = secondDerivativeAt(t);
+            // We intersect a line through the point on f'(t) at t with the x-axis:
+            //    y = m(x - x₀) + y₀
+            // ⇒  x - x₀ = (y - y₀) / m
+            // ⇒  x = (y - y₀) / m + x₀
+            //
+            // Thus, when zeroed,
+            //   tN = (0 - f'(t)) / m + t
+            const newT = (0 - derivativeAt(t)) / slope + t;
+            //const distDiff = sqrDistAt(newT) - sqrDistAt(t);
+            //console.assert(distDiff <= 0, `${-distDiff} >= 0`);
+            t = newT;
+            if (t > 1) {
+                t = 1;
+            }
+            else if (t < 0) {
+                t = 0;
+            }
+        };
+        for (let i = 0; i < 12; i++) {
+            iterate();
+        }
+        return { parameterValue: t, point: this.at(t) };
+    }
+    toString() {
+        return `Bézier(${this.getPoints().map(point => point.toString()).join(', ')})`;
     }
 }
+exports.BezierJSWrapper = BezierJSWrapper;
 _BezierJSWrapper_bezierJs = new WeakMap();
+/**
+ * Private concrete implementation of `BezierJSWrapper`, used by methods above that need to return a wrapper
+ * around a `Bezier`.
+ */
+class BezierJSWrapperImpl extends BezierJSWrapper {
+    constructor(controlPoints, curve) {
+        super(curve);
+        this.controlPoints = controlPoints;
+    }
+    getPoints() {
+        return this.controlPoints;
+    }
+}
 exports.default = BezierJSWrapper;