@js-draw/math 1.16.0 → 1.17.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,10 @@ 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[] {
 		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 +97,136 @@ 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);
+			// 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 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)
@@ -96,4 +96,38 @@ 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 });
+	});
 });

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
 
 	/**
@@ -58,8 +59,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 +79,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₁
@@ -146,10 +180,10 @@ 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 +201,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 +229,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 +240,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 +275,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,39 @@
+import { Point2, Vec2 } from '../Vec2';
+import Abstract2DShape from './Abstract2DShape';
+import LineSegment2 from './LineSegment2';
+
+/** A 2-dimensional path with parameter interval $t \in [0, 1]$. */
+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;

package/src/shapes/Path.test.ts

@@ -60,6 +60,24 @@ describe('Path', () => {
 		);
 	});
 
+	it.each([
+		[ 'm0,0 L1,1', 'M0,0 L1,1', true ],
+		[ 'm0,0 L1,1', 'M1,1 L0,0', false ],
+		[ 'm0,0 L1,1 Q2,3 4,5', 'M1,1 L0,0', false ],
+		[ 'm0,0 L1,1 Q2,3 4,5', 'M1,1 L0,0 Q2,3 4,5', false ],
+		[ 'm0,0 L1,1 Q2,3 4,5', 'M0,0 L1,1 Q2,3 4,5', true ],
+		[ 'm0,0 L1,1 Q2,3 4,5 C4,5 6,7 8,9', 'M0,0 L1,1 Q2,3 4,5 C4,5 6,7 8,9', true ],
+		[ 'm0,0 L1,1 Q2,3 4,5 C4,5 6,7 8,9Z', 'M0,0 L1,1 Q2,3 4,5 C4,5 6,7 8,9', false ],
+		[ 'm0,0 L1,1 Q2,3 4,5 C4,5 6,7 8,9', 'M0,0 L1,1 Q2,3 4,5 C4,5 6,7 8,9Z', false ],
+		[ 'm0,0 L1,1 Q2,3 4,5 C4,5 6,7 8,9', 'M0,0 L1,1 Q2,3 4,5 C4,5 6,7 8,9.01', false ],
+		[ 'm0,0 L1,1 Q2,3 4,5 C4,5 6,7 8,9', 'M0,0 L1,1 Q2,3 4,5 C4,5 6,7.01 8,9', false ],
+		[ 'm0,0 L1,1 Q2,3 4,5 C4,5 6,7 8,9', 'M0,0 L1,1 Q2,3 4,5 C4,5.01 6,7 8,9', false ],
+	])('.eq should check equality', (path1Str, path2Str, shouldEqual) => {
+		expect(Path.fromString(path1Str)).objEq(Path.fromString(path1Str));
+		expect(Path.fromString(path2Str)).objEq(Path.fromString(path2Str));
+		expect(Path.fromString(path1Str).eq(Path.fromString(path2Str))).toBe(shouldEqual);
+	});
+
 	describe('intersection', () => {
 		it('should give all intersections for a path made up of lines', () => {
 			const lineStart = Vec2.of(100, 100);
@@ -179,7 +197,7 @@ describe('Path', () => {
 			});
 		});
 
-		it('should give all intersections for a Bézier stroked path', () => {
+		it('should correctly report intersections for a simple Bézier curve path', () => {
 			const lineStart = Vec2.zero;
 			const path = new Path(lineStart, [
 				{
@@ -196,13 +214,36 @@ describe('Path', () => {
 			let intersections = path.intersection(
 				new LineSegment2(Vec2.of(-1, 0.5), Vec2.of(2, 0.5)), strokeWidth,
 			);
-			expect(intersections.length).toBe(0);
+			expect(intersections).toHaveLength(0);
 
 			// Should be an intersection when exiting/entering the edge of the stroke
 			intersections = path.intersection(
 				new LineSegment2(Vec2.of(0, 0.5), Vec2.of(8, 0.5)), strokeWidth,
 			);
-			expect(intersections.length).toBe(1);
+			expect(intersections).toHaveLength(1);
+		});
+
+		it('should correctly report intersections near the cap of a line-like Bézier', () => {
+			const path = Path.fromString('M0,0Q14,0 27,0');
+			expect(
+				path.intersection(
+					new LineSegment2(Vec2.of(0, -100), Vec2.of(0, 100)),
+					10,
+				),
+
+				// Should have intersections, despite being at the cap of the Bézier
+				// curve.
+			).toHaveLength(2);
+		});
+
+		it.each([
+			[new LineSegment2(Vec2.of(43.5,-12.5), Vec2.of(40.5,24.5)), 0],
+			// TODO: The below case is failing. It seems to be a Bezier-js bug though...
+			// (The Bézier.js method returns an empty array).
+			//[new LineSegment2(Vec2.of(35.5,19.5), Vec2.of(38.5,-17.5)), 0],
+		])('should correctly report positive intersections with a line-like Bézier', (line, strokeRadius) => {
+			const bezier = Path.fromString('M0,0 Q50,0 100,0');
+			expect(bezier.intersection(line, strokeRadius).length).toBeGreaterThan(0);
 		});
 	});
 
@@ -306,4 +347,23 @@ describe('Path', () => {
 			expect(strokedRect.startPoint).objEq(lastSegment.point);
 		});
 	});
+
+	it.each([
+		[ 'm0,0 L1,1', 'M1,1 L0,0' ],
+		[ 'm0,0 L1,1', 'M1,1 L0,0' ],
+		[ 'M0,0 L1,1 Q2,2 3,3', 'M3,3 Q2,2 1,1 L0,0' ],
+		[ 'M0,0 L1,1 Q4,2 5,3 C12,13 10,9 8,7', 'M8,7 C 10,9 12,13 5,3 Q 4,2 1,1 L 0,0' ],
+	])('.reversed should reverse paths', (original, expected) => {
+		expect(Path.fromString(original).reversed()).objEq(Path.fromString(expected));
+		expect(Path.fromString(expected).reversed()).objEq(Path.fromString(original));
+		expect(Path.fromString(original).reversed().reversed()).objEq(Path.fromString(original));
+	});
+
+	it.each([
+		[ 'm0,0 l1,0', Vec2.of(0, 0), Vec2.of(0, 0) ],
+		[ 'm0,0 l1,0', Vec2.of(0.5, 0), Vec2.of(0.5, 0) ],
+		[ 'm0,0 Q1,0 1,2', Vec2.of(1, 0), Vec2.of(0.6236, 0.299) ],
+	])('.nearestPointTo should return the closest point on a path to the given parameter (case %#)', (path, point, expectedClosest) => {
+		expect(Path.fromString(path).nearestPointTo(point).point).objEq(expectedClosest, 0.002);
+	});
 });