curvy 2.0.0-alpha.13 → 2.0.0-alpha.15

package/dist/shared/vector4.internal-DH5DzNYO.mjs

@@ -0,0 +1,116 @@
+import { Pipeable, dual } from "../utils.mjs";
+import { coincident } from "../number.mjs";
+//#region src/vector/vector4.internal.ts
+const Vector4TypeId = Symbol.for("curvy/vector4");
+var Vector4Impl = class extends Pipeable {
+	[Vector4TypeId] = Vector4TypeId;
+	x;
+	y;
+	z;
+	w;
+	constructor(v0 = 0, v1 = 0, v2 = 0, v3 = 0) {
+		super();
+		this.x = v0;
+		this.y = v1;
+		this.z = v2;
+		this.w = v3;
+	}
+	get [0]() {
+		return this.x;
+	}
+	get [1]() {
+		return this.y;
+	}
+	get [2]() {
+		return this.z;
+	}
+	get [3]() {
+		return this.w;
+	}
+	get [Symbol.toStringTag]() {
+		return `Vector4(${this.x}, ${this.y}, ${this.z}, ${this.w})`;
+	}
+	get [Symbol.for("nodejs.util.inspect.custom")]() {
+		return this[Symbol.toStringTag];
+	}
+};
+/** @internal */
+const isVector4 = (v) => typeof v === "object" && v !== null && Vector4TypeId in v;
+/** @internal */
+const equals = dual(2, (a, b) => coincident(a.x, b.x) && coincident(a.y, b.y) && coincident(a.z, b.z) && coincident(a.w, b.w));
+/** @internal */
+const make = (v0, v1 = v0, v2 = v1, v3 = v2) => new Vector4Impl(v0, v1, v2, v3);
+/** @internal */
+const fromTuple = (t) => new Vector4Impl(t[0], t[1], t[2], t[3]);
+/** @internal */
+const transpose = (inputs, project) => {
+	const a = project(inputs[0]);
+	const b = project(inputs[1]);
+	const c = project(inputs[2]);
+	const d = project(inputs[3]);
+	const result = [];
+	for (let i = 0; i < a.length; i++) result.push(make(a[i], b[i], c[i], d[i]));
+	return result;
+};
+/** @internal */
+const magnitude = (vector) => Math.hypot(vector.x, vector.y, vector.z, vector.w);
+/** @internal */
+const normalize = (vector) => {
+	const m = magnitude(vector);
+	return make(vector.x / m, vector.y / m, vector.z / m, vector.w / m);
+};
+/** @internal */
+const dot = dual(2, (a, b) => a.x * b.x + a.y * b.y + a.z * b.z + a.w * b.w);
+/** @internal */
+const components = (v) => [
+	v.x,
+	v.y,
+	v.z,
+	v.w
+];
+/** @internal */
+const softmax = (v) => {
+	const max = Math.max(v.x, v.y, v.z, v.w);
+	const v0 = Math.exp(v.x - max);
+	const v1 = Math.exp(v.y - max);
+	const v2 = Math.exp(v.z - max);
+	const v3 = Math.exp(v.w - max);
+	const sum = v0 + v1 + v2 + v3;
+	return make(v0 / sum, v1 / sum, v2 / sum, v3 / sum);
+};
+/** @internal */
+const add = dual(2, (a, b) => make(a.x + b.x, a.y + b.y, a.z + b.z, a.w + b.w));
+/** @internal */
+const subtract = dual(2, (a, b) => make(a.x - b.x, a.y - b.y, a.z - b.z, a.w - b.w));
+/** @internal */
+const hadamard = dual(2, (a, b) => make(a.x * b.x, a.y * b.y, a.z * b.z, a.w * b.w));
+/** @internal */
+const scale = dual(2, (v, s) => s === 1 ? v : make(v.x * s, v.y * s, v.z * s, v.w * s));
+/** @internal */
+const getX = (v) => v.x;
+/** @internal */
+const setX = dual(2, (v, x) => make(x, v.y, v.z, v.w));
+/** @internal */
+const mapX = dual(2, (v, f) => make(f(v.x), v.y, v.z, v.w));
+/** @internal */
+const getY = (v) => v.y;
+/** @internal */
+const setY = dual(2, (v, y) => make(v.x, y, v.z, v.w));
+/** @internal */
+const mapY = dual(2, (v, f) => make(v.x, f(v.y), v.z, v.w));
+/** @internal */
+const getZ = (v) => v.z;
+/** @internal */
+const setZ = dual(2, (v, z) => make(v.x, v.y, z, v.w));
+/** @internal */
+const mapZ = dual(2, (v, f) => make(v.x, v.y, f(v.z), v.w));
+/** @internal */
+const getW = (v) => v.w;
+/** @internal */
+const setW = dual(2, (v, w) => make(v.x, v.y, v.z, w));
+/** @internal */
+const mapW = dual(2, (v, f) => make(v.x, v.y, v.z, f(v.w)));
+//#endregion
+export { setZ as C, transpose as E, setY as S, subtract as T, mapZ as _, fromTuple as a, setW as b, getY as c, isVector4 as d, magnitude as f, mapY as g, mapX as h, equals as i, getZ as l, mapW as m, components as n, getW as o, make as p, dot as r, getX as s, add as t, hadamard as u, normalize as v, softmax as w, setX as x, scale as y };
+
+//# sourceMappingURL=vector4.internal-DH5DzNYO.mjs.map

