curvy 1.0.8 → 1.0.9

package/dist/path/cubic2d.d.mts

@@ -3,27 +3,93 @@ import { Pipeable } from '../pipe.mjs';
 import { Vector2 } from '../vector/vector2.mjs';
 import '../shared/curvy.Bf5TIk31.mjs';
 import '../interval.mjs';
-import '../shared/curvy.NsmY7zcr.mjs';
+import '../shared/curvy.FDaj5rlj.mjs';
 import '../vector/vector3.mjs';
 import '../vector/vector4.mjs';
 
 declare const CubicPath2dTypeId: unique symbol;
 type CubicPath2dTypeId = typeof CubicPath2dTypeId;
 
+/**
+ * A cubic path in 2D space.
+ *
+ * All fields are readonly and immutable, and all operations create new instances.
+ *
+ * @since 1.0.0
+ */
 interface CubicPath2d extends Pipeable, Iterable<CubicCurve2d> {
     readonly [CubicPath2dTypeId]: CubicPath2dTypeId;
 }
+/**
+ * Creates a new `CubicPath2d` instance from curve parameters.
+ *
+ * @param curves - The curves to create the path from.
+ * @returns A new `CubicPath2d` instance.
+ * @since 1.0.0
+ */
 declare const fromCurves: (...curves: ReadonlyArray<CubicCurve2d>) => CubicPath2d;
+/**
+ * Creates a new `CubicPath2d` instance from an array of curves.
+ *
+ * @param curves - The curves to create the path from.
+ * @returns A new `CubicPath2d` instance.
+ * @since 1.0.0
+ */
 declare const fromCurveArray: (curves: ReadonlyArray<CubicCurve2d>) => CubicPath2d;
+/**
+ * Checks if a value is a `CubicPath2d`.
+ *
+ * @param p - The value to check.
+ * @returns `true` if the value is a `CubicPath2d`, `false` otherwise.
+ * @since 1.0.0
+ */
 declare const isCubicPath2d: (p: unknown) => p is CubicPath2d;
 declare const append: {
+    /**
+     * Appends a cubic curve to a cubic path.
+     *
+     * @param c - The cubic curve to append.
+     * @returns A function that takes a cubic path and returns a new cubic path.
+     * @since 1.0.0
+     */
     (c: CubicCurve2d): (p: CubicPath2d) => CubicPath2d;
+    /**
+     * Appends a cubic curve to a cubic path.
+     *
+     * @param p - The cubic path to append to.
+     * @param c - The cubic curve to append.
+     * @returns A new cubic path.
+     * @since 1.0.0
+     */
     (p: CubicPath2d, c: CubicCurve2d): CubicPath2d;
 };
+/**
+ * Calculates the length of a cubic path.
+ *
+ * @param p - The cubic path to calculate the length of.
+ * @returns The length of the cubic path.
+ * @since 1.0.0
+ */
 declare const length: (p: CubicPath2d) => number;
 declare const solve: {
+    /**
+     * Solves a cubic path for a given parameter.
+     *
+     * @param u - The parameter to solve for.
+     * @returns A function that takes a cubic path and returns the solved vector.
+     * @since 1.0.0
+     */
     (u: number): (p: CubicPath2d) => Vector2;
+    /**
+     * Solves a cubic path for a given parameter.
+     *
+     * @param p - The cubic path to solve.
+     * @param u - The parameter to solve for.
+     * @returns The solved vector.
+     * @since 1.0.0
+     */
     (p: CubicPath2d, u: number): Vector2;
 };
 
-export { type CubicPath2d, append, fromCurveArray, fromCurves, isCubicPath2d, length, solve };
+export { append, fromCurveArray, fromCurves, isCubicPath2d, length, solve };
+export type { CubicPath2d };

package/dist/path/cubic2d.d.ts

@@ -3,27 +3,93 @@ import { Pipeable } from '../pipe.js';
 import { Vector2 } from '../vector/vector2.js';
 import '../shared/curvy.Bf5TIk31.js';
 import '../interval.js';
-import '../shared/curvy.BsHoYJNv.js';
+import '../shared/curvy.Cg8lZVUz.js';
 import '../vector/vector3.js';
 import '../vector/vector4.js';
 
 declare const CubicPath2dTypeId: unique symbol;
 type CubicPath2dTypeId = typeof CubicPath2dTypeId;
 
+/**
+ * A cubic path in 2D space.
+ *
+ * All fields are readonly and immutable, and all operations create new instances.
+ *
+ * @since 1.0.0
+ */
 interface CubicPath2d extends Pipeable, Iterable<CubicCurve2d> {
     readonly [CubicPath2dTypeId]: CubicPath2dTypeId;
 }
+/**
+ * Creates a new `CubicPath2d` instance from curve parameters.
+ *
+ * @param curves - The curves to create the path from.
+ * @returns A new `CubicPath2d` instance.
+ * @since 1.0.0
+ */
 declare const fromCurves: (...curves: ReadonlyArray<CubicCurve2d>) => CubicPath2d;
+/**
+ * Creates a new `CubicPath2d` instance from an array of curves.
+ *
+ * @param curves - The curves to create the path from.
+ * @returns A new `CubicPath2d` instance.
+ * @since 1.0.0
+ */
 declare const fromCurveArray: (curves: ReadonlyArray<CubicCurve2d>) => CubicPath2d;
