curvy 2.0.0-alpha.13 → 2.0.0-alpha.14

package/dist/shared/vector3.internal-CfWHl9SG.mjs

@@ -0,0 +1,135 @@
+import { Pipeable, dual } from "../utils.mjs";
+import { coincident } from "../number.mjs";
+//#region src/vector/vector3.internal.ts
+const Vector3TypeId = Symbol.for("curvy/vector3");
+var Vector3Impl = class extends Pipeable {
+	[Vector3TypeId] = Vector3TypeId;
+	x;
+	y;
+	z;
+	constructor(v0 = 0, v1 = 0, v2 = 0) {
+		super();
+		this.x = v0;
+		this.y = v1;
+		this.z = v2;
+	}
+	get [0]() {
+		return this.x;
+	}
+	get [1]() {
+		return this.y;
+	}
+	get [2]() {
+		return this.z;
+	}
+	get [Symbol.toStringTag]() {
+		return `Vector3(${this.x}, ${this.y}, ${this.z})`;
+	}
+	get [Symbol.for("nodejs.util.inspect.custom")]() {
+		return this[Symbol.toStringTag];
+	}
+};
+/** @internal */
+const isVector3 = (v) => typeof v === "object" && v !== null && Vector3TypeId in v;
+/** @internal */
+const equals = dual(2, (a, b) => coincident(a.x, b.x) && coincident(a.y, b.y) && coincident(a.z, b.z));
+/** @internal */
+const make = (v0, v1 = v0, v2 = v1) => new Vector3Impl(v0, v1, v2);
+/** @internal */
+const fromTuple = (t) => new Vector3Impl(t[0], t[1], t[2]);
+/** @internal */
+const transpose = (inputs, project) => {
+	const a = project(inputs[0]);
+	const b = project(inputs[1]);
+	const c = project(inputs[2]);
+	const result = [];
+	for (let i = 0; i < a.length; i++) result.push(make(a[i], b[i], c[i]));
+	return result;
+};
+/** @internal */
+const fromSpherical = (r, theta, phi) => new Vector3Impl(r * Math.sin(theta) * Math.cos(phi), r * Math.sin(theta) * Math.sin(phi), r * Math.cos(theta));
+/** @internal */
+const magnitude = (vector) => Math.hypot(vector.x, vector.y, vector.z);
+/** @internal */
+const normalize = (vector) => {
+	const m = magnitude(vector);
+	return make(vector.x / m, vector.y / m, vector.z / m);
+};
+/** @internal */
+const dot = dual(2, (a, b) => a.x * b.x + a.y * b.y + a.z * b.z);
+/** @internal */
+const cross = dual(2, (a, b) => {
+	return make(a.y * b.z - a.z * b.y, a.z * b.x - a.x * b.z, a.x * b.y - a.y * b.x);
+});
+/** @internal */
+const components = (v) => [
+	v.x,
+	v.y,
+	v.z
+];
+/** @internal */
+const softmax = (v) => {
+	const max = Math.max(v.x, v.y, v.z);
+	const v0 = Math.exp(v.x - max);
+	const v1 = Math.exp(v.y - max);
+	const v2 = Math.exp(v.z - max);
+	const sum = v0 + v1 + v2;
+	return make(v0 / sum, v1 / sum, v2 / sum);
+};
+/** @internal */
+const add = dual(2, (a, b) => make(a.x + b.x, a.y + b.y, a.z + b.z));
+/** @internal */
+const subtract = dual(2, (a, b) => make(a.x - b.x, a.y - b.y, a.z - b.z));
+/** @internal */
+const hadamard = dual(2, (a, b) => make(a.x * b.x, a.y * b.y, a.z * b.z));
+/** @internal */
+const scale = dual(2, (v, s) => s === 1 ? v : make(v.x * s, v.y * s, v.z * s));
+/** @internal */
+const getX = (v) => v.x;
+/** @internal */
+const setX = dual(2, (v, x) => make(x, v.y, v.z));
+/** @internal */
+const mapX = dual(2, (v, f) => make(f(v.x), v.y, v.z));
+/** @internal */
+const getY = (v) => v.y;
+/** @internal */
+const setY = dual(2, (v, y) => make(v.x, y, v.z));
+/** @internal */
+const mapY = dual(2, (v, f) => make(v.x, f(v.y), v.z));
+/** @internal */
+const getZ = (v) => v.z;
+/** @internal */
+const setZ = dual(2, (v, z) => make(v.x, v.y, z));
+/** @internal */
+const mapZ = dual(2, (v, f) => make(v.x, v.y, f(v.z)));
+/** @internal */
+const setR = dual(2, (v, r) => scale(r / magnitude(v))(v));
+/** @internal */
+const mapR = dual(2, (v, f) => {
+	const r = magnitude(v);
+	return scale(f(r) / r)(v);
+});
+/** @internal */
+const getTheta = (v) => Math.acos(v.z / magnitude(v));
+/** @internal */
+const setTheta = dual(2, (v, theta) => {
+	const r = magnitude(v);
+	const phi = Math.atan2(v.y, v.x);
+	const sinTheta = Math.sin(theta);
+	return make(r * sinTheta * Math.cos(phi), r * sinTheta * Math.sin(phi), r * Math.cos(theta));
+});
+/** @internal */
+const mapTheta = dual(2, (v, f) => setTheta(v, f(getTheta(v))));
+/** @internal */
+const getPhi = (v) => Math.atan2(v.y, v.x);
+/** @internal */
+const setPhi = dual(2, (v, phi) => {
+	const rho = Math.hypot(v.x, v.y);
+	return make(rho * Math.cos(phi), rho * Math.sin(phi), v.z);
+});
+/** @internal */
+const mapPhi = dual(2, (v, f) => setPhi(v, f(getPhi(v))));
+//#endregion
+export { setZ as A, normalize as C, setTheta as D, setR as E, subtract as M, transpose as N, setX as O, mapZ as S, setPhi as T, mapPhi as _, equals as a, mapX as b, getPhi as c, getY as d, getZ as f, make as g, magnitude as h, dot as i, softmax as j, setY as k, getTheta as l, isVector3 as m, components as n, fromSpherical as o, hadamard as p, cross as r, fromTuple as s, add as t, getX as u, mapR as v, scale as w, mapY as x, mapTheta as y };
+
+//# sourceMappingURL=vector3.internal-CfWHl9SG.mjs.map