package/dist/shared/vector4.internal-DH5DzNYO.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"vector4.internal-DH5DzNYO.mjs","names":[],"sources":["../../src/vector/vector4.internal.ts"],"sourcesContent":["import { dual, Pipeable } from '../utils.ts'\nimport { coincident } from '../number.ts'\nimport type { Vector4 } from './vector4.ts'\n\nexport const Vector4TypeId: unique symbol = Symbol.for('curvy/vector4')\nexport type Vector4TypeId = typeof Vector4TypeId\n\nclass Vector4Impl extends Pipeable implements Vector4 {\n  readonly [Vector4TypeId]: Vector4TypeId = Vector4TypeId\n\n  readonly x: number\n  readonly y: number\n  readonly z: number\n  readonly w: number\n\n  constructor(v0 = 0, v1 = 0, v2 = 0, v3 = 0) {\n    super()\n\n    this.x = v0\n    this.y = v1\n    this.z = v2\n    this.w = v3\n  }\n\n  get [0]() {\n    return this.x\n  }\n\n  get [1]() {\n    return this.y\n  }\n\n  get [2]() {\n    return this.z\n  }\n\n  get [3]() {\n    return this.w\n  }\n\n  get [Symbol.toStringTag]() {\n    return `Vector4(${this.x}, ${this.y}, ${this.z}, ${this.w})`\n  }\n\n  get [Symbol.for('nodejs.util.inspect.custom')]() {\n    return this[Symbol.toStringTag]\n  }\n}\n\n/** @internal */\nexport const isVector4 = (v: unknown): v is Vector4 =>\n  typeof v === 'object' && v !== null && Vector4TypeId in v\n\n/** @internal */\nexport const equals = dual<\n  (b: Vector4) => (a: Vector4) => boolean,\n  (a: Vector4, b: Vector4) => boolean\n>(\n  2,\n  (a: Vector4, b: Vector4) =>\n    coincident(a.x, b.x) && coincident(a.y, b.y) && coincident(a.z, b.z) && coincident(a.w, b.w),\n)\n\n/** @internal */\nexport const make = (v0: number, v1 = v0, v2 = v1, v3 = v2): Vector4 =>\n  new Vector4Impl(v0, v1, v2, v3)\n\n/** @internal */\nexport const fromTuple = (t: readonly [number, number, number, number]): Vector4 =>\n  new Vector4Impl(t[0], t[1], t[2], t[3])\n\n/** @internal */\nexport const transpose = <T, const Channels extends ReadonlyArray<number>>(\n  inputs: readonly [T, T, T, T],\n  project: (item: T) => Channels,\n): { readonly [K in keyof Channels]: Vector4 } => {\n  const a = project(inputs[0])\n  const b = project(inputs[1])\n  const c = project(inputs[2])\n  const d = project(inputs[3])\n  const result: Array<Vector4> = []\n  for (let i = 0; i < a.length; i++) {\n    result.push(make(a[i] as number, b[i] as number, c[i] as number, d[i] as number))\n  }\n  return result as never\n}\n\n/** @internal */\nexport const magnitude: (vector: Vector4) => number = (vector: Vector4) =>\n  Math.hypot(vector.x, vector.y, vector.z, vector.w)\n\n/** @internal */\nexport const normalize: (vector: Vector4) => Vector4 = (vector: Vector4) => {\n  const m = magnitude(vector)\n\n  return make(vector.x / m, vector.y / m, vector.z / m, vector.w / m)\n}\n\n/** @internal */\nexport const dot = dual<(b: Vector4) => (a: Vector4) => number, (a: Vector4, b: Vector4) => number>(\n  2,\n  (a: Vector4, b: Vector4) => a.x * b.x + a.y * b.y + a.z * b.z + a.w * b.w,\n)\n\n/** @internal */\nexport const components: (v: Vector4) => [number, number, number, number] = (v: Vector4) => [\n  v.x,\n  v.y,\n  v.z,\n  v.w,\n]\n\n/** @internal */\nexport const softmax: (v: Vector4) => Vector4 = (v: Vector4) => {\n  const max = Math.max(v.x, v.y, v.z, v.w)\n\n  const v0 = Math.exp(v.x - max)\n  const v1 = Math.exp(v.y - max)\n  const v2 = Math.exp(v.z - max)\n  const v3 = Math.exp(v.w - max)\n\n  const sum = v0 + v1 + v2 + v3\n\n  return make(v0 / sum, v1 / sum, v2 / sum, v3 / sum)\n}\n\n/** @internal */\nexport const add = dual<\n  (b: Vector4) => (a: Vector4) => Vector4,\n  (a: Vector4, b: Vector4) => Vector4\n>(2, (a: Vector4, b: Vector4) => make(a.x + b.x, a.y + b.y, a.z + b.z, a.w + b.w))\n\n/** @internal */\nexport const subtract = dual<\n  (b: Vector4) => (a: Vector4) => Vector4,\n  (a: Vector4, b: Vector4) => Vector4\n>(2, (a: Vector4, b: Vector4) => make(a.x - b.x, a.y - b.y, a.z - b.z, a.w - b.w))\n\n/** @internal */\nexport const hadamard = dual<\n  (b: Vector4) => (a: Vector4) => Vector4,\n  (a: Vector4, b: Vector4) => Vector4\n>(2, (a: Vector4, b: Vector4) => make(a.x * b.x, a.y * b.y, a.z * b.z, a.w * b.w))\n/** @internal */\nexport const scale = dual<\n  (s: number) => (v: Vector4) => Vector4,\n  (v: Vector4, s: number) => Vector4\n>(2, (v: Vector4, s: number) => (s === 1 ? v : make(v.x * s, v.y * s, v.z * s, v.w * s)))\n\n/** @internal */\nexport const getX = (v: Vector4) => v.x\n/** @internal */\nexport const setX = dual<\n  (x: number) => (v: Vector4) => Vector4,\n  (v: Vector4, x: number) => Vector4\n>(2, (v: Vector4, x: number) => make(x, v.y, v.z, v.w))\n/** @internal */\nexport const mapX = dual<\n  (f: (x: number) => number) => (v: Vector4) => Vector4,\n  (v: Vector4, f: (x: number) => number) => Vector4\n>(2, (v: Vector4, f: (x: number) => number) => make(f(v.x), v.y, v.z, v.w))\n\n/** @internal */\nexport const getY = (v: Vector4) => v.y\n/** @internal */\nexport const setY = dual<\n  (y: number) => (v: Vector4) => Vector4,\n  (v: Vector4, y: number) => Vector4\n>(2, (v: Vector4, y: number) => make(v.x, y, v.z, v.w))\n/** @internal */\nexport const mapY = dual<\n  (f: (y: number) => number) => (v: Vector4) => Vector4,\n  (v: Vector4, f: (y: number) => number) => Vector4\n>(2, (v: Vector4, f: (y: number) => number) => make(v.x, f(v.y), v.z, v.w))\n\n/** @internal */\nexport const getZ = (v: Vector4) => v.z\n/** @internal */\nexport const setZ = dual<\n  (z: number) => (v: Vector4) => Vector4,\n  (v: Vector4, z: number) => Vector4\n>(2, (v: Vector4, z: number) => make(v.x, v.y, z, v.w))\n/** @internal */\nexport const mapZ = dual<\n  (f: (z: number) => number) => (v: Vector4) => Vector4,\n  (v: Vector4, f: (z: number) => number) => Vector4\n>(2, (v: Vector4, f: (z: number) => number) => make(v.x, v.y, f(v.z), v.w))\n\n/** @internal */\nexport const getW = (v: Vector4) => v.w\n/** @internal */\nexport const setW = dual<\n  (w: number) => (v: Vector4) => Vector4,\n  (v: Vector4, w: number) => Vector4\n>(2, (v: Vector4, w: number) => make(v.x, v.y, v.z, w))\n/** @internal */\nexport const mapW = dual<\n  (f: (w: number) => number) => (v: Vector4) => Vector4,\n  (v: Vector4, f: (w: number) => number) => Vector4\n>(2, (v: Vector4, f: (w: number) => number) => make(v.x, v.y, v.z, f(v.w)))\n"],"mappings":"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"}

