@js-draw/math 1.16.0 → 1.17.0

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

@@ -2,7 +2,7 @@ import LineSegment2 from './LineSegment2';
 import Mat33 from '../Mat33';
 import Rect2 from './Rect2';
 import { Point2 } from '../Vec2';
-import Abstract2DShape from './Abstract2DShape';
+import Parameterized2DShape from './Parameterized2DShape';
 export declare enum PathCommandType {
     LineTo = 0,
     MoveTo = 1,
@@ -29,12 +29,23 @@ export interface MoveToPathCommand {
     point: Point2;
 }
 export type PathCommand = CubicBezierPathCommand | QuadraticBezierPathCommand | MoveToPathCommand | LinePathCommand;
-interface IntersectionResult {
-    curve: Abstract2DShape;
-    /** @internal @deprecated */
+export interface IntersectionResult {
+    curve: Parameterized2DShape;
+    curveIndex: number;
+    /** Parameter value for the closest point **on** the path to the intersection. @internal @deprecated */
     parameterValue?: number;
+    /** Point at which the intersection occured. */
     point: Point2;
 }
+/**
+ * Allows indexing a particular part of a path.
+ *
+ * @see {@link Path.at} {@link Path.tangentAt}
+ */
+export interface CurveIndexRecord {
+    curveIndex: number;
+    parameterValue: number;
+}
 /**
  * Represents a union of lines and curves.
  */
@@ -57,7 +68,7 @@ export declare class Path {
     constructor(startPoint: Point2, parts: Readonly<PathCommand>[]);
     getExactBBox(): Rect2;
     private cachedGeometry;
-    get geometry(): Abstract2DShape[];
+    get geometry(): Parameterized2DShape[];
     /**
      * Iterates through the start/end points of each component in this path.
      *
@@ -86,10 +97,31 @@ export declare class Path {
      * **Note**: `strokeRadius` is half of a stroke's width.
      */
     intersection(line: LineSegment2, strokeRadius?: number): IntersectionResult[];
+    /**
+     * @returns the nearest point on this path to the given `point`.
+     *
+     * @internal
+     * @beta
+     */
+    nearestPointTo(point: Point2): IntersectionResult;
+    at(index: CurveIndexRecord): import("../Vec3").Vec3;
+    tangentAt(index: CurveIndexRecord): import("../Vec3").Vec3;
     private static mapPathCommand;
     mapPoints(mapping: (point: Point2) => Point2): Path;
     transformedBy(affineTransfm: Mat33): Path;
-    union(other: Path | null): Path;
+    union(other: Path | null, options?: {
+        allowReverse?: boolean;
+    }): Path;
+    /**
+     * @returns a version of this path with the direction reversed.
+     *
+     * Example:
+     * ```ts,runnable,console
+     * import {Path} from '@js-draw/math';
+     * console.log(Path.fromString('m0,0l1,1').reversed()); // -> M1,1 L0,0
+     * ```
+     */
+    reversed(): Path;
     private getEndPoint;
     /**
      * Like {@link closedRoughlyIntersects} except takes stroke width into account.
@@ -103,6 +135,8 @@ export declare class Path {
      */
     roughlyIntersects(rect: Rect2, strokeWidth?: number): boolean;
     closedRoughlyIntersects(rect: Rect2): boolean;
+    /** @returns true if all points on this are equivalent to the points on `other` */
+    eq(other: Path, tolerance?: number): boolean;
     /**
      * Returns a path that outlines `rect`.
      *

package/dist/cjs/shapes/Path.js

@@ -236,7 +236,7 @@ class Path {
             for (const { part, distFn, bbox } of uncheckedDistFunctions) {
                 // Skip if impossible for the distance to the target to be lesser than
                 // the current minimum.
-                if (!bbox.grownBy(minDist).containsPoint(point)) {
+                if (isFinite(minDist) && !bbox.grownBy(minDist).containsPoint(point)) {
                     continue;
                 }
                 const currentDist = distFn(point);
@@ -274,7 +274,7 @@ class Path {
         });
         const result = [];
         const stoppingThreshold = strokeRadius / 1000;
-        // Returns the maximum x value explored
+        // Returns the maximum parameter value explored
         const raymarchFrom = (startPoint, 
         // Direction to march in (multiplies line.direction)
         directionMultiplier, 
@@ -318,9 +318,14 @@ class Path {
             if (lastPart && isOnLineSegment && Math.abs(lastDist) < stoppingThreshold) {
                 result.push({
                     point: currentPoint,
-                    parameterValue: NaN,
+                    parameterValue: NaN, // lastPart.nearestPointTo(currentPoint).parameterValue,
                     curve: lastPart,
+                    curveIndex: this.geometry.indexOf(lastPart),
                 });
+                // Slightly increase the parameter value to prevent the same point from being
+                // added to the results twice.
+                const parameterIncrease = strokeRadius / 20 / line.length;
+                lastParameter += isFinite(parameterIncrease) ? parameterIncrease : 0;
             }
             return lastParameter;
         };
@@ -353,14 +358,18 @@ class Path {
         if (!line.bbox.intersects(this.bbox.grownBy(strokeRadius ?? 0))) {
             return [];
         }
+        let index = 0;
         for (const part of this.geometry) {
-            const intersection = part.intersectsLineSegment(line);
-            if (intersection.length > 0) {
+            const intersections = part.argIntersectsLineSegment(line);
+            for (const intersection of intersections) {
                 result.push({
                     curve: part,
-                    point: intersection[0],
+                    curveIndex: index,
+                    point: part.at(intersection),
+                    parameterValue: intersection,
                 });
             }
+            index++;
         }
         // If given a non-zero strokeWidth, attempt to raymarch.
         // Even if raymarching, we need to collect starting points.
@@ -373,6 +382,42 @@ class Path {
         }
         return result;
     }
+    /**
+     * @returns the nearest point on this path to the given `point`.
+     *
+     * @internal
+     * @beta
+     */
+    nearestPointTo(point) {
+        // Find the closest point on this
+        let closestSquareDist = Infinity;
+        let closestPartIndex = 0;
+        let closestParameterValue = 0;
+        let closestPoint = this.startPoint;
+        for (let i = 0; i < this.geometry.length; i++) {
+            const current = this.geometry[i];
+            const nearestPoint = current.nearestPointTo(point);
+            const sqareDist = nearestPoint.point.squareDistanceTo(point);
+            if (i === 0 || sqareDist < closestSquareDist) {
+                closestPartIndex = i;
+                closestSquareDist = sqareDist;
+                closestParameterValue = nearestPoint.parameterValue;
+                closestPoint = nearestPoint.point;
+            }
+        }
+        return {
+            curve: this.geometry[closestPartIndex],
+            curveIndex: closestPartIndex,
+            parameterValue: closestParameterValue,
+            point: closestPoint,
+        };
+    }
+    at(index) {
+        return this.geometry[index.curveIndex].at(index.parameterValue);
+    }
+    tangentAt(index) {
+        return this.geometry[index.curveIndex].tangentAt(index.parameterValue);
+    }
     static mapPathCommand(part, mapping) {
         switch (part.kind) {
             case PathCommandType.MoveTo:
@@ -416,18 +461,85 @@ class Path {
         return this.mapPoints(point => affineTransfm.transformVec2(point));
     }
     // Creates a new path by joining [other] to the end of this path
-    union(other) {
+    union(other, 
+    // allowReverse: true iff reversing other or this is permitted if it means
+    //               no moveTo command is necessary when unioning the paths.
+    options = { allowReverse: true }) {
         if (!other) {
             return this;
         }
-        return new Path(this.startPoint, [
-            ...this.parts,
-            {
-                kind: PathCommandType.MoveTo,
-                point: other.startPoint,
-            },
-            ...other.parts,
-        ]);
+        const thisEnd = this.getEndPoint();
+        let newParts = [];
+        if (thisEnd.eq(other.startPoint)) {
+            newParts = this.parts.concat(other.parts);
+        }
+        else if (options.allowReverse && this.startPoint.eq(other.getEndPoint())) {
+            return other.union(this, { allowReverse: false });
+        }
+        else if (options.allowReverse && this.startPoint.eq(other.startPoint)) {
+            return this.union(other.reversed(), { allowReverse: false });
+        }
+        else {
+            newParts = [
+                ...this.parts,
+                {
+                    kind: PathCommandType.MoveTo,
+                    point: other.startPoint,
+                },
+                ...other.parts,
+            ];
+        }
+        return new Path(this.startPoint, newParts);
+    }
+    /**
+     * @returns a version of this path with the direction reversed.
+     *
+     * Example:
+     * ```ts,runnable,console
+     * import {Path} from '@js-draw/math';
+     * console.log(Path.fromString('m0,0l1,1').reversed()); // -> M1,1 L0,0
+     * ```
+     */
+    reversed() {
+        const newStart = this.getEndPoint();
+        const newParts = [];
+        let lastPoint = this.startPoint;
+        for (const part of this.parts) {
+            switch (part.kind) {
+                case PathCommandType.LineTo:
+                case PathCommandType.MoveTo:
+                    newParts.push({
+                        kind: part.kind,
+                        point: lastPoint,
+                    });
+                    lastPoint = part.point;
+                    break;
+                case PathCommandType.CubicBezierTo:
+                    newParts.push({
+                        kind: part.kind,
+                        controlPoint1: part.controlPoint2,
+                        controlPoint2: part.controlPoint1,
+                        endPoint: lastPoint,
+                    });
+                    lastPoint = part.endPoint;
+                    break;
+                case PathCommandType.QuadraticBezierTo:
+                    newParts.push({
+                        kind: part.kind,
+                        controlPoint: part.controlPoint,
+                        endPoint: lastPoint,
+                    });
+                    lastPoint = part.endPoint;
+                    break;
+                default:
+                    {
+                        const exhaustivenessCheck = part;
+                        return exhaustivenessCheck;
+                    }
+            }
+        }
+        newParts.reverse();
+        return new Path(newStart, newParts);
     }
     getEndPoint() {
         if (this.parts.length === 0) {
@@ -519,6 +631,52 @@ class Path {
         // Even? Probably no intersection.
         return false;
     }
+    /** @returns true if all points on this are equivalent to the points on `other` */
+    eq(other, tolerance) {
+        if (other.parts.length !== this.parts.length) {
+            return false;
+        }
+        for (let i = 0; i < this.parts.length; i++) {
+            const part1 = this.parts[i];
+            const part2 = other.parts[i];
+            switch (part1.kind) {
+                case PathCommandType.LineTo:
+                case PathCommandType.MoveTo:
+                    if (part1.kind !== part2.kind) {
+                        return false;
+                    }
+                    else if (!part1.point.eq(part2.point, tolerance)) {
+                        return false;
+                    }
+                    break;
+                case PathCommandType.CubicBezierTo:
+                    if (part1.kind !== part2.kind) {
+                        return false;
+                    }
+                    else if (!part1.controlPoint1.eq(part2.controlPoint1, tolerance)
+                        || !part1.controlPoint2.eq(part2.controlPoint2, tolerance)
+                        || !part1.endPoint.eq(part2.endPoint, tolerance)) {
+                        return false;
+                    }
+                    break;
+                case PathCommandType.QuadraticBezierTo:
+                    if (part1.kind !== part2.kind) {
+                        return false;
+                    }
+                    else if (!part1.controlPoint.eq(part2.controlPoint, tolerance)
+                        || !part1.endPoint.eq(part2.endPoint, tolerance)) {
+                        return false;
+                    }
+                    break;
+                default:
+                    {
+                        const exhaustivenessCheck = part1;
+                        return exhaustivenessCheck;
+                    }
+            }
+        }
+        return true;
+    }
     /**
      * Returns a path that outlines `rect`.
      *

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

@@ -1,18 +1,29 @@
 import { Point2 } from '../Vec2';
 import Vec3 from '../Vec3';
-import Abstract2DShape from './Abstract2DShape';
 import LineSegment2 from './LineSegment2';
+import Parameterized2DShape from './Parameterized2DShape';
 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 {
+declare class PointShape2D extends Parameterized2DShape {
     readonly p: Point2;
     constructor(p: Point2);
     signedDistance(point: Vec3): number;
-    intersectsLineSegment(lineSegment: LineSegment2, epsilon?: number): Vec3[];
+    argIntersectsLineSegment(lineSegment: LineSegment2, epsilon?: number): number[];
     getTightBoundingBox(): Rect2;
+    at(_t: number): Vec3;
+    /**
+     * Returns an arbitrary unit-length vector.
+     */
+    normalAt(_t: number): Vec3;
+    tangentAt(_t: number): Vec3;
+    splitAt(_t: number): [PointShape2D];
+    nearestPointTo(_point: Point2): {
+        point: Vec3;
+        parameterValue: number;
+    };
 }
 export default PointShape2D;

package/dist/cjs/shapes/PointShape2D.js

@@ -3,29 +3,52 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const Abstract2DShape_1 = __importDefault(require("./Abstract2DShape"));
+const Vec2_1 = require("../Vec2");
+const Parameterized2DShape_1 = __importDefault(require("./Parameterized2DShape"));
 const Rect2_1 = __importDefault(require("./Rect2"));
 /**
  * Like a {@link Point2}, but with additional functionality (e.g. SDF).
  *
  * Access the internal `Point2` using the `p` property.
  */
-class PointShape2D extends Abstract2DShape_1.default {
+class PointShape2D extends Parameterized2DShape_1.default {
     constructor(p) {
         super();
         this.p = p;
     }
     signedDistance(point) {
-        return this.p.minus(point).magnitude();
+        return this.p.distanceTo(point);
     }
-    intersectsLineSegment(lineSegment, epsilon) {
+    argIntersectsLineSegment(lineSegment, epsilon) {
         if (lineSegment.containsPoint(this.p, epsilon)) {
-            return [this.p];
+            return [0];
         }
         return [];
     }
     getTightBoundingBox() {
         return new Rect2_1.default(this.p.x, this.p.y, 0, 0);
     }
+    at(_t) {
+        return this.p;
+    }
+    /**
+     * Returns an arbitrary unit-length vector.
+     */
+    normalAt(_t) {
+        // Return a vector that makes sense.
+        return Vec2_1.Vec2.unitY;
+    }
+    tangentAt(_t) {
+        return Vec2_1.Vec2.unitX;
+    }
+    splitAt(_t) {
+        return [this];
+    }
+    nearestPointTo(_point) {
+        return {
+            point: this.p,
+            parameterValue: 0,
+        };
+    }
 }
 exports.default = PointShape2D;

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

@@ -18,11 +18,15 @@ export declare class QuadraticBezier extends BezierJSWrapper {
      */
     private static componentAt;
     private static derivativeComponentAt;
+    private static secondDerivativeComponentAt;
     /**
      * @returns the curve evaluated at `t`.
+     *
+     * `t` should be a number in `[0, 1]`.
      */
     at(t: number): Point2;
     derivativeAt(t: number): Point2;
+    secondDerivativeAt(t: number): Point2;
     normal(t: number): Vec2;
     /** @returns an overestimate of this shape's bounding box. */
     getLooseBoundingBox(): Rect2;

package/dist/cjs/shapes/QuadraticBezier.js

@@ -31,10 +31,19 @@ class QuadraticBezier extends BezierJSWrapper_1.default {
     static derivativeComponentAt(t, p0, p1, p2) {
         return -2 * p0 + 2 * p1 + 2 * t * (p0 - 2 * p1 + p2);
     }
+    static secondDerivativeComponentAt(t, p0, p1, p2) {
+        return 2 * (p0 - 2 * p1 + p2);
+    }
     /**
      * @returns the curve evaluated at `t`.
+     *
+     * `t` should be a number in `[0, 1]`.
      */
     at(t) {
+        if (t === 0)
+            return this.p0;
+        if (t === 1)
+            return this.p2;
         const p0 = this.p0;
         const p1 = this.p1;
         const p2 = this.p2;
@@ -46,6 +55,12 @@ class QuadraticBezier extends BezierJSWrapper_1.default {
         const p2 = this.p2;
         return Vec2_1.Vec2.of(QuadraticBezier.derivativeComponentAt(t, p0.x, p1.x, p2.x), QuadraticBezier.derivativeComponentAt(t, p0.y, p1.y, p2.y));
     }
+    secondDerivativeAt(t) {
+        const p0 = this.p0;
+        const p1 = this.p1;
+        const p2 = this.p2;
+        return Vec2_1.Vec2.of(QuadraticBezier.secondDerivativeComponentAt(t, p0.x, p1.x, p2.x), QuadraticBezier.secondDerivativeComponentAt(t, p0.y, p1.y, p2.y));
+    }
     normal(t) {
         const tangent = this.derivativeAt(t);
         return tangent.orthog().normalized();
@@ -106,10 +121,10 @@ class QuadraticBezier extends BezierJSWrapper_1.default {
         }
         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();
+        const sqrDist1 = at1.squareDistanceTo(point);
+        const sqrDist2 = at2.squareDistanceTo(point);
+        const sqrDist3 = this.at(0).squareDistanceTo(point);
+        const sqrDist4 = this.at(1).squareDistanceTo(point);
         return Math.sqrt(Math.min(sqrDist1, sqrDist2, sqrDist3, sqrDist4));
     }
     getPoints() {

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

@@ -25,6 +25,9 @@ export declare class Rect2 extends Abstract2DShape {
     resizedTo(size: Vec2): Rect2;
     containsPoint(other: Point2): boolean;
     containsRect(other: Rect2): boolean;
+    /**
+     * @returns true iff this and `other` overlap
+     */
     intersects(other: Rect2): boolean;
     intersection(other: Rect2): Rect2 | null;
     union(other: Rect2): Rect2;

package/dist/cjs/shapes/Rect2.js

@@ -44,6 +44,9 @@ class Rect2 extends Abstract2DShape_1.default {
             && this.x + this.w >= other.x + other.w
             && this.y + this.h >= other.y + other.h;
     }
+    /**
+     * @returns true iff this and `other` overlap
+     */
     intersects(other) {
         // Project along x/y axes.
         const thisMinX = this.x;
@@ -130,7 +133,7 @@ class Rect2 extends Abstract2DShape_1.default {
         let closest = null;
         let closestDist = null;
         for (const point of closestEdgePoints) {
-            const dist = point.minus(target).length();
+            const dist = point.distanceTo(target);
             if (closestDist === null || dist < closestDist) {
                 closest = point;
                 closestDist = dist;

package/dist/mjs/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/mjs/Vec3.mjs

@@ -55,11 +55,38 @@ export 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)));
@@ -72,6 +99,7 @@ export 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/mjs/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';

package/dist/mjs/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/mjs/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;