@js-draw/math 1.16.0 → 1.18.0

package/dist/mjs/shapes/BezierJSWrapper.mjs

@@ -1,32 +1,36 @@
-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 _BezierJSWrapper_bezierJs;
 import { Bezier } from 'bezier-js';
 import  { Vec2 }  from '../Vec2.mjs';
-import  Abstract2DShape  from './Abstract2DShape.mjs';
+import  LineSegment2  from './LineSegment2.mjs';
 import  Rect2  from './Rect2.mjs';
+import  Parameterized2DShape  from './Parameterized2DShape.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.
+ * **Do not use this class directly.** It may be removed/replaced in a future release.
  * @internal
  */
-class BezierJSWrapper extends Abstract2DShape {
-    constructor() {
-        super(...arguments);
+export class BezierJSWrapper extends Parameterized2DShape {
+    constructor(bezierJsBezier) {
+        super();
         _BezierJSWrapper_bezierJs.set(this, null);
+        if (bezierJsBezier) {
+            __classPrivateFieldSet(this, _BezierJSWrapper_bezierJs, bezierJsBezier, "f");
+        }
     }
     getBezier() {
         if (!__classPrivateFieldGet(this, _BezierJSWrapper_bezierJs, "f")) {
@@ -36,7 +40,7 @@ class BezierJSWrapper extends Abstract2DShape {
     }
     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.
@@ -56,34 +60,180 @@ class BezierJSWrapper extends Abstract2DShape {
     derivativeAt(t) {
         return Vec2.ofXY(this.getBezier().derivative(t));
     }
+    secondDerivativeAt(t) {
+        return Vec2.ofXY(this.getBezier().dderivative(t));
+    }
     normal(t) {
         return 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(bbox.x.min, bbox.y.min, width, height);
     }
-    intersectsLineSegment(line) {
+    argIntersectsLineSegment(line) {
+        // Bezier-js has a bug when all control points of a Bezier curve lie on
+        // a line. Our solution involves converting the Bezier into a line, then
+        // finding the parameter value that produced the intersection.
+        //
+        // TODO: This is unnecessarily slow. A better solution would be to fix
+        // the bug upstream.
+        const asLine = LineSegment2.ofSmallestContainingPoints(this.getPoints());
+        if (asLine) {
+            const intersection = asLine.intersectsLineSegment(line);
+            return intersection.map(p => this.nearestPointTo(p).parameterValue);
+        }
         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.ofXY(bezier.get(t));
+            const point = 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.ofXY(point)), split.left),
+            new BezierJSWrapperImpl(split.right.points.map(point => 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);
+            if (slope === 0)
+                return;
+            // 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) };
+    }
+    intersectsBezier(other) {
+        const intersections = this.getBezier().intersects(other.getBezier());
+        if (!intersections || intersections.length === 0) {
+            return [];
+        }
+        const result = [];
+        for (const intersection of intersections) {
+            // From http://pomax.github.io/bezierjs/#intersect-curve,
+            // .intersects returns an array of 't1/t2' pairs, where curve1.at(t1) gives the point.
+            const match = /^([-0-9.eE]+)\/([-0-9.eE]+)$/.exec(intersection);
+            if (!match) {
+                throw new Error(`Incorrect format returned by .intersects: ${intersections} should be array of "number/number"!`);
+            }
+            const t = parseFloat(match[1]);
+            result.push({
+                parameterValue: t,
+                point: this.at(t),
+            });
+        }
+        return result;
+    }
+    toString() {
+        return `Bézier(${this.getPoints().map(point => point.toString()).join(', ')})`;
     }
 }
 _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;
+    }
+}
 export default BezierJSWrapper;

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

@@ -1,13 +1,14 @@
 import Mat33 from '../Mat33';
 import Rect2 from './Rect2';
 import { Vec2, Point2 } from '../Vec2';
-import Abstract2DShape from './Abstract2DShape';
+import Parameterized2DShape from './Parameterized2DShape';
+import Vec3 from '../Vec3';
 interface IntersectionResult {
     point: Point2;
     t: number;
 }
 /** Represents a line segment. A `LineSegment2` is immutable. */
-export declare class LineSegment2 extends Abstract2DShape {
+export declare class LineSegment2 extends Parameterized2DShape {
     private readonly point1;
     private readonly point2;
     /**
@@ -24,12 +25,24 @@ export declare class LineSegment2 extends Abstract2DShape {
     readonly bbox: Rect2;
     /** Creates a new `LineSegment2` from its endpoints. */
     constructor(point1: Point2, point2: Point2);
+    /**
+     * Returns the smallest line segment that contains all points in `points`, or `null`
+     * if no such line segment exists.
+     *
+     * @example
+     * ```ts,runnable
+     * import {LineSegment2, Vec2} from '@js-draw/math';
+     * console.log(LineSegment2.ofSmallestContainingPoints([Vec2.of(1, 0), Vec2.of(0, 1)]));
+     * ```
+     */
+    static ofSmallestContainingPoints(points: readonly Point2[]): LineSegment2 | null;
     /** Alias for `point1`. */
     get p1(): Point2;
     /** Alias for `point2`. */
     get p2(): Point2;
+    get center(): Point2;
     /**
-     * Gets a point a distance `t` along this line.
+     * Gets a point a **distance** `t` along this line.
      *
      * @deprecated
      */
@@ -42,8 +55,20 @@ export declare class LineSegment2 extends Abstract2DShape {
      * `t` should be in `[0, 1]`.
      */
     at(t: number): Point2;
+    normalAt(_t: number): Vec2;
+    tangentAt(_t: number): Vec3;
+    splitAt(t: number): [LineSegment2] | [LineSegment2, LineSegment2];
+    /**
+     * Returns the intersection of this with another line segment.
+     *
+     * **WARNING**: The parameter value returned by this method does not range from 0 to 1 and
+     *              is currently a length.
+     *              This will change in a future release.
+     * @deprecated
+     */
     intersection(other: LineSegment2): IntersectionResult | null;
     intersects(other: LineSegment2): boolean;
+    argIntersectsLineSegment(lineSegment: LineSegment2): number[];
     /**
      * Returns the points at which this line segment intersects the
      * given line segment.
@@ -52,8 +77,12 @@ export declare class LineSegment2 extends Abstract2DShape {
      * line segment. This method, by contrast, returns **the point** at which the intersection
      * occurs, if such a point exists.
      */
-    intersectsLineSegment(lineSegment: LineSegment2): import("../Vec3").Vec3[];
-    closestPointTo(target: Point2): import("../Vec3").Vec3;
+    intersectsLineSegment(lineSegment: LineSegment2): Vec3[];
+    closestPointTo(target: Point2): Vec3;
+    nearestPointTo(target: Vec3): {
+        point: Vec3;
+        parameterValue: number;
+    };
     /**
      * Returns the distance from this line segment to `target`.
      *
@@ -66,5 +95,16 @@ export declare class LineSegment2 extends Abstract2DShape {
     /** @inheritdoc */
     getTightBoundingBox(): Rect2;
     toString(): string;
+    /**
+     * Returns `true` iff this is equivalent to `other`.
+     *
+     * **Options**:
+     * - `tolerance`: The maximum difference between endpoints. (Default: 0)
+     * - `ignoreDirection`: Allow matching a version of `this` with opposite direction. (Default: `true`)
+     */
+    eq(other: LineSegment2, options?: {
+        tolerance?: number;
+        ignoreDirection?: boolean;
+    }): boolean;
 }
 export default LineSegment2;

package/dist/mjs/shapes/LineSegment2.mjs

@@ -1,8 +1,8 @@
 import  Rect2  from './Rect2.mjs';
 import  { Vec2 }  from '../Vec2.mjs';
-import  Abstract2DShape  from './Abstract2DShape.mjs';
+import  Parameterized2DShape  from './Parameterized2DShape.mjs';
 /** Represents a line segment. A `LineSegment2` is immutable. */
-export class LineSegment2 extends Abstract2DShape {
+export class LineSegment2 extends Parameterized2DShape {
     /** Creates a new `LineSegment2` from its endpoints. */
     constructor(point1, point2) {
         super();
@@ -16,6 +16,28 @@ export class LineSegment2 extends Abstract2DShape {
             this.direction = this.direction.times(1 / this.length);
         }
     }
+    /**
+     * Returns the smallest line segment that contains all points in `points`, or `null`
+     * if no such line segment exists.
+     *
+     * @example
+     * ```ts,runnable
+     * import {LineSegment2, Vec2} from '@js-draw/math';
+     * console.log(LineSegment2.ofSmallestContainingPoints([Vec2.of(1, 0), Vec2.of(0, 1)]));
+     * ```
+     */
+    static ofSmallestContainingPoints(points) {
+        if (points.length <= 1)
+            return null;
+        const sorted = [...points].sort((a, b) => a.x !== b.x ? a.x - b.x : a.y - b.y);
+        const line = new LineSegment2(sorted[0], sorted[sorted.length - 1]);
+        for (const point of sorted) {
+            if (!line.containsPoint(point)) {
+                return null;
+            }
+        }
+        return line;
+    }
     // Accessors to make LineSegment2 compatible with bezier-js's
     // interface
     /** Alias for `point1`. */
@@ -26,8 +48,11 @@ export class LineSegment2 extends Abstract2DShape {
     get p2() {
         return this.point2;
     }
+    get center() {
+        return this.point1.lerp(this.point2, 0.5);
+    }
     /**
-     * Gets a point a distance `t` along this line.
+     * Gets a point a **distance** `t` along this line.
      *
      * @deprecated
      */
@@ -44,7 +69,31 @@ export class LineSegment2 extends Abstract2DShape {
     at(t) {
         return this.get(t * this.length);
     }
+    normalAt(_t) {
+        return this.direction.orthog();
+    }
+    tangentAt(_t) {
+        return this.direction;
+    }
+    splitAt(t) {
+        if (t <= 0 || t >= 1) {
+            return [this];
+        }
+        return [
+            new LineSegment2(this.point1, this.at(t)),
+            new LineSegment2(this.at(t), this.point2),
+        ];
+    }
+    /**
+     * Returns the intersection of this with another line segment.
+     *
+     * **WARNING**: The parameter value returned by this method does not range from 0 to 1 and
+     *              is currently a length.
+     *              This will change in a future release.
+     * @deprecated
+     */
     intersection(other) {
+        // TODO(v2.0.0): Make this return a `t` value from `0` to `1`.
         // We want x₁(t) = x₂(t) and y₁(t) = y₂(t)
         // Observe that
         // x = this.point1.x + this.direction.x · t₁
@@ -71,7 +120,10 @@ export class LineSegment2 extends Abstract2DShape {
         //     = ((o₁ᵧ - o₂ᵧ)((d₁ₓd₂ₓ)) + (d₂ᵧd₁ₓ)(o₂ₓ) - (d₁ᵧd₂ₓ)(o₁ₓ))/(d₂ᵧd₁ₓ - d₁ᵧd₂ₓ)
         // ⇒ y = o₁ᵧ + d₁ᵧ · (x - o₁ₓ) / d₁ₓ = ...
         let resultPoint, resultT;
-        if (this.direction.x === 0) {
+        // Consider very-near-vertical lines to be vertical --- not doing so can lead to
+        // precision error when dividing by this.direction.x.
+        const small = 4e-13;
+        if (Math.abs(this.direction.x) < small) {
             // Vertical line: Where does the other have x = this.point1.x?
             // x = o₁ₓ = o₂ₓ + d₂ₓ · (y - o₂ᵧ) / d₂ᵧ
             // ⇒ (o₁ₓ - o₂ₓ)(d₂ᵧ/d₂ₓ) + o₂ᵧ = y
@@ -103,10 +155,10 @@ export class LineSegment2 extends Abstract2DShape {
             resultT = (xIntersect - this.point1.x) / this.direction.x;
         }
         // Ensure the result is in this/the other segment.
-        const resultToP1 = resultPoint.minus(this.point1).magnitude();
-        const resultToP2 = resultPoint.minus(this.point2).magnitude();
-        const resultToP3 = resultPoint.minus(other.point1).magnitude();
-        const resultToP4 = resultPoint.minus(other.point2).magnitude();
+        const resultToP1 = resultPoint.distanceTo(this.point1);
+        const resultToP2 = resultPoint.distanceTo(this.point2);
+        const resultToP3 = resultPoint.distanceTo(other.point1);
+        const resultToP4 = resultPoint.distanceTo(other.point2);
         if (resultToP1 > this.length
             || resultToP2 > this.length
             || resultToP3 > other.length
@@ -121,6 +173,13 @@ export class LineSegment2 extends Abstract2DShape {
     intersects(other) {
         return this.intersection(other) !== null;
     }
+    argIntersectsLineSegment(lineSegment) {
+        const intersection = this.intersection(lineSegment);
+        if (intersection) {
+            return [intersection.t / this.length];
+        }
+        return [];
+    }
     /**
      * Returns the points at which this line segment intersects the
      * given line segment.
@@ -138,18 +197,21 @@ export class LineSegment2 extends Abstract2DShape {
     }
     // Returns the closest point on this to [target]
     closestPointTo(target) {
+        return this.nearestPointTo(target).point;
+    }
+    nearestPointTo(target) {
         // Distance from P1 along this' direction.
         const projectedDistFromP1 = target.minus(this.p1).dot(this.direction);
         const projectedDistFromP2 = this.length - projectedDistFromP1;
         const projection = this.p1.plus(this.direction.times(projectedDistFromP1));
         if (projectedDistFromP1 > 0 && projectedDistFromP1 < this.length) {
-            return projection;
+            return { point: projection, parameterValue: projectedDistFromP1 / this.length };
         }
         if (Math.abs(projectedDistFromP2) < Math.abs(projectedDistFromP1)) {
-            return this.p2;
+            return { point: this.p2, parameterValue: 1 };
         }
         else {
-            return this.p1;
+            return { point: this.p1, parameterValue: 0 };
         }
     }
     /**
@@ -172,5 +234,21 @@ export class LineSegment2 extends Abstract2DShape {
     toString() {
         return `LineSegment(${this.p1.toString()}, ${this.p2.toString()})`;
     }
+    /**
+     * Returns `true` iff this is equivalent to `other`.
+     *
+     * **Options**:
+     * - `tolerance`: The maximum difference between endpoints. (Default: 0)
+     * - `ignoreDirection`: Allow matching a version of `this` with opposite direction. (Default: `true`)
+     */
+    eq(other, options) {
+        if (!(other instanceof LineSegment2)) {
+            return false;
+        }
+        const tolerance = options?.tolerance;
+        const ignoreDirection = options?.ignoreDirection ?? true;
+        return ((other.p1.eq(this.p1, tolerance) && other.p2.eq(this.p2, tolerance))
+            || (ignoreDirection && other.p1.eq(this.p2, tolerance) && other.p2.eq(this.p1, tolerance)));
+    }
 }
 export default LineSegment2;

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

@@ -0,0 +1,36 @@
+import { Point2, Vec2 } from '../Vec2';
+import Abstract2DShape from './Abstract2DShape';
+import LineSegment2 from './LineSegment2';
+/**
+ * A 2-dimensional path with parameter interval $t \in [0, 1]$.
+ *
+ * **Note:** Avoid extending this class outside of `js-draw` --- new abstract methods
+ * may be added between minor versions.
+ */
+export declare abstract class Parameterized2DShape extends Abstract2DShape {
+    /** Returns this at a given parameter. $t \in [0, 1]$ */
+    abstract at(t: number): Point2;
+    /** Computes the unit normal vector at $t$. */
+    abstract normalAt(t: number): Vec2;
+    abstract tangentAt(t: number): Vec2;
+    /**
+     * Divides this shape into two separate shapes at parameter value $t$.
+     */
+    abstract splitAt(t: number): [Parameterized2DShape] | [Parameterized2DShape, Parameterized2DShape];
+    /**
+     * Returns the nearest point on `this` to `point` and the `parameterValue` at which
+     * that point occurs.
+     */
+    abstract nearestPointTo(point: Point2): {
+        point: Point2;
+        parameterValue: number;
+    };
+    /**
+     * Returns the **parameter values** at which `lineSegment` intersects this shape.
+     *
+     * See also {@link intersectsLineSegment}
+     */
+    abstract argIntersectsLineSegment(lineSegment: LineSegment2): number[];
+    intersectsLineSegment(line: LineSegment2): Point2[];
+}
+export default Parameterized2DShape;

package/dist/mjs/shapes/Parameterized2DShape.mjs

@@ -0,0 +1,13 @@
+import  Abstract2DShape  from './Abstract2DShape.mjs';
+/**
+ * A 2-dimensional path with parameter interval $t \in [0, 1]$.
+ *
+ * **Note:** Avoid extending this class outside of `js-draw` --- new abstract methods
+ * may be added between minor versions.
+ */
+export class Parameterized2DShape extends Abstract2DShape {
+    intersectsLineSegment(line) {
+        return this.argIntersectsLineSegment(line).map(t => this.at(t));
+    }
+}
+export default Parameterized2DShape;