package/dist/solution/index.mjs

@@ -1,2 +1,2 @@
-import { c as solution_exports } from "../shared/solution-B2JdOZpe.mjs";
+import { l as solution_exports } from "../shared/solution-BW0BBMXI.mjs";
 export { solution_exports as Solution };

package/dist/solution/solution.d.ts

@@ -221,6 +221,22 @@ export declare const clip: {
     (i: Interval): (s: Solution<number>) => Solution<number>;
     (s: Solution<number>, i: Interval): Solution<number>;
 };
+/**
+ * Approximate-containment variant of {@link clip} for post-processing the
+ * output of a numerical solver. Retains values within a small absolute
+ * tolerance of either boundary even if formally outside — a valid root can
+ * land a few ULPs past the boundary due to coefficient roundoff in the
+ * solver, and strict {@link clip} would drop it. Endpoint inclusivity is
+ * ignored at the EPSILON scale.
+ *
+ * @param s - The solution to clip.
+ * @param i - The interval to retain values approximately within.
+ * @since 2.0.0
+ */
+export declare const clipApprox: {
+    (i: Interval): (s: Solution<number>) => Solution<number>;
+    (s: Solution<number>, i: Interval): Solution<number>;
+};
 /**
  * Maps every value in the solution to a new value. Result cardinality matches
  * the input.

package/dist/splines/basis2d.d.ts

@@ -1,4 +1,5 @@
 import type { CubicPath2d } from '../path/cubic2d.ts';
+import type { Affine2d } from '../transform/affine2d.ts';
 import type { Pipeable } from '../utils.ts';
 import type { Vector2 } from '../vector/vector2.ts';
 import type { Basis2dTypeId } from './basis2d.internal.ts';
@@ -90,6 +91,69 @@ export declare const prepend: {
      */
     (p: Basis2d, ...points: ReadonlyArray<Vector2>): Basis2d;
 };