+/**
+ * Checks if a value is a `CubicPath2d`.
+ *
+ * @param p - The value to check.
+ * @returns `true` if the value is a `CubicPath2d`, `false` otherwise.
+ * @since 1.0.0
+ */
 declare const isCubicPath2d: (p: unknown) => p is CubicPath2d;
 declare const append: {
+    /**
+     * Appends a cubic curve to a cubic path.
+     *
+     * @param c - The cubic curve to append.
+     * @returns A function that takes a cubic path and returns a new cubic path.
+     * @since 1.0.0
+     */
     (c: CubicCurve2d): (p: CubicPath2d) => CubicPath2d;
+    /**
+     * Appends a cubic curve to a cubic path.
+     *
+     * @param p - The cubic path to append to.
+     * @param c - The cubic curve to append.
+     * @returns A new cubic path.
+     * @since 1.0.0
+     */
     (p: CubicPath2d, c: CubicCurve2d): CubicPath2d;
 };
+/**
+ * Calculates the length of a cubic path.
+ *
+ * @param p - The cubic path to calculate the length of.
+ * @returns The length of the cubic path.
+ * @since 1.0.0
+ */
 declare const length: (p: CubicPath2d) => number;
 declare const solve: {
+    /**
+     * Solves a cubic path for a given parameter.
+     *
+     * @param u - The parameter to solve for.
+     * @returns A function that takes a cubic path and returns the solved vector.
+     * @since 1.0.0
+     */
     (u: number): (p: CubicPath2d) => Vector2;
+    /**
+     * Solves a cubic path for a given parameter.
+     *
+     * @param p - The cubic path to solve.
+     * @param u - The parameter to solve for.
+     * @returns The solved vector.
+     * @since 1.0.0
+     */
     (p: CubicPath2d, u: number): Vector2;
 };
 
-export { type CubicPath2d, append, fromCurveArray, fromCurves, isCubicPath2d, length, solve };
+export { append, fromCurveArray, fromCurves, isCubicPath2d, length, solve };
+export type { CubicPath2d };

package/dist/path/cubic2d.mjs

@@ -1,38 +1,35 @@
 import { length as length$2, solve as solve$2 } from '../curve/cubic2d.mjs';
 import { unit } from '../interval.mjs';
 import { dual, Pipeable } from '../pipe.mjs';
-import { round, invariant } from '../utils.mjs';
+import { invariant, round } from '../utils.mjs';
 import '../shared/curvy.DmVFTi0N.mjs';
 import '../polynomial/cubic.mjs';
-import '../shared/curvy.BzVmUIKm.mjs';
-import '../shared/curvy.BDhiZ7He.mjs';
-import '../polynomial/quadratic.mjs';
+import '../shared/curvy.BxdGW9he.mjs';
 import '../vector/vector2.mjs';
-import '../shared/curvy.BZ_mTkJe.mjs';
+import '../shared/curvy.DJ4xO0al.mjs';
+import '../shared/curvy.r6f1j287.mjs';
+import '../polynomial/quadratic.mjs';
 import '../curve/linear2d.mjs';
 import '../polynomial/linear.mjs';
 import '../curve/quadratic2d.mjs';
 
