@js-draw/math 1.16.0 → 1.18.0

package/src/shapes/BezierJSWrapper.ts

@@ -1,8 +1,8 @@
 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.
@@ -10,14 +10,24 @@ import Rect2 from './Rect2';
  * 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
  */
-abstract class BezierJSWrapper extends Abstract2DShape {
+export abstract class BezierJSWrapper extends Parameterized2DShape {
 	#bezierJs: Bezier|null = null;
 
+	protected constructor(
+		bezierJsBezier?: Bezier
+	) {
+		super();
+
+		if (bezierJsBezier) {
+			this.#bezierJs = bezierJsBezier;
+		}
+	}
+
 	/** Returns the start, control points, and end point of this Bézier. */
-	public abstract getPoints(): Point2[];
+	public abstract getPoints(): readonly Point2[];
 
 	protected getBezier() {
 		if (!this.#bezierJs) {
@@ -28,7 +38,7 @@ abstract class BezierJSWrapper extends Abstract2DShape {
 
 	public override signedDistance(point: Point2): number {
 		// .d: Distance
-		return this.getBezier().project(point.xy).d!;
+		return this.nearestPointTo(point).point.distanceTo(point);
 	}
 
 	/**
@@ -44,7 +54,7 @@ abstract class BezierJSWrapper extends Abstract2DShape {
 	/**
 	 * @returns the curve evaluated at `t`.
 	 */
-	public at(t: number): Point2 {
+	public override at(t: number): Point2 {
 		return Vec2.ofXY(this.getBezier().get(t));
 	}
 
@@ -52,10 +62,22 @@ abstract class BezierJSWrapper extends Abstract2DShape {
 		return Vec2.ofXY(this.getBezier().derivative(t));
 	}
 
+	public secondDerivativeAt(t: number): Point2 {
+		return Vec2.ofXY((this.getBezier() as any).dderivative(t));
+	}
+
 	public normal(t: number): Vec2 {
 		return Vec2.ofXY(this.getBezier().normal(t));
 	}
 
+	public override normalAt(t: number): Vec2 {
+		return this.normal(t);
+	}
+
+	public override tangentAt(t: number): Vec2 {
+		return this.derivativeAt(t).normalized();
+	}
+
 	public override getTightBoundingBox(): Rect2 {
 		const bbox = this.getBezier().bbox();
 		const width = bbox.x.max - bbox.x.min;
@@ -64,10 +86,22 @@ abstract class BezierJSWrapper extends Abstract2DShape {
 		return new Rect2(bbox.x.min, bbox.y.min, width, height);
 	}
 
-	public override intersectsLineSegment(line: LineSegment2): Point2[] {
+	public override argIntersectsLineSegment(line: LineSegment2): number[] {
+		// 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),
@@ -75,18 +109,165 @@ abstract class BezierJSWrapper extends Abstract2DShape {
 				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;
-		}).filter(entry => entry !== null) as Point2[];
+			return t;
+		}).filter(entry => entry !== null) as number[];
+	}
+
+	public override splitAt(t: number): [BezierJSWrapper] | [BezierJSWrapper, BezierJSWrapper] {
+		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),
+		];
+	}
+
+	public override nearestPointTo(point: Point2) {
+		// 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: number) => 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: number) => {
+			// 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: number) => {
+			// 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) };
+	}
+
+	public intersectsBezier(other: BezierJSWrapper) {
+		const intersections = this.getBezier().intersects(other.getBezier()) as (string[] | null | undefined);
+		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;
+	}
+
+	public override toString() {
+		return `Bézier(${this.getPoints().map(point => point.toString()).join(', ')})`;
+	}
+}
+
+/**
+ * Private concrete implementation of `BezierJSWrapper`, used by methods above that need to return a wrapper
+ * around a `Bezier`.
+ */
+class BezierJSWrapperImpl extends BezierJSWrapper {
+	public constructor(private controlPoints: readonly Point2[], curve?: Bezier) {
+		super(curve);
+	}
 
-		return intersectionPoints;
+	public override getPoints() {
+		return this.controlPoints;
 	}
 }
 

package/src/shapes/LineSegment2.test.ts

@@ -28,7 +28,7 @@ describe('Line2', () => {
 
 		expect(line1.intersection(line2)?.point).objEq(Vec2.of(0, 10));
 
-		// t=10 implies 10 units along he line from (10, 10) to (-10, 10)
+		// t=10 implies 10 units along the line from (10, 10) to (-10, 10)
 		expect(line1.intersection(line2)?.t).toBe(10);
 
 		// Similarly, t = 12 implies 12 units above (0, -2) in the direction of (0, 200)
@@ -74,6 +74,14 @@ describe('Line2', () => {
 		expect(line2.intersection(line1)).toBeNull();
 	});
 
+	it('(9.559000000000001, 11.687)->(9.559, 11.67673) should intersect (9.56069, 11.68077)->(9.55719, 11.68077)', () => {
+		// Points taken from an issue observed in the editor.
+		const l1 = new LineSegment2(Vec2.of(9.559000000000001, 11.687), Vec2.of(9.559, 11.67673));
+		const l2 = new LineSegment2(Vec2.of(9.56069, 11.68077), Vec2.of(9.55719, 11.68077));
+		expect(l2.intersects(l1)).toBe(true);
+		expect(l1.intersects(l2)).toBe(true);
+	});
+
 	it('Closest point to (0,0) on the line x = 1 should be (1,0)', () => {
 		const line = new LineSegment2(Vec2.of(1, 100), Vec2.of(1, -100));
 		expect(line.closestPointTo(Vec2.zero)).objEq(Vec2.of(1, 0));
@@ -96,4 +104,56 @@ describe('Line2', () => {
 			p2: Vec2.of(3, 98),
 		});
 	});
+
+	it.each([
+		{ from: Vec2.of(0, 0), to: Vec2.of(2, 2) },
+		{ from: Vec2.of(100, 0), to: Vec2.of(2, 2) },
+	])('should be able to split a line segment between %j', ({ from, to }) => {
+		const midpoint = from.lerp(to, 0.5);
+		const lineSegment = new LineSegment2(from, to);
+
+		// Halving
+		//
+		expect(lineSegment.at(0.5)).objEq(midpoint);
+		const [ firstHalf, secondHalf ] = lineSegment.splitAt(0.5);
+
+		if (!secondHalf) {
+			throw new Error('Splitting a line segment in half should yield two line segments.');
+		}
+
+		expect(firstHalf.p2).objEq(midpoint);
+		expect(firstHalf.p1).objEq(from);
+		expect(secondHalf.p2).objEq(to);
+		expect(secondHalf.p1).objEq(midpoint);
+
+		// Before start/end
+		expect(lineSegment.splitAt(0)[0]).objEq(lineSegment);
+		expect(lineSegment.splitAt(0)).toHaveLength(1);
+		expect(lineSegment.splitAt(1)).toHaveLength(1);
+		expect(lineSegment.splitAt(2)).toHaveLength(1);
+	});
+
+	it('equivalence check should allow ignoring direction', () => {
+		expect(new LineSegment2(Vec2.zero, Vec2.unitX)).objEq(new LineSegment2(Vec2.zero, Vec2.unitX));
+		expect(new LineSegment2(Vec2.zero, Vec2.unitX)).objEq(new LineSegment2(Vec2.unitX, Vec2.zero));
+		expect(new LineSegment2(Vec2.zero, Vec2.unitX)).not.objEq(new LineSegment2(Vec2.unitX, Vec2.zero), { ignoreDirection: false });
+	});
+
+	it('should support creating from a collection of points', () => {
+		expect(LineSegment2.ofSmallestContainingPoints([])).toBeNull();
+		expect(LineSegment2.ofSmallestContainingPoints([Vec2.of(1, 1)])).toBeNull();
+		expect(LineSegment2.ofSmallestContainingPoints(
+			[Vec2.of(1, 1), Vec2.of(1, 2), Vec2.of(3, 3)]
+		)).toBeNull();
+
+		expect(LineSegment2.ofSmallestContainingPoints(
+			[Vec2.of(1, 1), Vec2.of(1, 2)]
+		)).objEq(new LineSegment2(Vec2.of(1, 1), Vec2.of(1, 2)));
+		expect(LineSegment2.ofSmallestContainingPoints(
+			[Vec2.of(1, 1), Vec2.of(2, 2), Vec2.of(3, 3)]
+		)).objEq(new LineSegment2(Vec2.of(1, 1), Vec2.of(3, 3)));
+		expect(LineSegment2.ofSmallestContainingPoints(
+			[Vec2.of(3, 3), Vec2.of(2, 2), Vec2.of(2.4, 2.4), Vec2.of(3, 3)]
+		)).objEq(new LineSegment2(Vec2.of(2, 2), Vec2.of(3, 3)));
+	});
 });

package/src/shapes/LineSegment2.ts

@@ -1,7 +1,8 @@
 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;
@@ -9,7 +10,7 @@ interface IntersectionResult {
 }
 
 /** Represents a line segment. A `LineSegment2` is immutable. */
-export class LineSegment2 extends Abstract2DShape {
+export class LineSegment2 extends Parameterized2DShape {
 	// invariant: ||direction|| = 1
 
 	/**
@@ -45,6 +46,31 @@ export class LineSegment2 extends Abstract2DShape {
 		}
 	}
 
+	/**
+	 * 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)]));
+	 * ```
+	 */
+	public static ofSmallestContainingPoints(points: readonly Point2[]) {
+		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
 
@@ -58,8 +84,12 @@ export class LineSegment2 extends Abstract2DShape {
 		return this.point2;
 	}
 
+	public get center(): Point2 {
+		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
 	 */
@@ -74,11 +104,40 @@ export class LineSegment2 extends Abstract2DShape {
 	 *
 	 * `t` should be in `[0, 1]`.
 	 */
-	public at(t: number): Point2 {
+	public override at(t: number): Point2 {
 		return this.get(t * this.length);
 	}
 
+	public override normalAt(_t: number): Vec2 {
+		return this.direction.orthog();
+	}
+
+	public override tangentAt(_t: number): Vec3 {
+		return this.direction;
+	}
+
+	public splitAt(t: number): [LineSegment2]|[LineSegment2,LineSegment2] {
+		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
+	 */
 	public intersection(other: LineSegment2): IntersectionResult|null {
+		// 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₁
@@ -105,7 +164,11 @@ 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
@@ -146,10 +209,11 @@ export class LineSegment2 extends Abstract2DShape {
 		}
 
 		// 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
@@ -167,6 +231,15 @@ export class LineSegment2 extends Abstract2DShape {
 		return this.intersection(other) !== null;
 	}
 
+	public override argIntersectsLineSegment(lineSegment: LineSegment2) {
+		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.
@@ -186,6 +259,10 @@ export class LineSegment2 extends Abstract2DShape {
 
 	// Returns the closest point on this to [target]
 	public closestPointTo(target: Point2) {
+		return this.nearestPointTo(target).point;
+	}
+
+	public override nearestPointTo(target: Vec3): { point: Vec3; parameterValue: number; } {
 		// Distance from P1 along this' direction.
 		const projectedDistFromP1 = target.minus(this.p1).dot(this.direction);
 		const projectedDistFromP2 = this.length - projectedDistFromP1;
@@ -193,13 +270,13 @@ export class LineSegment2 extends Abstract2DShape {
 		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 };
 		}
 	}
 
@@ -228,5 +305,26 @@ export class LineSegment2 extends Abstract2DShape {
 	public override 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`)
+	 */
+	public eq(other: LineSegment2, options?: { tolerance?: number, ignoreDirection?: boolean }) {
+		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/src/shapes/Parameterized2DShape.ts

@@ -0,0 +1,44 @@
+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 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}
+	 */
+	public abstract argIntersectsLineSegment(lineSegment: LineSegment2): number[];
+
+
+	public override intersectsLineSegment(line: LineSegment2): Point2[] {
+		return this.argIntersectsLineSegment(line).map(t => this.at(t));
+	}
+}
+
+export default Parameterized2DShape;