+export declare const mapPoints: {
+    /**
+     * Applies a per-point transform to every control point in a `Basis2d`,
+     * preserving point count and spline identity.
+     *
+     * @param f - The point transform.
+     * @returns A function that takes a `Basis2d` and returns the mapped spline.
+     * @since 2.0.0
+     */
+    (f: (p: Vector2) => Vector2): (s: Basis2d) => Basis2d;
+    /**
+     * Applies a per-point transform to every control point in a `Basis2d`.
+     *
+     * @param s - The basis spline.
+     * @param f - The point transform.
+     * @returns A new `Basis2d` with the transform applied to each control point.
+     * @since 2.0.0
+     */
+    (s: Basis2d, f: (p: Vector2) => Vector2): Basis2d;
+};
+export declare const flatMap: {
+    /**
+     * Hands the spline's full control-point array to `f` and uses its returned
+     * `Basis2d` as the result. The returned spline goes through this module's
+     * builders, so the 4-or-more-points invariant is enforced at construction.
+     *
+     * @param f - The bulk transform.
+     * @returns A function that takes a `Basis2d` and returns the rebuilt spline.
+     * @since 2.0.0
+     */
+    (f: (points: ReadonlyArray<Vector2>) => Basis2d): (s: Basis2d) => Basis2d;
+    /**
+     * Hands the spline's full control-point array to `f` and uses its returned
+     * `Basis2d` as the result.
+     *
+     * @param s - The basis spline.
+     * @param f - The bulk transform.
+     * @returns The `Basis2d` returned by `f`.
+     * @since 2.0.0
+     */
+    (s: Basis2d, f: (points: ReadonlyArray<Vector2>) => Basis2d): Basis2d;
+};
+export declare const transform: {
+    /**
+     * Applies an `Affine2d` transform to every control point of a `Basis2d`.
+     * Affine maps commute with the B-spline basis, so the result exactly
+     * parameterizes the affine image of the original curve.
+     *
+     * @param s - The basis spline.
+     * @param a - The affine transform.
+     * @returns A new `Basis2d` whose control points are the affine images of the input's.
+     * @since 2.0.0
+     */
+    (s: Basis2d, a: Affine2d): Basis2d;
+    /**
+     * Applies an `Affine2d` transform to every control point of a `Basis2d`.
+     *
+     * @param a - The affine transform.
+     * @returns A function that takes a `Basis2d` and returns the transformed spline.
+     * @since 2.0.0
+     */
+    (a: Affine2d): (s: Basis2d) => Basis2d;
+};
 /**
  * Triplicates the endpoints of a `Basis2d`.
  *

package/dist/splines/bezier2d.d.ts

@@ -1,4 +1,5 @@
 import type { CubicPath2d } from '../path/cubic2d.ts';
+import type { Affine2d } from '../transform/affine2d.ts';
 import type { Pipeable } from '../utils.ts';
 import type * as Solution from '../solution/solution.ts';
 import type { Vector2 } from '../vector/vector2.ts';
@@ -153,6 +154,77 @@ export declare const appendAccelerationAligned: {
      */
     (p: Bezier2d, p3: Vector2): Bezier2d;
 };