package/dist/shared/vector3.internal-CfWHl9SG.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"vector3.internal-CfWHl9SG.mjs","names":[],"sources":["../../src/vector/vector3.internal.ts"],"sourcesContent":["import { dual, Pipeable } from '../utils.ts'\nimport { coincident } from '../number.ts'\nimport type { Vector3 } from './vector3.ts'\n\nexport const Vector3TypeId: unique symbol = Symbol.for('curvy/vector3')\nexport type Vector3TypeId = typeof Vector3TypeId\n\nclass Vector3Impl extends Pipeable implements Vector3 {\n  readonly [Vector3TypeId]: Vector3TypeId = Vector3TypeId\n\n  readonly x: number\n  readonly y: number\n  readonly z: number\n\n  constructor(v0 = 0, v1 = 0, v2 = 0) {\n    super()\n    this.x = v0\n    this.y = v1\n    this.z = v2\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 [Symbol.toStringTag]() {\n    return `Vector3(${this.x}, ${this.y}, ${this.z})`\n  }\n\n  get [Symbol.for('nodejs.util.inspect.custom')]() {\n    return this[Symbol.toStringTag]\n  }\n}\n\n/** @internal */\nexport const isVector3 = (v: unknown): v is Vector3 =>\n  typeof v === 'object' && v !== null && Vector3TypeId in v\n\n/** @internal */\nexport const equals = dual<\n  (b: Vector3) => (a: Vector3) => boolean,\n  (a: Vector3, b: Vector3) => boolean\n>(\n  2,\n  (a: Vector3, b: Vector3) => coincident(a.x, b.x) && coincident(a.y, b.y) && coincident(a.z, b.z),\n)\n\n/** @internal */\nexport const make = (v0: number, v1 = v0, v2 = v1): Vector3 => new Vector3Impl(v0, v1, v2)\n\n/** @internal */\nexport const fromTuple = (t: readonly [number, number, number]): Vector3 =>\n  new Vector3Impl(t[0], t[1], t[2])\n\n/** @internal */\nexport const transpose = <T, const Channels extends ReadonlyArray<number>>(\n  inputs: readonly [T, T, T],\n  project: (item: T) => Channels,\n): { readonly [K in keyof Channels]: Vector3 } => {\n  const a = project(inputs[0])\n  const b = project(inputs[1])\n  const c = project(inputs[2])\n  const result: Array<Vector3> = []\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))\n  }\n  return result as never\n}\n\n/** @internal */\nexport const fromSpherical = (r: number, theta: number, phi: number) =>\n  new Vector3Impl(\n    r * Math.sin(theta) * Math.cos(phi),\n    r * Math.sin(theta) * Math.sin(phi),\n    r * Math.cos(theta),\n  )\n\n/** @internal */\nexport const magnitude = (vector: Vector3) => Math.hypot(vector.x, vector.y, vector.z)\n\n/** @internal */\nexport const normalize = (vector: Vector3) => {\n  const m = magnitude(vector)\n\n  return make(vector.x / m, vector.y / m, vector.z / m)\n}\n\n/** @internal */\nexport const dot = dual<(b: Vector3) => (a: Vector3) => number, (a: Vector3, b: Vector3) => number>(\n  2,\n  (a: Vector3, b: Vector3) => a.x * b.x + a.y * b.y + a.z * b.z,\n)\n\n/** @internal */\nexport const cross = dual<\n  (b: Vector3) => (a: Vector3) => Vector3,\n  (a: Vector3, b: Vector3) => Vector3\n>(2, (a: Vector3, b: Vector3) => {\n  const x = a.y * b.z - a.z * b.y\n  const y = a.z * b.x - a.x * b.z\n  const z = a.x * b.y - a.y * b.x\n\n  return make(x, y, z)\n})\n\n/** @internal */\nexport const components: (v: Vector3) => [number, number, number] = (v: Vector3) => [v.x, v.y, v.z]\n\n/** @internal */\nexport const softmax = (v: Vector3) => {\n  const max = Math.max(v.x, v.y, v.z)\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\n  const sum = v0 + v1 + v2\n\n  return make(v0 / sum, v1 / sum, v2 / sum)\n}\n\n/** @internal */\nexport const add = dual<\n  (b: Vector3) => (a: Vector3) => Vector3,\n  (a: Vector3, b: Vector3) => Vector3\n>(2, (a: Vector3, b: Vector3) => make(a.x + b.x, a.y + b.y, a.z + b.z))\n\n/** @internal */\nexport const subtract = dual<\n  (b: Vector3) => (a: Vector3) => Vector3,\n  (a: Vector3, b: Vector3) => Vector3\n>(2, (a: Vector3, b: Vector3) => make(a.x - b.x, a.y - b.y, a.z - b.z))\n\n/** @internal */\nexport const hadamard = dual<\n  (b: Vector3) => (a: Vector3) => Vector3,\n  (a: Vector3, b: Vector3) => Vector3\n>(2, (a: Vector3, b: Vector3) => make(a.x * b.x, a.y * b.y, a.z * b.z))\n\n/** @internal */\nexport const scale = dual<\n  (s: number) => (v: Vector3) => Vector3,\n  (v: Vector3, s: number) => Vector3\n>(2, (v: Vector3, s: number) => (s === 1 ? v : make(v.x * s, v.y * s, v.z * s)))\n\n/** @internal */\nexport const getX: (v: Vector3) => number = (v: Vector3) => v.x\n/** @internal */\nexport const setX = dual<\n  (x: number) => (v: Vector3) => Vector3,\n  (v: Vector3, x: number) => Vector3\n>(2, (v: Vector3, x: number) => make(x, v.y, v.z))\n\n/** @internal */\nexport const mapX = dual<\n  (f: (x: number) => number) => (v: Vector3) => Vector3,\n  (v: Vector3, f: (x: number) => number) => Vector3\n>(2, (v: Vector3, f: (x: number) => number) => make(f(v.x), v.y, v.z))\n\n/** @internal */\nexport const getY: (v: Vector3) => number = (v: Vector3) => v.y\n/** @internal */\nexport const setY = dual<\n  (y: number) => (v: Vector3) => Vector3,\n  (v: Vector3, y: number) => Vector3\n>(2, (v: Vector3, y: number) => make(v.x, y, v.z))\n\n/** @internal */\nexport const mapY = dual<\n  (f: (y: number) => number) => (v: Vector3) => Vector3,\n  (v: Vector3, f: (y: number) => number) => Vector3\n>(2, (v: Vector3, f: (y: number) => number) => make(v.x, f(v.y), v.z))\n\n/** @internal */\nexport const getZ: (v: Vector3) => number = (v: Vector3) => v.z\n/** @internal */\nexport const setZ = dual<\n  (z: number) => (v: Vector3) => Vector3,\n  (v: Vector3, z: number) => Vector3\n>(2, (v: Vector3, z: number) => make(v.x, v.y, z))\n\n/** @internal */\nexport const mapZ = dual<\n  (f: (z: number) => number) => (v: Vector3) => Vector3,\n  (v: Vector3, f: (z: number) => number) => Vector3\n>(2, (v: Vector3, f: (z: number) => number) => make(v.x, v.y, f(v.z)))\n\n/** @internal */\nexport const setR = dual<\n  (r: number) => (v: Vector3) => Vector3,\n  (v: Vector3, r: number) => Vector3\n>(2, (v: Vector3, r: number) => scale(r / magnitude(v))(v))\n\n/** @internal */\nexport const mapR = dual<\n  (f: (r: number) => number) => (v: Vector3) => Vector3,\n  (v: Vector3, f: (r: number) => number) => Vector3\n>(2, (v: Vector3, f: (r: number) => number) => {\n  const r = magnitude(v)\n  return scale(f(r) / r)(v)\n})\n\n/** @internal */\nexport const getTheta = (v: Vector3) => Math.acos(v.z / magnitude(v))\n/** @internal */\nexport const setTheta = dual<\n  (theta: number) => (v: Vector3) => Vector3,\n  (v: Vector3, theta: number) => Vector3\n>(2, (v: Vector3, theta: number) => {\n  const r = magnitude(v)\n  const phi = Math.atan2(v.y, v.x)\n  const sinTheta = Math.sin(theta)\n  return make(r * sinTheta * Math.cos(phi), r * sinTheta * Math.sin(phi), r * Math.cos(theta))\n})\n\n/** @internal */\nexport const mapTheta = dual<\n  (f: (theta: number) => number) => (v: Vector3) => Vector3,\n  (v: Vector3, f: (theta: number) => number) => Vector3\n>(2, (v: Vector3, f: (theta: number) => number) => setTheta(v, f(getTheta(v))))\n\n/** @internal */\nexport const getPhi = (v: Vector3) => Math.atan2(v.y, v.x)\n// setPhi rotates only in the xy plane: preserve z and the xy-projection\n// length ρ = r·sin(θ) = hypot(v.x, v.y). That keeps both r and θ invariant.\n/** @internal */\nexport const setPhi = dual<\n  (phi: number) => (v: Vector3) => Vector3,\n  (v: Vector3, phi: number) => Vector3\n>(2, (v: Vector3, phi: number) => {\n  const rho = Math.hypot(v.x, v.y)\n  return make(rho * Math.cos(phi), rho * Math.sin(phi), v.z)\n})\n\n/** @internal */\nexport const mapPhi = dual<\n  (f: (phi: number) => number) => (v: Vector3) => Vector3,\n  (v: Vector3, f: (phi: number) => number) => Vector3\n>(2, (v: Vector3, f: (phi: number) => number) => setPhi(v, f(getPhi(v))))\n"],"mappings":"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"}