+var _a;
 const CubicPath2dTypeId = Symbol("curvy/path/cubic2d");
 class CubicPath2dImpl extends Pipeable {
-  [CubicPath2dTypeId] = CubicPath2dTypeId;
-  curves;
   constructor(curves) {
     invariant(curves.length > 0, "cubic path requires at least one curve");
     super();
+    this[_a] = CubicPath2dTypeId;
     this.curves = curves;
   }
-  [Symbol.iterator]() {
+  [(_a = CubicPath2dTypeId, Symbol.iterator)]() {
     return this.curves[Symbol.iterator]();
   }
 }
 const isCubicPath2d$1 = (p) => typeof p === "object" && p !== null && CubicPath2dTypeId in p;
 const fromCurves$1 = (...curves) => new CubicPath2dImpl(curves);
 const fromCurveArray$1 = (curves) => new CubicPath2dImpl(curves);
-const append$1 = dual(
-  2,
-  (p, c) => fromCurveArray$1([...p, c])
-);
+const append$1 = dual(2, (p, c) => fromCurveArray$1([...p, c]));
 const length$1 = (p) => {
   let length2 = 0;
   for (const curve of p) {
@@ -60,3 +57,4 @@ const length = length$1;
 const solve = solve$1;
 
 export { append, fromCurveArray, fromCurves, isCubicPath2d, length, solve };
+//# sourceMappingURL=cubic2d.mjs.map

package/dist/path/cubic2d.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"cubic2d.mjs","sources":["../../src/path/cubic2d.internal.ts","../../src/path/cubic2d.ts"],"sourcesContent":["import * as CubicCurve2d from '../curve/cubic2d'\nimport * as Interval from '../interval'\nimport { Pipeable } from '../pipe'\nimport { dual } from '../pipe'\nimport { invariant, round } from '../utils'\nimport type { Vector2 } from '../vector/vector2'\nimport type { CubicPath2d } from './cubic2d'\n\nexport const CubicPath2dTypeId: unique symbol = Symbol('curvy/path/cubic2d')\nexport type CubicPath2dTypeId = typeof CubicPath2dTypeId\n\nexport class CubicPath2dImpl extends Pipeable implements CubicPath2d {\n  readonly [CubicPath2dTypeId]: CubicPath2dTypeId = CubicPath2dTypeId\n\n  readonly curves: ReadonlyArray<CubicCurve2d.CubicCurve2d>\n\n  constructor(curves: ReadonlyArray<CubicCurve2d.CubicCurve2d>) {\n    invariant(curves.length > 0, 'cubic path requires at least one curve')\n    super()\n    this.curves = curves\n  }\n\n  [Symbol.iterator](): Iterator<CubicCurve2d.CubicCurve2d> {\n    return this.curves[Symbol.iterator]()\n  }\n}\n\nexport const isCubicPath2d = (p: unknown): p is CubicPath2d =>\n  typeof p === 'object' && p !== null && CubicPath2dTypeId in p\n\nexport const fromCurves = (...curves: ReadonlyArray<CubicCurve2d.CubicCurve2d>): CubicPath2d =>\n  new CubicPath2dImpl(curves)\n\nexport const fromCurveArray = (curves: ReadonlyArray<CubicCurve2d.CubicCurve2d>): CubicPath2d =>\n  new CubicPath2dImpl(curves)\n\nexport const append = dual<\n  (c: CubicCurve2d.CubicCurve2d) => (p: CubicPath2d) => CubicPath2d,\n  (p: CubicPath2d, c: CubicCurve2d.CubicCurve2d) => CubicPath2d\n>(2, (p: CubicPath2d, c: CubicCurve2d.CubicCurve2d) => fromCurveArray([...p, c]))\n\nexport const length = (p: CubicPath2d) => {\n  let length = 0\n  for (const curve of p) {\n    length += CubicCurve2d.length(curve, Interval.unit)\n  }\n\n  return round(length)\n}\n\nexport const solve = dual<\n  (u: number) => (p: CubicPath2d) => Vector2,\n  (p: CubicPath2d, u: number) => Vector2\n>(2, (p: CubicPath2d, u: number) => {\n  const curves = p instanceof CubicPath2dImpl ? p.curves : [...p]\n\n  if (u === 1) {\n    const last = curves.at(-1) as CubicCurve2d.CubicCurve2d\n    return CubicCurve2d.solve(last, 1)\n  }\n\n  const t = u * curves.length\n  const i = Math.floor(t)\n  const curve = curves[i] as CubicCurve2d.CubicCurve2d\n  return CubicCurve2d.solve(curve, t - i)\n})\n","import type { CubicCurve2d } from '../curve/cubic2d'\nimport type { Pipeable } from '../pipe'\nimport type { Vector2 } from '../vector/vector2'\nimport type { CubicPath2dTypeId } from './cubic2d.internal'\nimport * as internal from './cubic2d.internal'\n\n/**\n * A cubic path in 2D space.\n *\n * All fields are readonly and immutable, and all operations create new instances.\n *\n * @since 1.0.0\n */\nexport interface CubicPath2d extends Pipeable, Iterable<CubicCurve2d> {\n  readonly [CubicPath2dTypeId]: CubicPath2dTypeId\n}\n\n/**\n * Creates a new `CubicPath2d` instance from curve parameters.\n *\n * @param curves - The curves to create the path from.\n * @returns A new `CubicPath2d` instance.\n * @since 1.0.0\n */\nexport const fromCurves: (...curves: ReadonlyArray<CubicCurve2d>) => CubicPath2d =\n  internal.fromCurves\n\n/**\n * Creates a new `CubicPath2d` instance from an array of curves.\n *\n * @param curves - The curves to create the path from.\n * @returns A new `CubicPath2d` instance.\n * @since 1.0.0\n */\nexport const fromCurveArray: (curves: ReadonlyArray<CubicCurve2d>) => CubicPath2d =\n  internal.fromCurveArray\n\n/**\n * Checks if a value is a `CubicPath2d`.\n *\n * @param p - The value to check.\n * @returns `true` if the value is a `CubicPath2d`, `false` otherwise.\n * @since 1.0.0\n */\nexport const isCubicPath2d: (p: unknown) => p is CubicPath2d = internal.isCubicPath2d\n\nexport const append: {\n  /**\n   * Appends a cubic curve to a cubic path.\n   *\n   * @param c - The cubic curve to append.\n   * @returns A function that takes a cubic path and returns a new cubic path.\n   * @since 1.0.0\n   */\n  (c: CubicCurve2d): (p: CubicPath2d) => CubicPath2d\n  /**\n   * Appends a cubic curve to a cubic path.\n   *\n   * @param p - The cubic path to append to.\n   * @param c - The cubic curve to append.\n   * @returns A new cubic path.\n   * @since 1.0.0\n   */\n  (p: CubicPath2d, c: CubicCurve2d): CubicPath2d\n} = internal.append\n\n/**\n * Calculates the length of a cubic path.\n *\n * @param p - The cubic path to calculate the length of.\n * @returns The length of the cubic path.\n * @since 1.0.0\n */\nexport const length: (p: CubicPath2d) => number = internal.length\n\nexport const solve: {\n  /**\n   * Solves a cubic path for a given parameter.\n   *\n   * @param u - The parameter to solve for.\n   * @returns A function that takes a cubic path and returns the solved vector.\n   * @since 1.0.0\n   */\n  (u: number): (p: CubicPath2d) => Vector2\n  /**\n   * Solves a cubic path for a given parameter.\n   *\n   * @param p - The cubic path to solve.\n   * @param u - The parameter to solve for.\n   * @returns The solved vector.\n   * @since 1.0.0\n   */\n  (p: CubicPath2d, u: number): Vector2\n} = internal.solve\n"],"names":["isCubicPath2d","fromCurves","fromCurveArray","append","length","CubicCurve2d.length","Interval.unit","solve","CubicCurve2d.solve","internal.fromCurves","internal.fromCurveArray","internal.isCubicPath2d","internal.append","internal.length","internal.solve"],"mappings":";;;;;;;;;;;;;;;AAAA,IAAA,EAAA;AAQa,MAAA,iBAAA,GAAmC,OAAO,oBAAoB,CAAA;AAGpE,MAAM,wBAAwB,QAAgC,CAAA;AAAA,EAKnE,YAAY,MAAkD,EAAA;AAC5D,IAAU,SAAA,CAAA,MAAA,CAAO,MAAS,GAAA,CAAA,EAAG,wCAAwC,CAAA;AACrE,IAAM,KAAA,EAAA;AANR,IAAA,IAAA,CAAU,EAAwC,CAAA,GAAA,iBAAA;AAOhD,IAAA,IAAA,CAAK,MAAS,GAAA,MAAA;AAAA;AAChB,EAEA,EAVU,EAAA,GAAA,iBAAA,EAUT,MAAO,CAAA,QAAA,EAAiD,GAAA;AACvD,IAAA,OAAO,IAAK,CAAA,MAAA,CAAO,MAAO,CAAA,QAAQ,CAAE,EAAA;AAAA;AAExC;AAEa,MAAAA,eAAA,GAAgB,CAAC,CAC5B,KAAA,OAAO,MAAM,QAAY,IAAA,CAAA,KAAM,QAAQ,iBAAqB,IAAA,CAAA;AAEvD,MAAMC,YAAa,GAAA,CAAA,GAAI,MAC5B,KAAA,IAAI,gBAAgB,MAAM,CAAA;AAErB,MAAMC,gBAAiB,GAAA,CAAC,MAC7B,KAAA,IAAI,gBAAgB,MAAM,CAAA;AAErB,MAAMC,QAAS,GAAA,IAAA,CAGpB,CAAG,EAAA,CAAC,CAAgB,EAAA,CAAA,KAAiCD,gBAAe,CAAA,CAAC,GAAG,CAAA,EAAG,CAAC,CAAC,CAAC,CAAA;AAEnE,MAAAE,QAAA,GAAS,CAAC,CAAmB,KAAA;AACxC,EAAA,IAAIA,OAAS,GAAA,CAAA;AACb,EAAA,KAAA,MAAW,SAAS,CAAG,EAAA;AACrB,IAAAA,OAAU,IAAAC,QAAoB,CAAA,KAAA,EAAOC,IAAa,CAAA;AAAA;AAGpD,EAAA,OAAO,MAAMF,OAAM,CAAA;AACrB,CAAA;AAEO,MAAMG,OAAQ,GAAA,IAAA,CAGnB,CAAG,EAAA,CAAC,GAAgB,CAAc,KAAA;AAClC,EAAA,MAAM,SAAS,CAAa,YAAA,eAAA,GAAkB,EAAE,MAAS,GAAA,CAAC,GAAG,CAAC,CAAA;AAE9D,EAAA,IAAI,MAAM,CAAG,EAAA;AACX,IAAM,MAAA,IAAA,GAAO,MAAO,CAAA,EAAA,CAAG,EAAE,CAAA;AACzB,IAAO,OAAAC,OAAmB,CAAA,IAAA,EAAM,CAAC,CAAA;AAAA;AAGnC,EAAM,MAAA,CAAA,GAAI,IAAI,MAAO,CAAA,MAAA;AACrB,EAAM,MAAA,CAAA,GAAI,IAAK,CAAA,KAAA,CAAM,CAAC,CAAA;AACtB,EAAM,MAAA,KAAA,GAAQ,OAAO,CAAC,CAAA;AACtB,EAAA,OAAOA,OAAa,CAAM,KAAO,EAAA,CAAA,GAAI,CAAC,CAAA;AACxC,CAAC,CAAA;;ACzCM,MAAM,aACXC;AASK,MAAM,iBACXC;AASK,MAAM,gBAAkDC;AAExD,MAAM,SAkBTC;AASG,MAAM,SAAqCC;AAE3C,MAAM,QAkBTC;;;;"}

package/dist/path/linear2d.d.mts

@@ -3,27 +3,93 @@ import { Pipeable } from '../pipe.mjs';
 import { Vector2 } from '../vector/vector2.mjs';
 import '../shared/curvy.Bf5TIk31.mjs';
 import '../interval.mjs';
-import '../shared/curvy.NsmY7zcr.mjs';
+import '../shared/curvy.FDaj5rlj.mjs';
 import '../vector/vector3.mjs';
 import '../vector/vector4.mjs';
 
 declare const LinearPath2dTypeId: unique symbol;
 type LinearPath2dTypeId = typeof LinearPath2dTypeId;
 
+/**
+ * A linear path in 2D space.
+ *
+ * All fields are readonly and immutable, and all operations create new instances.
+ *
+ * @since 1.0.0
+ */
 interface LinearPath2d extends Pipeable, Iterable<LinearCurve2d> {
     readonly [LinearPath2dTypeId]: LinearPath2dTypeId;
 }
+/**
+ * Creates a new `LinearPath2d` instance from curve parameters.
+ *
+ * @param curves - The curves to create the path from.
+ * @returns A new `LinearPath2d` instance.
+ * @since 1.0.0
+ */
 declare const fromCurves: (...curves: ReadonlyArray<LinearCurve2d>) => LinearPath2d;
+/**
+ * Creates a new `LinearPath2d` instance from an array of curves.
+ *
+ * @param curves - The curves to create the path from.
+ * @returns A new `LinearPath2d` instance.
+ * @since 1.0.0
+ */
 declare const fromCurveArray: (curves: ReadonlyArray<LinearCurve2d>) => LinearPath2d;
+/**
+ * Checks if a value is a `LinearPath2d`.
+ *
+ * @param p - The value to check.
+ * @returns `true` if the value is a `LinearPath2d`, `false` otherwise.
+ * @since 1.0.0
+ */
 declare const isLinearPath2d: (p: unknown) => p is LinearPath2d;
 declare const append: {
+    /**
+     * Appends a linear curve to a linear path.
+     *
+     * @param c - The linear curve to append.
+     * @returns A function that takes a linear path and returns a new linear path.
+     * @since 1.0.0
+     */
     (c: LinearCurve2d): (p: LinearPath2d) => LinearPath2d;
+    /**
+     * Appends a linear curve to a linear path.
+     *
+     * @param p - The linear path to append to.
+     * @param c - The linear curve to append.
+     * @returns A new `LinearPath2d` instance with the appended curve.
+     * @since 1.0.0
+     */
     (p: LinearPath2d, c: LinearCurve2d): LinearPath2d;
 };
+/**
+ * Calculates the length of a linear path.
+ *
+ * @param p - The linear path to calculate the length of.
+ * @returns The length of the linear path.
+ * @since 1.0.0
+ */
 declare const length: (p: LinearPath2d) => number;
 declare const solve: {
+    /**
+     * Solves a linear path for a given parameter.
+     *
+     * @param u - The parameter to solve for.
+     * @returns A function that takes a linear path and returns the solved point.
+     * @since 1.0.0
+     */
     (u: number): (p: LinearPath2d) => Vector2;
+    /**
+     * Solves a linear path for a given parameter.
+     *
+     * @param p - The linear path to solve.
+     * @param u - The parameter to solve for.
+     * @returns The solved point on the linear path.
+     * @since 1.0.0
+     */
     (p: LinearPath2d, u: number): Vector2;
 };
 
-export { type LinearPath2d, append, fromCurveArray, fromCurves, isLinearPath2d, length, solve };
+export { append, fromCurveArray, fromCurves, isLinearPath2d, length, solve };
+export type { LinearPath2d };

package/dist/path/linear2d.d.ts

@@ -3,27 +3,93 @@ import { Pipeable } from '../pipe.js';
 import { Vector2 } from '../vector/vector2.js';
 import '../shared/curvy.Bf5TIk31.js';
 import '../interval.js';
-import '../shared/curvy.BsHoYJNv.js';
+import '../shared/curvy.Cg8lZVUz.js';
 import '../vector/vector3.js';
 import '../vector/vector4.js';
 
 declare const LinearPath2dTypeId: unique symbol;
 type LinearPath2dTypeId = typeof LinearPath2dTypeId;
 
+/**
+ * A linear path in 2D space.
+ *
+ * All fields are readonly and immutable, and all operations create new instances.
+ *
+ * @since 1.0.0
+ */
 interface LinearPath2d extends Pipeable, Iterable<LinearCurve2d> {
     readonly [LinearPath2dTypeId]: LinearPath2dTypeId;
 }
+/**
+ * Creates a new `LinearPath2d` instance from curve parameters.
+ *
+ * @param curves - The curves to create the path from.
+ * @returns A new `LinearPath2d` instance.
+ * @since 1.0.0
+ */
 declare const fromCurves: (...curves: ReadonlyArray<LinearCurve2d>) => LinearPath2d;
+/**
+ * Creates a new `LinearPath2d` instance from an array of curves.
+ *
+ * @param curves - The curves to create the path from.
+ * @returns A new `LinearPath2d` instance.
+ * @since 1.0.0
+ */
 declare const fromCurveArray: (curves: ReadonlyArray<LinearCurve2d>) => LinearPath2d;
+/**
+ * Checks if a value is a `LinearPath2d`.
+ *
+ * @param p - The value to check.
+ * @returns `true` if the value is a `LinearPath2d`, `false` otherwise.
+ * @since 1.0.0
+ */
 declare const isLinearPath2d: (p: unknown) => p is LinearPath2d;
 declare const append: {
+    /**
+     * Appends a linear curve to a linear path.
+     *
+     * @param c - The linear curve to append.
+     * @returns A function that takes a linear path and returns a new linear path.
+     * @since 1.0.0
+     */
     (c: LinearCurve2d): (p: LinearPath2d) => LinearPath2d;
+    /**
+     * Appends a linear curve to a linear path.
+     *
+     * @param p - The linear path to append to.
+     * @param c - The linear curve to append.
+     * @returns A new `LinearPath2d` instance with the appended curve.
+     * @since 1.0.0
+     */
     (p: LinearPath2d, c: LinearCurve2d): LinearPath2d;
 };
+/**
+ * Calculates the length of a linear path.
+ *
+ * @param p - The linear path to calculate the length of.
+ * @returns The length of the linear path.
+ * @since 1.0.0
+ */
 declare const length: (p: LinearPath2d) => number;
 declare const solve: {
+    /**
+     * Solves a linear path for a given parameter.
+     *
+     * @param u - The parameter to solve for.
+     * @returns A function that takes a linear path and returns the solved point.
+     * @since 1.0.0
+     */
     (u: number): (p: LinearPath2d) => Vector2;
+    /**
+     * Solves a linear path for a given parameter.
+     *
+     * @param p - The linear path to solve.
+     * @param u - The parameter to solve for.
+     * @returns The solved point on the linear path.
+     * @since 1.0.0
+     */
     (p: LinearPath2d, u: number): Vector2;
 };
 
-export { type LinearPath2d, append, fromCurveArray, fromCurves, isLinearPath2d, length, solve };
+export { append, fromCurveArray, fromCurves, isLinearPath2d, length, solve };
+export type { LinearPath2d };

package/dist/path/linear2d.mjs

@@ -3,29 +3,26 @@ import { unit } from '../interval.mjs';
 import { dual, Pipeable } from '../pipe.mjs';
 import { round } from '../utils.mjs';
 import '../polynomial/linear.mjs';
-import '../shared/curvy.BDhiZ7He.mjs';
+import '../shared/curvy.r6f1j287.mjs';
 import '../vector/vector2.mjs';
-import '../shared/curvy.BZ_mTkJe.mjs';
+import '../shared/curvy.DJ4xO0al.mjs';
 
+var _a;
 const LinearPath2dTypeId = Symbol("curvy/path/linear2d");
 class LinearPath2dImpl extends Pipeable {
-  [LinearPath2dTypeId] = LinearPath2dTypeId;
-  curves;
   constructor(curves) {
     super();
+    this[_a] = LinearPath2dTypeId;
     this.curves = curves;
   }
-  [Symbol.iterator]() {
+  [(_a = LinearPath2dTypeId, Symbol.iterator)]() {
     return this.curves[Symbol.iterator]();
   }
 }
 const isLinearPath2d$1 = (p) => typeof p === "object" && p !== null && LinearPath2dTypeId in p;
 const fromCurves$1 = (...curves) => new LinearPath2dImpl(curves);
 const fromCurveArray$1 = (curves) => new LinearPath2dImpl(curves);
-const append$1 = dual(
-  2,
-  (p, c) => fromCurveArray$1([...p, c])
-);
+const append$1 = dual(2, (p, c) => fromCurveArray$1([...p, c]));
 const length$1 = (p) => {
   let length2 = 0;
   for (const curve of p) {
@@ -53,3 +50,4 @@ const length = length$1;
 const solve = solve$1;
 
 export { append, fromCurveArray, fromCurves, isLinearPath2d, length, solve };
+//# sourceMappingURL=linear2d.mjs.map

package/dist/path/linear2d.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"linear2d.mjs","sources":["../../src/path/linear2d.internal.ts","../../src/path/linear2d.ts"],"sourcesContent":["import * as LinearCurve2d from '../curve/linear2d'\nimport * as Interval from '../interval'\nimport { Pipeable } from '../pipe'\nimport { dual } from '../pipe'\nimport { round } from '../utils'\nimport type { Vector2 } from '../vector/vector2'\nimport type { LinearPath2d } from './linear2d'\n\nexport const LinearPath2dTypeId: unique symbol = Symbol('curvy/path/linear2d')\nexport type LinearPath2dTypeId = typeof LinearPath2dTypeId\n\nexport class LinearPath2dImpl extends Pipeable implements LinearPath2d {\n  readonly [LinearPath2dTypeId]: LinearPath2dTypeId = LinearPath2dTypeId\n\n  readonly curves: ReadonlyArray<LinearCurve2d.LinearCurve2d>\n\n  constructor(curves: ReadonlyArray<LinearCurve2d.LinearCurve2d>) {\n    super()\n    this.curves = curves\n  }\n\n  [Symbol.iterator](): Iterator<LinearCurve2d.LinearCurve2d> {\n    return this.curves[Symbol.iterator]()\n  }\n}\n\nexport const isLinearPath2d = (p: unknown): p is LinearPath2d =>\n  typeof p === 'object' && p !== null && LinearPath2dTypeId in p\n\nexport const fromCurves = (...curves: ReadonlyArray<LinearCurve2d.LinearCurve2d>): LinearPath2d =>\n  new LinearPath2dImpl(curves)\n\nexport const fromCurveArray = (curves: ReadonlyArray<LinearCurve2d.LinearCurve2d>) =>\n  new LinearPath2dImpl(curves)\n\nexport const append = dual<\n  (c: LinearCurve2d.LinearCurve2d) => (p: LinearPath2d) => LinearPath2d,\n  (p: LinearPath2d, c: LinearCurve2d.LinearCurve2d) => LinearPath2d\n>(2, (p: LinearPath2d, c: LinearCurve2d.LinearCurve2d) => fromCurveArray([...p, c]))\n\nexport const length = (p: LinearPath2d) => {\n  let length = 0\n  for (const curve of p) {\n    length += LinearCurve2d.length(curve, Interval.unit)\n  }\n\n  return round(length)\n}\n\nexport const solve = dual<\n  (u: number) => (p: LinearPath2d) => Vector2,\n  (p: LinearPath2d, u: number) => Vector2\n>(2, (p: LinearPath2d, u: number) => {\n  const curves = p instanceof LinearPath2dImpl ? p.curves : [...p]\n\n  if (u === 1) {\n    const last = curves.at(-1) as LinearCurve2d.LinearCurve2d\n    return LinearCurve2d.solve(last, 1)\n  }\n\n  const t = u * curves.length\n  const i = Math.floor(t)\n  const curve = curves[i] as LinearCurve2d.LinearCurve2d\n  return LinearCurve2d.solve(curve, t - i)\n})\n","import type { LinearCurve2d } from '../curve/linear2d'\nimport type { Pipeable } from '../pipe'\nimport type { Vector2 } from '../vector/vector2'\nimport type { LinearPath2dTypeId } from './linear2d.internal'\nimport * as internal from './linear2d.internal'\n\n/**\n * A linear path in 2D space.\n *\n * All fields are readonly and immutable, and all operations create new instances.\n *\n * @since 1.0.0\n */\nexport interface LinearPath2d extends Pipeable, Iterable<LinearCurve2d> {\n  readonly [LinearPath2dTypeId]: LinearPath2dTypeId\n}\n\n/**\n * Creates a new `LinearPath2d` instance from curve parameters.\n *\n * @param curves - The curves to create the path from.\n * @returns A new `LinearPath2d` instance.\n * @since 1.0.0\n */\nexport const fromCurves: (...curves: ReadonlyArray<LinearCurve2d>) => LinearPath2d =\n  internal.fromCurves\n\n/**\n * Creates a new `LinearPath2d` instance from an array of curves.\n *\n * @param curves - The curves to create the path from.\n * @returns A new `LinearPath2d` instance.\n * @since 1.0.0\n */\nexport const fromCurveArray: (curves: ReadonlyArray<LinearCurve2d>) => LinearPath2d =\n  internal.fromCurveArray\n\n/**\n * Checks if a value is a `LinearPath2d`.\n *\n * @param p - The value to check.\n * @returns `true` if the value is a `LinearPath2d`, `false` otherwise.\n * @since 1.0.0\n */\nexport const isLinearPath2d: (p: unknown) => p is LinearPath2d = internal.isLinearPath2d\n\nexport const append: {\n  /**\n   * Appends a linear curve to a linear path.\n   *\n   * @param c - The linear curve to append.\n   * @returns A function that takes a linear path and returns a new linear path.\n   * @since 1.0.0\n   */\n  (c: LinearCurve2d): (p: LinearPath2d) => LinearPath2d\n  /**\n   * Appends a linear curve to a linear path.\n   *\n   * @param p - The linear path to append to.\n   * @param c - The linear curve to append.\n   * @returns A new `LinearPath2d` instance with the appended curve.\n   * @since 1.0.0\n   */\n  (p: LinearPath2d, c: LinearCurve2d): LinearPath2d\n} = internal.append\n\n/**\n * Calculates the length of a linear path.\n *\n * @param p - The linear path to calculate the length of.\n * @returns The length of the linear path.\n * @since 1.0.0\n */\nexport const length: (p: LinearPath2d) => number = internal.length\n\nexport const solve: {\n  /**\n   * Solves a linear path for a given parameter.\n   *\n   * @param u - The parameter to solve for.\n   * @returns A function that takes a linear path and returns the solved point.\n   * @since 1.0.0\n   */\n  (u: number): (p: LinearPath2d) => Vector2\n  /**\n   * Solves a linear path for a given parameter.\n   *\n   * @param p - The linear path to solve.\n   * @param u - The parameter to solve for.\n   * @returns The solved point on the linear path.\n   * @since 1.0.0\n   */\n  (p: LinearPath2d, u: number): Vector2\n} = internal.solve\n"],"names":["isLinearPath2d","fromCurves","fromCurveArray","append","length","LinearCurve2d.length","Interval.unit","solve","LinearCurve2d.solve","internal.fromCurves","internal.fromCurveArray","internal.isLinearPath2d","internal.append","internal.length","internal.solve"],"mappings":";;;;;;;;;AAAA,IAAA,EAAA;AAQa,MAAA,kBAAA,GAAoC,OAAO,qBAAqB,CAAA;AAGtE,MAAM,yBAAyB,QAAiC,CAAA;AAAA,EAKrE,YAAY,MAAoD,EAAA;AAC9D,IAAM,KAAA,EAAA;AALR,IAAA,IAAA,CAAU,EAA0C,CAAA,GAAA,kBAAA;AAMlD,IAAA,IAAA,CAAK,MAAS,GAAA,MAAA;AAAA;AAChB,EAEA,EATU,EAAA,GAAA,kBAAA,EAST,MAAO,CAAA,QAAA,EAAmD,GAAA;AACzD,IAAA,OAAO,IAAK,CAAA,MAAA,CAAO,MAAO,CAAA,QAAQ,CAAE,EAAA;AAAA;AAExC;AAEa,MAAAA,gBAAA,GAAiB,CAAC,CAC7B,KAAA,OAAO,MAAM,QAAY,IAAA,CAAA,KAAM,QAAQ,kBAAsB,IAAA,CAAA;AAExD,MAAMC,YAAa,GAAA,CAAA,GAAI,MAC5B,KAAA,IAAI,iBAAiB,MAAM,CAAA;AAEtB,MAAMC,gBAAiB,GAAA,CAAC,MAC7B,KAAA,IAAI,iBAAiB,MAAM,CAAA;AAEtB,MAAMC,QAAS,GAAA,IAAA,CAGpB,CAAG,EAAA,CAAC,CAAiB,EAAA,CAAA,KAAmCD,gBAAe,CAAA,CAAC,GAAG,CAAA,EAAG,CAAC,CAAC,CAAC,CAAA;AAEtE,MAAAE,QAAA,GAAS,CAAC,CAAoB,KAAA;AACzC,EAAA,IAAIA,OAAS,GAAA,CAAA;AACb,EAAA,KAAA,MAAW,SAAS,CAAG,EAAA;AACrB,IAAAA,OAAU,IAAAC,QAAqB,CAAA,KAAA,EAAOC,IAAa,CAAA;AAAA;AAGrD,EAAA,OAAO,MAAMF,OAAM,CAAA;AACrB,CAAA;AAEO,MAAMG,OAAQ,GAAA,IAAA,CAGnB,CAAG,EAAA,CAAC,GAAiB,CAAc,KAAA;AACnC,EAAA,MAAM,SAAS,CAAa,YAAA,gBAAA,GAAmB,EAAE,MAAS,GAAA,CAAC,GAAG,CAAC,CAAA;AAE/D,EAAA,IAAI,MAAM,CAAG,EAAA;AACX,IAAM,MAAA,IAAA,GAAO,MAAO,CAAA,EAAA,CAAG,EAAE,CAAA;AACzB,IAAO,OAAAC,OAAoB,CAAA,IAAA,EAAM,CAAC,CAAA;AAAA;AAGpC,EAAM,MAAA,CAAA,GAAI,IAAI,MAAO,CAAA,MAAA;AACrB,EAAM,MAAA,CAAA,GAAI,IAAK,CAAA,KAAA,CAAM,CAAC,CAAA;AACtB,EAAM,MAAA,KAAA,GAAQ,OAAO,CAAC,CAAA;AACtB,EAAA,OAAOA,OAAc,CAAM,KAAO,EAAA,CAAA,GAAI,CAAC,CAAA;AACzC,CAAC,CAAA;;ACxCM,MAAM,aACXC;AASK,MAAM,iBACXC;AASK,MAAM,iBAAoDC;AAE1D,MAAM,SAkBTC;AASG,MAAM,SAAsCC;AAE5C,MAAM,QAkBTC;;;;"}

package/dist/path/quadratic2d.d.mts

@@ -3,7 +3,7 @@ import { Pipeable } from '../pipe.mjs';
 import { Vector2 } from '../vector/vector2.mjs';
 import '../shared/curvy.Bf5TIk31.mjs';
 import '../interval.mjs';
-import '../shared/curvy.NsmY7zcr.mjs';
+import '../shared/curvy.FDaj5rlj.mjs';
 import '../vector/vector3.mjs';
 import '../vector/vector4.mjs';
 import '../curve/linear2d.mjs';
@@ -11,20 +11,85 @@ import '../curve/linear2d.mjs';
 declare const QuadraticPath2dTypeId: unique symbol;
 type QuadraticPath2dTypeId = typeof QuadraticPath2dTypeId;
 
+/**
+ * A quadratic path in 2D space.
+ *
+ * All fields are readonly and immutable, and all operations create new instances.
+ *
+ * @since 1.0.0
+ */
 interface QuadraticPath2d extends Pipeable, Iterable<QuadraticCurve2d> {
     readonly [QuadraticPath2dTypeId]: QuadraticPath2dTypeId;
 }
+/**
+ * Creates a new `QuadraticPath2d` instance from curve parameters.
+ *
+ * @param curves - The curves to create the path from.
+ * @returns A new `QuadraticPath2d` instance.
+ * @since 1.0.0
+ */
 declare const fromCurves: (...curves: ReadonlyArray<QuadraticCurve2d>) => QuadraticPath2d;
+/**
+ * Creates a new `QuadraticPath2d` instance from an array of curves.
+ *
+ * @param curves - The curves to create the path from.
+ * @returns A new `QuadraticPath2d` instance.
+ * @since 1.0.0
+ */
 declare const fromCurveArray: (curves: ReadonlyArray<QuadraticCurve2d>) => QuadraticPath2d;
+/**
+ * Checks if a value is a `QuadraticPath2d`.
+ *
+ * @param p - The value to check.
+ * @returns `true` if the value is a `QuadraticPath2d`, `false` otherwise.
+ * @since 1.0.0
+ */
 declare const isQuadraticPath2d: (p: unknown) => p is QuadraticPath2d;
 declare const append: {
+    /**
+     * Appends a quadratic curve to a quadratic path.
+     *
+     * @param c - The quadratic curve to append.
+     * @returns A function that takes a quadratic path and returns a new quadratic path.
+     * @since 1.0.0
+     */
     (c: QuadraticCurve2d): (p: QuadraticPath2d) => QuadraticPath2d;
+    /**
+     * Appends a quadratic curve to a quadratic path.
+     *
+     * @param p - The quadratic path to append to.
+     * @param c - The quadratic curve to append.
+     * @returns A new `QuadraticPath2d` instance with the appended curve.
+     * @since 1.0.0
+     */
     (p: QuadraticPath2d, c: QuadraticCurve2d): QuadraticPath2d;
 };
+/**
+ * Calculates the length of a quadratic path.
+ *
+ * @param p - The quadratic path to calculate the length of.
+ * @returns The length of the path.
+ */
 declare const length: (p: QuadraticPath2d) => number;
 declare const solve: {
+    /**
+     * Solves a quadratic path at a given parameter.
+     *
+     * @param u - The parameter to solve for.
+     * @returns A function that takes a quadratic path and returns the solved point.
+     * @since 1.0.0
+     */
     (u: number): (p: QuadraticPath2d) => Vector2;
+    /**
+     * Solves a quadratic path at a given parameter.
+     *
+     * @param p - The quadratic path to solve.
+     * @param u - The parameter to solve for.
+     * @returns The solved point.
+     * @since 1.0.0
+     */
     (p: QuadraticPath2d, u: number): Vector2;
 };
 
-export { type QuadraticPath2d, append, fromCurveArray, fromCurves, isQuadraticPath2d, length, solve };
+export { append, fromCurveArray, fromCurves, isQuadraticPath2d, length, solve };
+export type { QuadraticPath2d };