+export declare const mapPoints: {
+    /**
+     * Applies a per-point transform to every control point in a `Bezier2d`,
+     * preserving point count and spline identity.
+     *
+     * Note that the transform is applied uniformly to all control points,
+     * including off-curve handles. Affine maps (translate, rotate, scale, shear)
+     * commute with cubic Bézier evaluation and preserve curve identity up to
+     * the affine map; nonlinear maps produce a geometrically reasonable result
+     * but no longer parameterize the affine image of the original curve.
+     *
+     * @param f - The point transform.
+     * @returns A function that takes a `Bezier2d` and returns the mapped spline.
+     * @since 2.0.0
+     */
+    (f: (p: Vector2) => Vector2): (s: Bezier2d) => Bezier2d;
+    /**
+     * Applies a per-point transform to every control point in a `Bezier2d`.
+     *
+     * @param s - The bezier.
+     * @param f - The point transform.
+     * @returns A new `Bezier2d` with the transform applied to each control point.
+     * @since 2.0.0
+     */
+    (s: Bezier2d, f: (p: Vector2) => Vector2): Bezier2d;
+};
+export declare const flatMap: {
+    /**
+     * Hands the bezier's full control-point array to `f` and uses its returned
+     * `Bezier2d` as the result. The returned bezier goes through this module's
+     * builders, so the `3n + 1` point-count invariant is enforced at
+     * construction.
+     *
+     * @param f - The bulk transform.
+     * @returns A function that takes a `Bezier2d` and returns the rebuilt spline.
+     * @since 2.0.0
+     */
+    (f: (points: ReadonlyArray<Vector2>) => Bezier2d): (s: Bezier2d) => Bezier2d;
+    /**
+     * Hands the bezier's full control-point array to `f` and uses its returned
+     * `Bezier2d` as the result.
+     *
+     * @param s - The bezier.
+     * @param f - The bulk transform.
+     * @returns The `Bezier2d` returned by `f`.
+     * @since 2.0.0
+     */
+    (s: Bezier2d, f: (points: ReadonlyArray<Vector2>) => Bezier2d): Bezier2d;
+};
+export declare const transform: {
+    /**
+     * Applies an `Affine2d` transform to every control point of a `Bezier2d`.
+     * Affine maps commute with Bézier evaluation, so the result exactly
+     * parameterizes the affine image of the original curve.
+     *
+     * @param s - The bezier.
+     * @param a - The affine transform.
+     * @returns A new `Bezier2d` whose control points are the affine images of
+     *   the input's.
+     * @since 2.0.0
+     */
+    (s: Bezier2d, a: Affine2d): Bezier2d;
+    /**
+     * Applies an `Affine2d` transform to every control point of a `Bezier2d`.
+     *
+     * @param a - The affine transform.
+     * @returns A function that takes a `Bezier2d` and returns the transformed bezier.
+     * @since 2.0.0
+     */
+    (a: Affine2d): (s: Bezier2d) => Bezier2d;
+};
 /**
  * Converts a `Bezier2d` to a `CubicPath2d`.
  *

package/dist/splines/cardinal2d.d.ts

@@ -1,4 +1,5 @@
 import type { CubicPath2d } from '../path/cubic2d.ts';
+import type { Affine2d } from '../transform/affine2d.ts';
 import type { Pipeable } from '../utils.ts';
 import type { Vector2 } from '../vector/vector2.ts';
 import type { Bezier2d } from './bezier2d.ts';
@@ -244,6 +245,83 @@ export declare const withOptions: {
      */
     (c: Cardinal2d, options: Options): Cardinal2d;
 };
