@js-draw/math 1.11.1 → 1.17.0

package/dist/cjs/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;
     /**
@@ -28,8 +29,9 @@ export declare class LineSegment2 extends Abstract2DShape {
     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 +44,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 +66,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 +84,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/cjs/shapes/LineSegment2.js

@@ -6,9 +6,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.LineSegment2 = void 0;
 const Rect2_1 = __importDefault(require("./Rect2"));
 const Vec2_1 = require("../Vec2");
-const Abstract2DShape_1 = __importDefault(require("./Abstract2DShape"));
+const Parameterized2DShape_1 = __importDefault(require("./Parameterized2DShape"));
 /** Represents a line segment. A `LineSegment2` is immutable. */
-class LineSegment2 extends Abstract2DShape_1.default {
+class LineSegment2 extends Parameterized2DShape_1.default {
     /** Creates a new `LineSegment2` from its endpoints. */
     constructor(point1, point2) {
         super();
@@ -32,8 +32,11 @@ class LineSegment2 extends Abstract2DShape_1.default {
     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
      */
@@ -50,7 +53,31 @@ class LineSegment2 extends Abstract2DShape_1.default {
     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₁
@@ -109,10 +136,10 @@ class LineSegment2 extends Abstract2DShape_1.default {
             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
@@ -127,6 +154,13 @@ class LineSegment2 extends Abstract2DShape_1.default {
     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.
@@ -144,18 +178,21 @@ class LineSegment2 extends Abstract2DShape_1.default {
     }
     // 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 };
         }
     }
     /**
@@ -178,6 +215,22 @@ class LineSegment2 extends Abstract2DShape_1.default {
     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)));
+    }
 }
 exports.LineSegment2 = LineSegment2;
 exports.default = LineSegment2;

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

@@ -0,0 +1,31 @@
+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 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/cjs/shapes/Parameterized2DShape.js

@@ -0,0 +1,15 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Parameterized2DShape = void 0;
+const Abstract2DShape_1 = __importDefault(require("./Abstract2DShape"));
+/** A 2-dimensional path with parameter interval $t \in [0, 1]$. */
+class Parameterized2DShape extends Abstract2DShape_1.default {
+    intersectsLineSegment(line) {
+        return this.argIntersectsLineSegment(line).map(t => this.at(t));
+    }
+}
+exports.Parameterized2DShape = Parameterized2DShape;
+exports.default = Parameterized2DShape;

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

@@ -4,13 +4,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Path = exports.PathCommandType = void 0;
-const rounding_1 = require("../rounding");
 const LineSegment2_1 = __importDefault(require("./LineSegment2"));
 const Rect2_1 = __importDefault(require("./Rect2"));
 const Vec2_1 = require("../Vec2");
 const CubicBezier_1 = __importDefault(require("./CubicBezier"));
 const QuadraticBezier_1 = __importDefault(require("./QuadraticBezier"));
 const PointShape2D_1 = __importDefault(require("./PointShape2D"));
+const toRoundedString_1 = __importDefault(require("../rounding/toRoundedString"));
+const toStringOfSamePrecision_1 = __importDefault(require("../rounding/toStringOfSamePrecision"));
 var PathCommandType;
 (function (PathCommandType) {
     PathCommandType[PathCommandType["LineTo"] = 0] = "LineTo";
@@ -235,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);
@@ -273,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, 
@@ -317,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;
         };
@@ -352,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.
@@ -372,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:
@@ -415,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) {
@@ -518,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`.
      *
@@ -591,15 +750,15 @@ class Path {
             const absoluteCommandParts = [];
             const relativeCommandParts = [];
             const makeAbsCommand = !prevPoint || onlyAbsCommands;
-            const roundedPrevX = prevPoint ? (0, rounding_1.toRoundedString)(prevPoint.x) : '';
-            const roundedPrevY = prevPoint ? (0, rounding_1.toRoundedString)(prevPoint.y) : '';
+            const roundedPrevX = prevPoint ? (0, toRoundedString_1.default)(prevPoint.x) : '';
+            const roundedPrevY = prevPoint ? (0, toRoundedString_1.default)(prevPoint.y) : '';
             for (const point of points) {
-                const xComponent = (0, rounding_1.toRoundedString)(point.x);
-                const yComponent = (0, rounding_1.toRoundedString)(point.y);
+                const xComponent = (0, toRoundedString_1.default)(point.x);
+                const yComponent = (0, toRoundedString_1.default)(point.y);
                 // Relative commands are often shorter as strings than absolute commands.
                 if (!makeAbsCommand) {
-                    const xComponentRelative = (0, rounding_1.toStringOfSamePrecision)(point.x - prevPoint.x, xComponent, roundedPrevX, roundedPrevY);
-                    const yComponentRelative = (0, rounding_1.toStringOfSamePrecision)(point.y - prevPoint.y, yComponent, roundedPrevX, roundedPrevY);
+                    const xComponentRelative = (0, toStringOfSamePrecision_1.default)(point.x - prevPoint.x, xComponent, roundedPrevX, roundedPrevY);
+                    const yComponentRelative = (0, toStringOfSamePrecision_1.default)(point.y - prevPoint.y, yComponent, roundedPrevX, roundedPrevY);
                     // No need for an additional separator if it starts with a '-'
                     if (yComponentRelative.charAt(0) === '-') {
                         relativeCommandParts.push(`${xComponentRelative}${yComponentRelative}`);

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;