package/dist/shared/{vector4-PO_7EYd-.mjs → vector4-DGHuCvTV.mjs}

@@ -1,5 +1,5 @@
 import { t as __exportAll } from "./chunk-25Hzd3z8.mjs";
-import { C as setZ$1, E as transpose$1, S as setY$1, T as subtract$1, _ as mapZ$1, a as fromTuple$1, b as setW$1, c as getY$1, d as isVector4$1, f as magnitude$1, g as mapY$1, h as mapX$1, i as equals$1, l as getZ$1, m as mapW$1, n as components$1, o as getW$1, p as make$1, r as dot$1, s as getX$1, t as add$1, u as hadamard$1, v as normalize$1, w as softmax$1, x as setX$1, y as scale$1 } from "./vector4.internal-BJ1QN2Ck.mjs";
+import { C as setZ$1, E as transpose$1, S as setY$1, T as subtract$1, _ as mapZ$1, a as fromTuple$1, b as setW$1, c as getY$1, d as isVector4$1, f as magnitude$1, g as mapY$1, h as mapX$1, i as equals$1, l as getZ$1, m as mapW$1, n as components$1, o as getW$1, p as make$1, r as dot$1, s as getX$1, t as add$1, u as hadamard$1, v as normalize$1, w as softmax$1, x as setX$1, y as scale$1 } from "./vector4.internal-DH5DzNYO.mjs";
 //#region src/vector/vector4.ts
 var vector4_exports = /* @__PURE__ */ __exportAll({
 	add: () => add,
@@ -168,4 +168,4 @@ const mapW = mapW$1;
 //#endregion
 export { transpose as n, vector4_exports as r, make as t };
 
-//# sourceMappingURL=vector4-PO_7EYd-.mjs.map
+//# sourceMappingURL=vector4-DGHuCvTV.mjs.map

package/dist/shared/{vector4-PO_7EYd-.mjs.map → vector4-DGHuCvTV.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"vector4-PO_7EYd-.mjs","names":["internal.isVector4","internal.equals","internal.make","internal.fromTuple","internal.transpose","internal.magnitude","internal.normalize","internal.dot","internal.components","internal.softmax","internal.add","internal.subtract","internal.hadamard","internal.scale","internal.getX","internal.setX","internal.mapX","internal.getY","internal.setY","internal.mapY","internal.getZ","internal.setZ","internal.mapZ","internal.getW","internal.setW","internal.mapW"],"sources":["../../src/vector/vector4.ts"],"sourcesContent":["import type { FourDimensional } from '../dimensions.ts'\nimport type { Pipeable } from '../utils.ts'\nimport type { Vector4TypeId } from './vector4.internal.ts'\nimport * as internal from './vector4.internal.ts'\n\n/**\n * A 4D vector.\n *\n * All fields are readonly and immutable, and all operations create new instances.\n *\n * @since 1.0.0\n */\nexport interface Vector4 extends Pipeable, FourDimensional<number> {\n  readonly [Vector4TypeId]: Vector4TypeId\n}\n\n/**\n * Checks if a value is a `Vector4`.\n *\n * @param v - The value to check.\n * @returns `true` if the value is a `Vector4`, `false` otherwise.\n * @since 1.0.0\n */\nexport const isVector4: (v: unknown) => v is Vector4 = internal.isVector4\n\nexport const equals: {\n  /**\n   * Checks if two `Vector4` instances are approximately equal within the\n   * default absolute tolerance ({@link EPSILON}).\n   *\n   * @param a - The first vector.\n   * @param b - The second vector.\n   * @returns `true` when each pair of components is within tolerance.\n   * @since 1.1.0\n   */\n  (a: Vector4, b: Vector4): boolean\n  /**\n   * Checks if two `Vector4` instances are approximately equal within the\n   * default absolute tolerance ({@link EPSILON}).\n   *\n   * @param b - The second vector.\n   * @returns A function that takes the first vector and returns the comparison result.\n   * @since 1.1.0\n   */\n  (b: Vector4): (a: Vector4) => boolean\n} = internal.equals\n\nexport const make: {\n  /**\n   * Creates a new `Vector4` instance.\n   *\n   * @param xyzw - The x, y, z, and w components of the vector.\n   * @returns A new `Vector4` instance.\n   * @since 1.0.0\n   */\n  (xyzw: number): Vector4\n  /**\n   * Creates a new `Vector4` instance.\n   *\n   * @param x - The x component of the vector.\n   * @param yzw - The y, z, and w components of the vector.\n   * @returns A new `Vector4` instance.\n   * @since 1.0.0\n   */\n  (x: number, yzw: number): Vector4\n  /**\n   * Creates a new `Vector4` instance.\n   *\n   * @param x - The x component of the vector.\n   * @param y - The y component of the vector.\n   * @param zw - The z and w components of the vector.\n   * @returns A new `Vector4` instance.\n   * @since 1.0.0\n   */\n  (x: number, y: number, zw: number): Vector4\n  /**\n   * Creates a new `Vector4` instance.\n   *\n   * @param x - The x component of the vector.\n   * @param y - The y component of the vector.\n   * @param z - The z component of the vector.\n   * @param w - The w component of the vector.\n   * @returns A new `Vector4` instance.\n   * @since 1.0.0\n   */\n  (x: number, y: number, z: number, w: number): Vector4\n} = internal.make\n\n/**\n * Creates a new `Vector4` instance from a `[x, y, z, w]` tuple. Inverse of\n * {@link components}.\n *\n * @param t - The `[x, y, z, w]` tuple.\n * @returns A new `Vector4` instance.\n * @since 2.0.0\n */\nexport const fromTuple: (t: readonly [number, number, number, number]) => Vector4 =\n  internal.fromTuple\n\n/**\n * Transposes a 4-tuple of items into one or more `Vector4`s, one per channel\n * extracted by the projection function.\n *\n * For each output channel, takes the corresponding number from each of the\n * four projected items and packs them into a `Vector4` — the data-layout\n * transformation NumPy calls a transpose, FP calls `unzip`, GPUs call a\n * gather, and DSP people inexplicably call deinterleaving.\n *\n * The projection's return-tuple arity determines the number of output\n * vectors, and that arity is preserved in the return type.\n *\n * @example\n * ```ts\n * // Pack the x and y coordinates of four control points into two Vector4s.\n * const [xs, ys] = Vector4.transpose(\n *   [p0, p1, p2, p3],\n *   (p) => [p.x, p.y],\n * )\n * ```\n *\n * @param inputs - Exactly four items of any type.\n * @param project - A function returning a fixed-arity tuple of numbers — one per output channel.\n * @returns A tuple of `Vector4`s with the same arity as the projection's return tuple.\n * @since 2.0.0\n */\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 } = internal.transpose\n\n/**\n * Gets the magnitude of a `Vector4`.\n *\n * @param vector - The vector to calculate the magnitude of.\n * @returns The magnitude of the vector.\n * @since 1.0.0\n */\nexport const magnitude: (vector: Vector4) => number = internal.magnitude\n\n/**\n * Normalizes a `Vector4`.\n *\n * @param vector - The vector to normalize.\n * @returns A new `Vector4` instance with the same direction as the input vector but with a magnitude of 1.\n * @since 1.0.0\n */\nexport const normalize: (vector: Vector4) => Vector4 = internal.normalize\n\nexport const dot: {\n  /**\n   * Computes the dot product of two `Vector4` instances.\n   *\n   * @param a - The first vector.\n   * @param b - The second vector.\n   * @returns The dot product of the two vectors.\n   * @since 1.0.0\n   */\n  (a: Vector4, b: Vector4): number\n  /**\n   * Computes the dot product of a `Vector4` instance and another vector.\n   *\n   * @param b - The second vector.\n   * @returns A function that takes the first vector and returns the dot product.\n   * @since 1.0.0\n   */\n  (b: Vector4): (a: Vector4) => number\n} = internal.dot\n\n/**\n * Returns the components of a `Vector4` as an array.\n *\n * @param v - The vector to get the components of.\n * @returns An array containing the x, y, z, and w components of the vector.\n * @since 1.0.0\n */\nexport const components: (v: Vector4) => [number, number, number, number] = internal.components\n\n/**\n * Applies the softmax function to a `Vector4`.\n *\n * @param v - The vector to calculate the softmax of.\n * @returns A new `Vector4` instance representing the softmax of the input vector.\n */\nexport const softmax: (v: Vector4) => Vector4 = internal.softmax\n\n/**\n * Creates a zero vector.\n *\n * @since 1.0.0\n */\nexport const zero = make(0)\n\n/**\n * Creates a unit vector.\n *\n * @since 1.0.0\n */\nexport const unit = make(1)\n\nexport const add: {\n  /**\n   * Adds two `Vector4` instances.\n   *\n   * @param a - The first vector.\n   * @param b - The second vector.\n   * @returns A new `Vector4` instance representing the sum of the two vectors.\n   * @since 1.0.0\n   */\n  (a: Vector4, b: Vector4): Vector4\n\n  /**\n   * Adds a `Vector4` instance to another vector.\n   *\n   * @param b - The second vector.\n   * @returns A function that takes the first vector and returns the sum.\n   * @since 1.0.0\n   */\n  (b: Vector4): (a: Vector4) => Vector4\n} = internal.add\n\nexport const subtract: {\n  /**\n   * Subtracts one `Vector4` instance from another.\n   *\n   * @param a - The first vector.\n   * @param b - The second vector.\n   * @returns A new `Vector4` instance representing the difference of the two vectors.\n   * @since 1.0.0\n   */\n  (a: Vector4, b: Vector4): Vector4\n  /**\n   * Subtracts a `Vector4` instance from another vector.\n   *\n   * @param b - The second vector.\n   * @returns A function that takes the first vector and returns the difference.\n   * @since 1.0.0\n   */\n  (b: Vector4): (a: Vector4) => Vector4\n} = internal.subtract\n\nexport const hadamard: {\n  /**\n   * Computes the Hadamard product of two `Vector4` instances.\n   *\n   * @param a - The first vector.\n   * @param b - The second vector.\n   * @returns A new `Vector4` instance representing the Hadamard product of the two vectors.\n   * @since 1.0.0\n   */\n  (a: Vector4, b: Vector4): Vector4\n  /**\n   * Computes the Hadamard product of a `Vector4` instance and another vector.\n   *\n   * @param b - The second vector.\n   * @returns A function that takes the first vector and returns the Hadamard product.\n   * @since 1.0.0\n   */\n  (b: Vector4): (a: Vector4) => Vector4\n} = internal.hadamard\n\nexport const scale: {\n  /**\n   * Scales a `Vector4` by a scalar.\n   *\n   * @param s - The scalar to scale the vector by.\n   * @returns A function that takes the vector and returns the scaled vector.\n   * @since 1.0.0\n   */\n  (s: number): (v: Vector4) => Vector4\n  /**\n   * Scales a `Vector4` by a scalar.\n   *\n   * @param s - The scalar to scale the vector by.\n   * @param v - The vector to scale.\n   * @returns A new `Vector4` instance representing the scaled vector.\n   * @since 1.0.0\n   */\n  (v: Vector4, s: number): Vector4\n} = internal.scale\n\n/**\n * Gets the x component of a `Vector4`.\n *\n * @param v - The vector to get the x component of.\n * @returns The x component of the vector.\n * @since 2.0.0\n */\nexport const getX: (v: Vector4) => number = internal.getX\n\nexport const setX: {\n  /**\n   * Sets the x component of a `Vector4`.\n   *\n   * @param v - The vector to set the x component of.\n   * @param x - The new x component.\n   * @returns A new `Vector4` instance with the updated x component.\n   * @since 2.0.0\n   */\n  (v: Vector4, x: number): Vector4\n  /**\n   * Sets the x component of a `Vector4`.\n   *\n   * @param x - The new x component.\n   * @returns A function that takes a vector and returns the updated vector.\n   * @since 2.0.0\n   */\n  (x: number): (v: Vector4) => Vector4\n} = internal.setX\n\nexport const mapX: {\n  /**\n   * Returns a new `Vector4` with the x component replaced by `f(v.x)`.\n   *\n   * @param v - The vector to update.\n   * @param f - The function to apply to the x component.\n   * @returns A new `Vector4` with the updated x.\n   * @since 2.0.0\n   */\n  (v: Vector4, f: (x: number) => number): Vector4\n  /**\n   * Returns a new `Vector4` with the x component replaced by `f(v.x)`.\n   *\n   * @param f - The function to apply to the x component.\n   * @returns A function that takes a vector and returns the updated vector.\n   * @since 2.0.0\n   */\n  (f: (x: number) => number): (v: Vector4) => Vector4\n} = internal.mapX\n\n/**\n * Gets the y component of a `Vector4`.\n *\n * @param v - The vector to get the y component of.\n * @returns The y component of the vector.\n * @since 2.0.0\n */\nexport const getY: (v: Vector4) => number = internal.getY\n\nexport const setY: {\n  /**\n   * Sets the y component of a `Vector4`.\n   *\n   * @param v - The vector to set the y component of.\n   * @param y - The new y component.\n   * @returns A new `Vector4` instance with the updated y component.\n   * @since 2.0.0\n   */\n  (v: Vector4, y: number): Vector4\n  /**\n   * Sets the y component of a `Vector4`.\n   *\n   * @param y - The new y component.\n   * @returns A function that takes a vector and returns the updated vector.\n   * @since 2.0.0\n   */\n  (y: number): (v: Vector4) => Vector4\n} = internal.setY\n\nexport const mapY: {\n  /**\n   * Returns a new `Vector4` with the y component replaced by `f(v.y)`.\n   *\n   * @param v - The vector to update.\n   * @param f - The function to apply to the y component.\n   * @returns A new `Vector4` with the updated y.\n   * @since 2.0.0\n   */\n  (v: Vector4, f: (y: number) => number): Vector4\n  /**\n   * Returns a new `Vector4` with the y component replaced by `f(v.y)`.\n   *\n   * @param f - The function to apply to the y component.\n   * @returns A function that takes a vector and returns the updated vector.\n   * @since 2.0.0\n   */\n  (f: (y: number) => number): (v: Vector4) => Vector4\n} = internal.mapY\n\n/**\n * Gets the z component of a `Vector4`.\n *\n * @param v - The vector to get the z component of.\n * @returns The z component of the vector.\n * @since 2.0.0\n */\nexport const getZ: (v: Vector4) => number = internal.getZ\n\nexport const setZ: {\n  /**\n   * Sets the z component of a `Vector4`.\n   *\n   * @param v - The vector to set the z component of.\n   * @param z - The new z component.\n   * @returns A new `Vector4` instance with the updated z component.\n   * @since 2.0.0\n   */\n  (v: Vector4, z: number): Vector4\n  /**\n   * Sets the z component of a `Vector4`.\n   *\n   * @param z - The new z component.\n   * @returns A function that takes a vector and returns the updated vector.\n   * @since 2.0.0\n   */\n  (z: number): (v: Vector4) => Vector4\n} = internal.setZ\n\nexport const mapZ: {\n  /**\n   * Returns a new `Vector4` with the z component replaced by `f(v.z)`.\n   *\n   * @param v - The vector to update.\n   * @param f - The function to apply to the z component.\n   * @returns A new `Vector4` with the updated z.\n   * @since 2.0.0\n   */\n  (v: Vector4, f: (z: number) => number): Vector4\n  /**\n   * Returns a new `Vector4` with the z component replaced by `f(v.z)`.\n   *\n   * @param f - The function to apply to the z component.\n   * @returns A function that takes a vector and returns the updated vector.\n   * @since 2.0.0\n   */\n  (f: (z: number) => number): (v: Vector4) => Vector4\n} = internal.mapZ\n\n/**\n * Gets the w component of a `Vector4`.\n *\n * @param v - The vector to get the w component of.\n * @returns The w component of the vector.\n * @since 2.0.0\n */\nexport const getW: (v: Vector4) => number = internal.getW\n\nexport const setW: {\n  /**\n   * Sets the w component of a `Vector4`.\n   *\n   * @param v - The vector to set the w component of.\n   * @param w - The new w component.\n   * @returns A new `Vector4` instance with the updated w component.\n   * @since 2.0.0\n   */\n  (v: Vector4, w: number): Vector4\n  /**\n   * Sets the w component of a `Vector4`.\n   *\n   * @param w - The new w component.\n   * @returns A function that takes a vector and returns the updated vector.\n   * @since 2.0.0\n   */\n  (w: number): (v: Vector4) => Vector4\n} = internal.setW\n\nexport const mapW: {\n  /**\n   * Returns a new `Vector4` with the w component replaced by `f(v.w)`.\n   *\n   * @param v - The vector to update.\n   * @param f - The function to apply to the w component.\n   * @returns A new `Vector4` with the updated w.\n   * @since 2.0.0\n   */\n  (v: Vector4, f: (w: number) => number): Vector4\n  /**\n   * Returns a new `Vector4` with the w component replaced by `f(v.w)`.\n   *\n   * @param f - The function to apply to the w component.\n   * @returns A function that takes a vector and returns the updated vector.\n   * @since 2.0.0\n   */\n  (f: (w: number) => number): (v: Vector4) => Vector4\n} = internal.mapW\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuBA,MAAa,YAA0CA;AAEvD,MAAa,SAoBTC;AAEJ,MAAa,OAuCTC;;;;;;;;;AAUJ,MAAa,YACXC;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BF,MAAa,YAGsCC;;;;;;;;AASnD,MAAa,YAAyCC;;;;;;;;AAStD,MAAa,YAA0CC;AAEvD,MAAa,MAkBTC;;;;;;;;AASJ,MAAa,aAA+DC;;;;;;;AAQ5E,MAAa,UAAmCC;;;;;;AAOhD,MAAa,OAAO,KAAK,EAAE;;;;;;AAO3B,MAAa,OAAO,KAAK,EAAE;AAE3B,MAAa,MAmBTC;AAEJ,MAAa,WAkBTC;AAEJ,MAAa,WAkBTC;AAEJ,MAAa,QAkBTC;;;;;;;;AASJ,MAAa,OAA+BC;AAE5C,MAAa,OAkBTC;AAEJ,MAAa,OAkBTC;;;;;;;;AASJ,MAAa,OAA+BC;AAE5C,MAAa,OAkBTC;AAEJ,MAAa,OAkBTC;;;;;;;;AASJ,MAAa,OAA+BC;AAE5C,MAAa,OAkBTC;AAEJ,MAAa,OAkBTC;;;;;;;;AASJ,MAAa,OAA+BC;AAE5C,MAAa,OAkBTC;AAEJ,MAAa,OAkBTC"}
+{"version":3,"file":"vector4-DGHuCvTV.mjs","names":["internal.isVector4","internal.equals","internal.make","internal.fromTuple","internal.transpose","internal.magnitude","internal.normalize","internal.dot","internal.components","internal.softmax","internal.add","internal.subtract","internal.hadamard","internal.scale","internal.getX","internal.setX","internal.mapX","internal.getY","internal.setY","internal.mapY","internal.getZ","internal.setZ","internal.mapZ","internal.getW","internal.setW","internal.mapW"],"sources":["../../src/vector/vector4.ts"],"sourcesContent":["import type { FourDimensional } from '../dimensions.ts'\nimport type { Pipeable } from '../utils.ts'\nimport type { Vector4TypeId } from './vector4.internal.ts'\nimport * as internal from './vector4.internal.ts'\n\n/**\n * A 4D vector.\n *\n * All fields are readonly and immutable, and all operations create new instances.\n *\n * @since 1.0.0\n */\nexport interface Vector4 extends Pipeable, FourDimensional<number> {\n  readonly [Vector4TypeId]: Vector4TypeId\n}\n\n/**\n * Checks if a value is a `Vector4`.\n *\n * @param v - The value to check.\n * @returns `true` if the value is a `Vector4`, `false` otherwise.\n * @since 1.0.0\n */\nexport const isVector4: (v: unknown) => v is Vector4 = internal.isVector4\n\nexport const equals: {\n  /**\n   * Checks if two `Vector4` instances are approximately equal within the\n   * default absolute tolerance ({@link EPSILON}).\n   *\n   * @param a - The first vector.\n   * @param b - The second vector.\n   * @returns `true` when each pair of components is within tolerance.\n   * @since 1.1.0\n   */\n  (a: Vector4, b: Vector4): boolean\n  /**\n   * Checks if two `Vector4` instances are approximately equal within the\n   * default absolute tolerance ({@link EPSILON}).\n   *\n   * @param b - The second vector.\n   * @returns A function that takes the first vector and returns the comparison result.\n   * @since 1.1.0\n   */\n  (b: Vector4): (a: Vector4) => boolean\n} = internal.equals\n\nexport const make: {\n  /**\n   * Creates a new `Vector4` instance.\n   *\n   * @param xyzw - The x, y, z, and w components of the vector.\n   * @returns A new `Vector4` instance.\n   * @since 1.0.0\n   */\n  (xyzw: number): Vector4\n  /**\n   * Creates a new `Vector4` instance.\n   *\n   * @param x - The x component of the vector.\n   * @param yzw - The y, z, and w components of the vector.\n   * @returns A new `Vector4` instance.\n   * @since 1.0.0\n   */\n  (x: number, yzw: number): Vector4\n  /**\n   * Creates a new `Vector4` instance.\n   *\n   * @param x - The x component of the vector.\n   * @param y - The y component of the vector.\n   * @param zw - The z and w components of the vector.\n   * @returns A new `Vector4` instance.\n   * @since 1.0.0\n   */\n  (x: number, y: number, zw: number): Vector4\n  /**\n   * Creates a new `Vector4` instance.\n   *\n   * @param x - The x component of the vector.\n   * @param y - The y component of the vector.\n   * @param z - The z component of the vector.\n   * @param w - The w component of the vector.\n   * @returns A new `Vector4` instance.\n   * @since 1.0.0\n   */\n  (x: number, y: number, z: number, w: number): Vector4\n} = internal.make\n\n/**\n * Creates a new `Vector4` instance from a `[x, y, z, w]` tuple. Inverse of\n * {@link components}.\n *\n * @param t - The `[x, y, z, w]` tuple.\n * @returns A new `Vector4` instance.\n * @since 2.0.0\n */\nexport const fromTuple: (t: readonly [number, number, number, number]) => Vector4 =\n  internal.fromTuple\n\n/**\n * Transposes a 4-tuple of items into one or more `Vector4`s, one per channel\n * extracted by the projection function.\n *\n * For each output channel, takes the corresponding number from each of the\n * four projected items and packs them into a `Vector4` — the data-layout\n * transformation NumPy calls a transpose, FP calls `unzip`, GPUs call a\n * gather, and DSP people inexplicably call deinterleaving.\n *\n * The projection's return-tuple arity determines the number of output\n * vectors, and that arity is preserved in the return type.\n *\n * @example\n * ```ts\n * // Pack the x and y coordinates of four control points into two Vector4s.\n * const [xs, ys] = Vector4.transpose(\n *   [p0, p1, p2, p3],\n *   (p) => [p.x, p.y],\n * )\n * ```\n *\n * @param inputs - Exactly four items of any type.\n * @param project - A function returning a fixed-arity tuple of numbers — one per output channel.\n * @returns A tuple of `Vector4`s with the same arity as the projection's return tuple.\n * @since 2.0.0\n */\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 } = internal.transpose\n\n/**\n * Gets the magnitude of a `Vector4`.\n *\n * @param vector - The vector to calculate the magnitude of.\n * @returns The magnitude of the vector.\n * @since 1.0.0\n */\nexport const magnitude: (vector: Vector4) => number = internal.magnitude\n\n/**\n * Normalizes a `Vector4`.\n *\n * @param vector - The vector to normalize.\n * @returns A new `Vector4` instance with the same direction as the input vector but with a magnitude of 1.\n * @since 1.0.0\n */\nexport const normalize: (vector: Vector4) => Vector4 = internal.normalize\n\nexport const dot: {\n  /**\n   * Computes the dot product of two `Vector4` instances.\n   *\n   * @param a - The first vector.\n   * @param b - The second vector.\n   * @returns The dot product of the two vectors.\n   * @since 1.0.0\n   */\n  (a: Vector4, b: Vector4): number\n  /**\n   * Computes the dot product of a `Vector4` instance and another vector.\n   *\n   * @param b - The second vector.\n   * @returns A function that takes the first vector and returns the dot product.\n   * @since 1.0.0\n   */\n  (b: Vector4): (a: Vector4) => number\n} = internal.dot\n\n/**\n * Returns the components of a `Vector4` as an array.\n *\n * @param v - The vector to get the components of.\n * @returns An array containing the x, y, z, and w components of the vector.\n * @since 1.0.0\n */\nexport const components: (v: Vector4) => [number, number, number, number] = internal.components\n\n/**\n * Applies the softmax function to a `Vector4`.\n *\n * @param v - The vector to calculate the softmax of.\n * @returns A new `Vector4` instance representing the softmax of the input vector.\n */\nexport const softmax: (v: Vector4) => Vector4 = internal.softmax\n\n/**\n * Creates a zero vector.\n *\n * @since 1.0.0\n */\nexport const zero = make(0)\n\n/**\n * Creates a unit vector.\n *\n * @since 1.0.0\n */\nexport const unit = make(1)\n\nexport const add: {\n  /**\n   * Adds two `Vector4` instances.\n   *\n   * @param a - The first vector.\n   * @param b - The second vector.\n   * @returns A new `Vector4` instance representing the sum of the two vectors.\n   * @since 1.0.0\n   */\n  (a: Vector4, b: Vector4): Vector4\n\n  /**\n   * Adds a `Vector4` instance to another vector.\n   *\n   * @param b - The second vector.\n   * @returns A function that takes the first vector and returns the sum.\n   * @since 1.0.0\n   */\n  (b: Vector4): (a: Vector4) => Vector4\n} = internal.add\n\nexport const subtract: {\n  /**\n   * Subtracts one `Vector4` instance from another.\n   *\n   * @param a - The first vector.\n   * @param b - The second vector.\n   * @returns A new `Vector4` instance representing the difference of the two vectors.\n   * @since 1.0.0\n   */\n  (a: Vector4, b: Vector4): Vector4\n  /**\n   * Subtracts a `Vector4` instance from another vector.\n   *\n   * @param b - The second vector.\n   * @returns A function that takes the first vector and returns the difference.\n   * @since 1.0.0\n   */\n  (b: Vector4): (a: Vector4) => Vector4\n} = internal.subtract\n\nexport const hadamard: {\n  /**\n   * Computes the Hadamard product of two `Vector4` instances.\n   *\n   * @param a - The first vector.\n   * @param b - The second vector.\n   * @returns A new `Vector4` instance representing the Hadamard product of the two vectors.\n   * @since 1.0.0\n   */\n  (a: Vector4, b: Vector4): Vector4\n  /**\n   * Computes the Hadamard product of a `Vector4` instance and another vector.\n   *\n   * @param b - The second vector.\n   * @returns A function that takes the first vector and returns the Hadamard product.\n   * @since 1.0.0\n   */\n  (b: Vector4): (a: Vector4) => Vector4\n} = internal.hadamard\n\nexport const scale: {\n  /**\n   * Scales a `Vector4` by a scalar.\n   *\n   * @param s - The scalar to scale the vector by.\n   * @returns A function that takes the vector and returns the scaled vector.\n   * @since 1.0.0\n   */\n  (s: number): (v: Vector4) => Vector4\n  /**\n   * Scales a `Vector4` by a scalar.\n   *\n   * @param s - The scalar to scale the vector by.\n   * @param v - The vector to scale.\n   * @returns A new `Vector4` instance representing the scaled vector.\n   * @since 1.0.0\n   */\n  (v: Vector4, s: number): Vector4\n} = internal.scale\n\n/**\n * Gets the x component of a `Vector4`.\n *\n * @param v - The vector to get the x component of.\n * @returns The x component of the vector.\n * @since 2.0.0\n */\nexport const getX: (v: Vector4) => number = internal.getX\n\nexport const setX: {\n  /**\n   * Sets the x component of a `Vector4`.\n   *\n   * @param v - The vector to set the x component of.\n   * @param x - The new x component.\n   * @returns A new `Vector4` instance with the updated x component.\n   * @since 2.0.0\n   */\n  (v: Vector4, x: number): Vector4\n  /**\n   * Sets the x component of a `Vector4`.\n   *\n   * @param x - The new x component.\n   * @returns A function that takes a vector and returns the updated vector.\n   * @since 2.0.0\n   */\n  (x: number): (v: Vector4) => Vector4\n} = internal.setX\n\nexport const mapX: {\n  /**\n   * Returns a new `Vector4` with the x component replaced by `f(v.x)`.\n   *\n   * @param v - The vector to update.\n   * @param f - The function to apply to the x component.\n   * @returns A new `Vector4` with the updated x.\n   * @since 2.0.0\n   */\n  (v: Vector4, f: (x: number) => number): Vector4\n  /**\n   * Returns a new `Vector4` with the x component replaced by `f(v.x)`.\n   *\n   * @param f - The function to apply to the x component.\n   * @returns A function that takes a vector and returns the updated vector.\n   * @since 2.0.0\n   */\n  (f: (x: number) => number): (v: Vector4) => Vector4\n} = internal.mapX\n\n/**\n * Gets the y component of a `Vector4`.\n *\n * @param v - The vector to get the y component of.\n * @returns The y component of the vector.\n * @since 2.0.0\n */\nexport const getY: (v: Vector4) => number = internal.getY\n\nexport const setY: {\n  /**\n   * Sets the y component of a `Vector4`.\n   *\n   * @param v - The vector to set the y component of.\n   * @param y - The new y component.\n   * @returns A new `Vector4` instance with the updated y component.\n   * @since 2.0.0\n   */\n  (v: Vector4, y: number): Vector4\n  /**\n   * Sets the y component of a `Vector4`.\n   *\n   * @param y - The new y component.\n   * @returns A function that takes a vector and returns the updated vector.\n   * @since 2.0.0\n   */\n  (y: number): (v: Vector4) => Vector4\n} = internal.setY\n\nexport const mapY: {\n  /**\n   * Returns a new `Vector4` with the y component replaced by `f(v.y)`.\n   *\n   * @param v - The vector to update.\n   * @param f - The function to apply to the y component.\n   * @returns A new `Vector4` with the updated y.\n   * @since 2.0.0\n   */\n  (v: Vector4, f: (y: number) => number): Vector4\n  /**\n   * Returns a new `Vector4` with the y component replaced by `f(v.y)`.\n   *\n   * @param f - The function to apply to the y component.\n   * @returns A function that takes a vector and returns the updated vector.\n   * @since 2.0.0\n   */\n  (f: (y: number) => number): (v: Vector4) => Vector4\n} = internal.mapY\n\n/**\n * Gets the z component of a `Vector4`.\n *\n * @param v - The vector to get the z component of.\n * @returns The z component of the vector.\n * @since 2.0.0\n */\nexport const getZ: (v: Vector4) => number = internal.getZ\n\nexport const setZ: {\n  /**\n   * Sets the z component of a `Vector4`.\n   *\n   * @param v - The vector to set the z component of.\n   * @param z - The new z component.\n   * @returns A new `Vector4` instance with the updated z component.\n   * @since 2.0.0\n   */\n  (v: Vector4, z: number): Vector4\n  /**\n   * Sets the z component of a `Vector4`.\n   *\n   * @param z - The new z component.\n   * @returns A function that takes a vector and returns the updated vector.\n   * @since 2.0.0\n   */\n  (z: number): (v: Vector4) => Vector4\n} = internal.setZ\n\nexport const mapZ: {\n  /**\n   * Returns a new `Vector4` with the z component replaced by `f(v.z)`.\n   *\n   * @param v - The vector to update.\n   * @param f - The function to apply to the z component.\n   * @returns A new `Vector4` with the updated z.\n   * @since 2.0.0\n   */\n  (v: Vector4, f: (z: number) => number): Vector4\n  /**\n   * Returns a new `Vector4` with the z component replaced by `f(v.z)`.\n   *\n   * @param f - The function to apply to the z component.\n   * @returns A function that takes a vector and returns the updated vector.\n   * @since 2.0.0\n   */\n  (f: (z: number) => number): (v: Vector4) => Vector4\n} = internal.mapZ\n\n/**\n * Gets the w component of a `Vector4`.\n *\n * @param v - The vector to get the w component of.\n * @returns The w component of the vector.\n * @since 2.0.0\n */\nexport const getW: (v: Vector4) => number = internal.getW\n\nexport const setW: {\n  /**\n   * Sets the w component of a `Vector4`.\n   *\n   * @param v - The vector to set the w component of.\n   * @param w - The new w component.\n   * @returns A new `Vector4` instance with the updated w component.\n   * @since 2.0.0\n   */\n  (v: Vector4, w: number): Vector4\n  /**\n   * Sets the w component of a `Vector4`.\n   *\n   * @param w - The new w component.\n   * @returns A function that takes a vector and returns the updated vector.\n   * @since 2.0.0\n   */\n  (w: number): (v: Vector4) => Vector4\n} = internal.setW\n\nexport const mapW: {\n  /**\n   * Returns a new `Vector4` with the w component replaced by `f(v.w)`.\n   *\n   * @param v - The vector to update.\n   * @param f - The function to apply to the w component.\n   * @returns A new `Vector4` with the updated w.\n   * @since 2.0.0\n   */\n  (v: Vector4, f: (w: number) => number): Vector4\n  /**\n   * Returns a new `Vector4` with the w component replaced by `f(v.w)`.\n   *\n   * @param f - The function to apply to the w component.\n   * @returns A function that takes a vector and returns the updated vector.\n   * @since 2.0.0\n   */\n  (f: (w: number) => number): (v: Vector4) => Vector4\n} = internal.mapW\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuBA,MAAa,YAA0CA;AAEvD,MAAa,SAoBTC;AAEJ,MAAa,OAuCTC;;;;;;;;;AAUJ,MAAa,YACXC;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BF,MAAa,YAGsCC;;;;;;;;AASnD,MAAa,YAAyCC;;;;;;;;AAStD,MAAa,YAA0CC;AAEvD,MAAa,MAkBTC;;;;;;;;AASJ,MAAa,aAA+DC;;;;;;;AAQ5E,MAAa,UAAmCC;;;;;;AAOhD,MAAa,OAAO,KAAK,EAAE;;;;;;AAO3B,MAAa,OAAO,KAAK,EAAE;AAE3B,MAAa,MAmBTC;AAEJ,MAAa,WAkBTC;AAEJ,MAAa,WAkBTC;AAEJ,MAAa,QAkBTC;;;;;;;;AASJ,MAAa,OAA+BC;AAE5C,MAAa,OAkBTC;AAEJ,MAAa,OAkBTC;;;;;;;;AASJ,MAAa,OAA+BC;AAE5C,MAAa,OAkBTC;AAEJ,MAAa,OAkBTC;;;;;;;;AASJ,MAAa,OAA+BC;AAE5C,MAAa,OAkBTC;AAEJ,MAAa,OAkBTC;;;;;;;;AASJ,MAAa,OAA+BC;AAE5C,MAAa,OAkBTC;AAEJ,MAAa,OAkBTC"}

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`.
  *