+export declare const mapPoints: {
+    /**
+     * Applies a per-point transform to every control point in a `Cardinal2d`,
+     * preserving point count, tension, and alpha.
+     *
+     * @param f - The point transform.
+     * @returns A function that takes a `Cardinal2d` and returns the mapped spline.
+     * @since 2.0.0
+     */
+    (f: (p: Vector2) => Vector2): (s: Cardinal2d) => Cardinal2d;
+    /**
+     * Applies a per-point transform to every control point in a `Cardinal2d`.
+     *
+     * @param s - The cardinal spline.
+     * @param f - The point transform.
+     * @returns A new `Cardinal2d` with the transform applied to each control point.
+     * @since 2.0.0
+     */
+    (s: Cardinal2d, f: (p: Vector2) => Vector2): Cardinal2d;
+};
+export declare const flatMap: {
+    /**
+     * Hands the spline's full control-point array to `f` and uses its returned
+     * `Cardinal2d` as the result. The returned spline's tension and alpha come
+     * from the mapper's output, not the input — to preserve the input's
+     * parameterization, the mapper should re-supply it (e.g. by reading the
+     * original spline in the data-first form, or chaining `withOptions`
+     * afterward).
+     *
+     * @param f - The bulk transform.
+     * @returns A function that takes a `Cardinal2d` and returns the rebuilt spline.
+     * @since 2.0.0
+     */
+    (f: (points: ReadonlyArray<Vector2>) => Cardinal2d): (s: Cardinal2d) => Cardinal2d;
+    /**
+     * Hands the spline's full control-point array to `f` and uses its returned
+     * `Cardinal2d` as the result.
+     *
+     * @param s - The cardinal spline.
+     * @param f - The bulk transform.
+     * @returns The `Cardinal2d` returned by `f`.
+     * @since 2.0.0
+     */
+    (s: Cardinal2d, f: (points: ReadonlyArray<Vector2>) => Cardinal2d): Cardinal2d;
+};
+export declare const transform: {
+    /**
+     * Applies an `Affine2d` transform to every control point of a `Cardinal2d`,
+     * preserving the spline's `tension` and `alpha`.
+     *
+     * **Exactness depends on parameterization.** With `alpha = 0` (uniform
+     * Catmull-Rom) the affine basis commutes exactly with evaluation, so the
+     * result parameterizes the affine image of the original curve. With
+     * `alpha != 0` (centripetal / chordal), chord lengths between control points
+     * drive the parameterization and a non-uniform-scaling transform changes
+     * those chord lengths in axis-dependent ways. In that case the returned
+     * curve is still a sensible Cardinal spline on the transformed control
+     * points, but it no longer matches the affine image of the original
+     * pointwise. For pixel-exact transforms of centripetal splines, convert to
+     * `Bezier2d` via {@link toBezier} first, then transform.
+     *
+     * @param s - The cardinal spline.
+     * @param a - The affine transform.
+     * @returns A new `Cardinal2d` whose control points are the affine images of
+     *   the input's, with the same parameterization.
+     * @since 2.0.0
+     */
+    (s: Cardinal2d, a: Affine2d): Cardinal2d;
+    /**
+     * Applies an `Affine2d` transform to every control point of a `Cardinal2d`.
+     *
+     * @param a - The affine transform.
+     * @returns A function that takes a `Cardinal2d` and returns the transformed spline.
+     * @since 2.0.0
+     */
+    (a: Affine2d): (s: Cardinal2d) => Cardinal2d;
+};
 /**
  * Converts a `Cardinal2d` to a `CubicPath2d` using the spline's `tension` and
  * `alpha`. With the default options (`{ tension: 0.5, alpha: 0.5 }`) the

package/dist/splines/hermite2d.d.ts

@@ -1,4 +1,5 @@
 import type { CubicPath2d } from '../path/cubic2d.ts';
+import type { Affine2d } from '../transform/affine2d.ts';
 import type { Pipeable } from '../utils.ts';
 import type { Vector2 } from '../vector/vector2.ts';
 import type { Bezier2d } from './bezier2d.ts';
@@ -95,6 +96,81 @@ export declare const prepend: {
      */
     (p: Hermite2d, p0: Vector2, v0: Vector2): Hermite2d;
 };
+export declare const mapPoints: {
+    /**
+     * Applies a per-point transform to every entry in a `Hermite2d`, preserving
+     * the alternating position/velocity layout and total point count.
+     *
+     * The transform receives both positions and velocity vectors as plain
+     * `Vector2`s — Hermite splines store them in interleaved slots without a
+     * structural distinction. Linear transforms (rotation, scaling) act
+     * correctly on both slot kinds, but a uniform translation will offset the
+     * velocity slots as well as the positions; to translate positions only,
+     * reach for {@link flatMap} and split the array yourself.
+     *
+     * @param f - The point transform.
+     * @returns A function that takes a `Hermite2d` and returns the mapped spline.
+     * @since 2.0.0
+     */
+    (f: (p: Vector2) => Vector2): (s: Hermite2d) => Hermite2d;
+    /**
+     * Applies a per-point transform to every entry in a `Hermite2d`.
+     *
+     * @param s - The hermite spline.
+     * @param f - The point transform.
+     * @returns A new `Hermite2d` with the transform applied to each entry.
+     * @since 2.0.0
+     */
+    (s: Hermite2d, f: (p: Vector2) => Vector2): Hermite2d;
+};
+export declare const flatMap: {
+    /**
+     * Hands the spline's full entry array to `f` (alternating positions and
+     * velocities) and uses its returned `Hermite2d` as the result. The returned
+     * spline goes through this module's builders, so the even-arity and
+     * minimum-4-entry invariants are enforced at construction.
+     *
+     * @param f - The bulk transform.
+     * @returns A function that takes a `Hermite2d` and returns the rebuilt spline.
+     * @since 2.0.0
+     */
+    (f: (points: ReadonlyArray<Vector2>) => Hermite2d): (s: Hermite2d) => Hermite2d;
+    /**
+     * Hands the spline's full entry array to `f` and uses its returned
+     * `Hermite2d` as the result.
+     *
+     * @param s - The hermite spline.
+     * @param f - The bulk transform.
+     * @returns The `Hermite2d` returned by `f`.
+     * @since 2.0.0
+     */
+    (s: Hermite2d, f: (points: ReadonlyArray<Vector2>) => Hermite2d): Hermite2d;
+};
+export declare const transform: {
+    /**
+     * Applies an `Affine2d` transform to a `Hermite2d`, treating the entries
+     * correctly by kind: positions (even indices) receive the full affine, and
+     * tangent vectors (odd indices) receive only the linear part — translation
+     * doesn't move tangents, only the linear map does.
+     *
+     * The result exactly parameterizes the affine image of the original curve.
+     *
+     * @param s - The hermite spline.
+     * @param a - The affine transform.
+     * @returns A new `Hermite2d` with positions and tangents transformed
+     *   appropriately.
+     * @since 2.0.0
+     */
+    (s: Hermite2d, a: Affine2d): Hermite2d;
+    /**
+     * Applies an `Affine2d` transform to a `Hermite2d`.
+     *
+     * @param a - The affine transform.
+     * @returns A function that takes a `Hermite2d` and returns the transformed spline.
+     * @since 2.0.0
+     */
+    (a: Affine2d): (s: Hermite2d) => Hermite2d;
+};
 /**
  * Creates a new `CubicPath2d` instance from a `Hermite2d`.
  *