curvy 1.0.8 → 2.0.0-alpha.0

package/dist/shared/vector2.internal-DU_E808S.mjs

@@ -0,0 +1,97 @@
+import { Pipeable, dual, invariant } from "../utils.mjs";
+import { epsEquals } from "../number.mjs";
+//#region src/vector/vector2.internal.ts
+const Vector2TypeId = Symbol.for("curvy/vector2");
+const WeightedVector2TypeId = Symbol.for("curvy/vector2/weighted");
+var Vector2Impl = class extends Pipeable {
+	[Vector2TypeId] = Vector2TypeId;
+	x;
+	y;
+	constructor(v0 = 0, v1 = 0) {
+		super();
+		this.x = v0;
+		this.y = v1;
+	}
+	get [0]() {
+		return this.x;
+	}
+	get [1]() {
+		return this.y;
+	}
+	get [Symbol.toStringTag]() {
+		return `Vector2(${this.x}, ${this.y})`;
+	}
+	get [Symbol.for("nodejs.util.inspect.custom")]() {
+		return this[Symbol.toStringTag];
+	}
+};
+var WeightedImpl = class extends Pipeable {
+	[WeightedVector2TypeId] = WeightedVector2TypeId;
+	x;
+	y;
+	weight;
+	constructor(x, y, weight) {
+		super();
+		this.x = x;
+		this.y = y;
+		this.weight = weight;
+	}
+	get [Symbol.toStringTag]() {
+		return `Vector2.Weighted(${this.x}, ${this.y}, w=${this.weight})`;
+	}
+	get [Symbol.for("nodejs.util.inspect.custom")]() {
+		return this[Symbol.toStringTag];
+	}
+};
+const isVector2 = (v) => typeof v === "object" && v !== null && Vector2TypeId in v;
+const isWeighted = (v) => typeof v === "object" && v !== null && WeightedVector2TypeId in v;
+const equals = dual(2, (a, b) => epsEquals(a.x, b.x) && epsEquals(a.y, b.y));
+const make = (v0, v1 = v0) => new Vector2Impl(v0, v1);
+const transpose = (inputs, project) => {
+	const a = project(inputs[0]);
+	const b = project(inputs[1]);
+	const result = [];
+	for (let i = 0; i < a.length; i++) result.push(make(a[i], b[i]));
+	return result;
+};
+const makeWeighted = (x, y, weight) => {
+	invariant(Number.isFinite(weight) && weight > 0, "Vector2.Weighted weight must be positive and finite");
+	return new WeightedImpl(x, y, weight);
+};
+const withWeight = dual(2, (v, weight) => makeWeighted(v.x, v.y, weight));
+const unweighted = (w) => make(w.x, w.y);
+const weightedEquals = dual(2, (a, b) => epsEquals(a.x, b.x) && epsEquals(a.y, b.y) && epsEquals(a.weight, b.weight));
+const fromPolar = (r, theta) => make(r * Math.cos(theta), r * Math.sin(theta));
+const components = (v) => [v.x, v.y];
+const magnitude = (vector) => Math.hypot(vector.x, vector.y);
+const normalize = (vector) => {
+	const m = magnitude(vector);
+	return make(vector.x / m, vector.y / m);
+};
+const dot = dual(2, (a, b) => a.x * b.x + a.y * b.y);
+const cross = dual(2, (a, b) => a.x * b.y - a.y * b.x);
+const softmax = (v) => {
+	const max = Math.max(v.x, v.y);
+	const v0 = Math.exp(v.x - max);
+	const v1 = Math.exp(v.y - max);
+	const sum = v0 + v1;
+	return make(v0 / sum, v1 / sum);
+};
+const add = dual(2, (a, b) => make(a.x + b.x, a.y + b.y));
+const subtract = dual(2, (a, b) => make(a.x - b.x, a.y - b.y));
+const hadamard = dual(2, (a, b) => make(a.x * b.x, a.y * b.y));
+const scale = dual(2, (v, s) => s === 1 ? v : make(v.x * s, v.y * s));
+const getX = (v) => v.x;
+const setX = dual(2, (v, x) => make(x, v.y));
+const getY = (v) => v.y;
+const setY = dual(2, (v, y) => make(v.x, y));
+const setR = dual(2, (v, r) => scale(r / magnitude(v))(v));
+const getTheta = (v) => Math.atan2(v.y, v.x);
+const setTheta = dual(2, (v, theta) => {
+	const r = magnitude(v);
+	return make(r * Math.cos(theta), r * Math.sin(theta));
+});
+//#endregion
+export { subtract as C, withWeight as D, weightedEquals as E, softmax as S, unweighted as T, scale as _, equals as a, setX as b, getX as c, isVector2 as d, isWeighted as f, normalize as g, makeWeighted as h, dot as i, getY as l, make as m, components as n, fromPolar as o, magnitude as p, cross as r, getTheta as s, add as t, hadamard as u, setR as v, transpose as w, setY as x, setTheta as y };
+
+//# sourceMappingURL=vector2.internal-DU_E808S.mjs.map

package/dist/shared/vector2.internal-DU_E808S.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"vector2.internal-DU_E808S.mjs","names":[],"sources":["../../src/vector/vector2.internal.ts"],"sourcesContent":["import { dual, Pipeable } from '../utils'\nimport { invariant } from '../utils'\nimport { epsEquals } from '../number'\nimport type { Vector2, Weighted } from './vector2'\n\nexport const Vector2TypeId = Symbol.for('curvy/vector2')\nexport type Vector2TypeId = typeof Vector2TypeId\n\nexport const WeightedVector2TypeId = Symbol.for('curvy/vector2/weighted')\nexport type WeightedVector2TypeId = typeof WeightedVector2TypeId\n\nclass Vector2Impl extends Pipeable implements Vector2 {\n  readonly [Vector2TypeId]: Vector2TypeId = Vector2TypeId\n\n  readonly x: number\n  readonly y: number\n\n  constructor(v0 = 0, v1 = 0) {\n    super()\n    this.x = v0\n    this.y = v1\n  }\n\n  get [0]() {\n    return this.x\n  }\n\n  get [1]() {\n    return this.y\n  }\n\n  get [Symbol.toStringTag]() {\n    return `Vector2(${this.x}, ${this.y})`\n  }\n\n  get [Symbol.for('nodejs.util.inspect.custom')]() {\n    return this[Symbol.toStringTag]\n  }\n}\n\nclass WeightedImpl extends Pipeable implements Weighted {\n  readonly [WeightedVector2TypeId]: WeightedVector2TypeId = WeightedVector2TypeId\n\n  readonly x: number\n  readonly y: number\n  readonly weight: number\n\n  constructor(x: number, y: number, weight: number) {\n    super()\n    this.x = x\n    this.y = y\n    this.weight = weight\n  }\n\n  get [Symbol.toStringTag]() {\n    return `Vector2.Weighted(${this.x}, ${this.y}, w=${this.weight})`\n  }\n\n  get [Symbol.for('nodejs.util.inspect.custom')]() {\n    return this[Symbol.toStringTag]\n  }\n}\n\nexport const isVector2 = (v: unknown): v is Vector2 =>\n  typeof v === 'object' && v !== null && Vector2TypeId in v\n\nexport const isWeighted = (v: unknown): v is Weighted =>\n  typeof v === 'object' && v !== null && WeightedVector2TypeId in v\n\nexport const equals = dual<\n  (b: Vector2) => (a: Vector2) => boolean,\n  (a: Vector2, b: Vector2) => boolean\n>(2, (a: Vector2, b: Vector2) => epsEquals(a.x, b.x) && epsEquals(a.y, b.y))\n\nexport const make = (v0: number, v1 = v0): Vector2 => new Vector2Impl(v0, v1)\n\nexport const transpose = <T, const Channels extends ReadonlyArray<number>>(\n  inputs: readonly [T, T],\n  project: (item: T) => Channels,\n): { readonly [K in keyof Channels]: Vector2 } => {\n  const a = project(inputs[0])\n  const b = project(inputs[1])\n  const result: Array<Vector2> = []\n  for (let i = 0; i < a.length; i++) {\n    result.push(make(a[i] as number, b[i] as number))\n  }\n  return result as never\n}\n\nexport const makeWeighted = (x: number, y: number, weight: number): Weighted => {\n  invariant(\n    Number.isFinite(weight) && weight > 0,\n    'Vector2.Weighted weight must be positive and finite',\n  )\n  return new WeightedImpl(x, y, weight)\n}\n\nexport const withWeight = dual<\n  (weight: number) => (v: Vector2) => Weighted,\n  (v: Vector2, weight: number) => Weighted\n>(2, (v: Vector2, weight: number) => makeWeighted(v.x, v.y, weight))\n\nexport const unweighted = (w: Weighted): Vector2 => make(w.x, w.y)\n\nexport const weightedEquals = dual<\n  (b: Weighted) => (a: Weighted) => boolean,\n  (a: Weighted, b: Weighted) => boolean\n>(\n  2,\n  (a: Weighted, b: Weighted) =>\n    epsEquals(a.x, b.x) && epsEquals(a.y, b.y) && epsEquals(a.weight, b.weight),\n)\n\nexport const fromPolar = (r: number, theta: number) =>\n  make(r * Math.cos(theta), r * Math.sin(theta))\n\nexport const components = (v: Vector2): [number, number] => [v.x, v.y]\n\nexport const magnitude = (vector: Vector2) => Math.hypot(vector.x, vector.y)\n\nexport const normalize = (vector: Vector2) => {\n  const m = magnitude(vector)\n\n  return make(vector.x / m, vector.y / m)\n}\n\nexport const dot = dual<(b: Vector2) => (a: Vector2) => number, (a: Vector2, b: Vector2) => number>(\n  2,\n  (a: Vector2, b: Vector2) => a.x * b.x + a.y * b.y,\n)\n\nexport const cross = dual<\n  (b: Vector2) => (a: Vector2) => number,\n  (a: Vector2, b: Vector2) => number\n>(2, (a: Vector2, b: Vector2) => a.x * b.y - a.y * b.x)\n\nexport const softmax = (v: Vector2) => {\n  const max = Math.max(v.x, v.y)\n\n  const v0 = Math.exp(v.x - max)\n  const v1 = Math.exp(v.y - max)\n\n  const sum = v0 + v1\n\n  return make(v0 / sum, v1 / sum)\n}\n\nexport const add = dual<\n  (b: Vector2) => (a: Vector2) => Vector2,\n  (a: Vector2, b: Vector2) => Vector2\n>(2, (a: Vector2, b: Vector2) => make(a.x + b.x, a.y + b.y))\n\nexport const subtract = dual<\n  (b: Vector2) => (a: Vector2) => Vector2,\n  (a: Vector2, b: Vector2) => Vector2\n>(2, (a: Vector2, b: Vector2) => make(a.x - b.x, a.y - b.y))\n\nexport const hadamard = dual<\n  (b: Vector2) => (a: Vector2) => Vector2,\n  (a: Vector2, b: Vector2) => Vector2\n>(2, (a: Vector2, b: Vector2) => make(a.x * b.x, a.y * b.y))\n\nexport const scale = dual<\n  (s: number) => (v: Vector2) => Vector2,\n  (v: Vector2, s: number) => Vector2\n>(2, (v: Vector2, s: number) => (s === 1 ? v : make(v.x * s, v.y * s)))\n\nexport const getX = (v: Vector2) => v.x\nexport const setX = dual<\n  (x: number) => (v: Vector2) => Vector2,\n  (v: Vector2, x: number) => Vector2\n>(2, (v: Vector2, x: number) => make(x, v.y))\n\nexport const getY = (v: Vector2) => v.y\nexport const setY = dual<\n  (y: number) => (v: Vector2) => Vector2,\n  (v: Vector2, y: number) => Vector2\n>(2, (v: Vector2, y: number) => make(v.x, y))\n\nexport const setR = dual<\n  (r: number) => (v: Vector2) => Vector2,\n  (v: Vector2, r: number) => Vector2\n>(2, (v: Vector2, r: number) => scale(r / magnitude(v))(v))\n\nexport const getTheta = (v: Vector2) => Math.atan2(v.y, v.x)\nexport const setTheta = dual<\n  (theta: number) => (v: Vector2) => Vector2,\n  (v: Vector2, theta: number) => Vector2\n>(2, (v: Vector2, theta: number) => {\n  const r = magnitude(v)\n  return make(r * Math.cos(theta), r * Math.sin(theta))\n})\n"],"mappings":"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"}

package/dist/shared/vector3-D-tv_aKL.mjs

@@ -0,0 +1,204 @@
+import { t as __exportAll } from "./chunk-25Hzd3z8.mjs";
+import { A as scale$1, C as getY$1, D as magnitude$1, E as isVector3$1, F as setY$1, I as setZ$1, L as softmax$1, M as setR$1, N as setTheta$1, O as make$1, P as setX$1, R as subtract$1, S as getX$1, T as hadamard$1, _ as dot$1, b as getPhi$1, g as cross$1, h as components$1, j as setPhi$1, k as normalize$1, m as add$1, v as equals$1, w as getZ$1, x as getTheta$1, y as fromSpherical$1, z as transpose$1 } from "./vector4.internal-5XcaX12X.mjs";
+//#region src/vector/vector3.ts
+var vector3_exports = /* @__PURE__ */ __exportAll({
+	add: () => add,
+	components: () => components,
+	cross: () => cross,
+	dot: () => dot,
+	equals: () => equals,
+	fromSpherical: () => fromSpherical,
+	getPhi: () => getPhi,
+	getR: () => getR,
+	getTheta: () => getTheta,
+	getX: () => getX,
+	getY: () => getY,
+	getZ: () => getZ,
+	hadamard: () => hadamard,
+	isVector3: () => isVector3,
+	length: () => length,
+	magnitude: () => magnitude,
+	make: () => make,
+	normalize: () => normalize,
+	scale: () => scale,
+	setPhi: () => setPhi,
+	setR: () => setR,
+	setTheta: () => setTheta,
+	setX: () => setX,
+	setY: () => setY,
+	setZ: () => setZ,
+	softmax: () => softmax,
+	subtract: () => subtract,
+	transpose: () => transpose,
+	unit: () => unit,
+	unitX: () => unitX,
+	unitY: () => unitY,
+	unitZ: () => unitZ,
+	zero: () => zero
+});
+/**
+* Checks if a value is a `Vector3`.
+*
+* @param v - The value to check.
+* @returns `true` if the value is a `Vector3`, `false` otherwise.
+* @since 1.0.0
+*/
+const isVector3 = isVector3$1;
+const equals = equals$1;
+const make = make$1;
+/**
+* Transposes a 3-tuple of items into one or more `Vector3`s, one per channel
+* extracted by the projection function. See {@link Vector4.transpose} for the
+* full operation description; this is the 3-component analog.
+*
+* @param inputs - Exactly three items of any type.
+* @param project - A function returning a fixed-arity tuple of numbers — one per output channel.
+* @returns A tuple of `Vector3`s with the same arity as the projection's return tuple.
+* @since 2.1.0
+*/
+const transpose = transpose$1;
+/**
+* Creates a new `Vector3` instance from spherical coordinates.
+*
+* @param r - The radius.
+* @param theta - The polar angle, in radians. Ranges from 0 to π
+* @param phi - The azimuthal angle, in radians. Ranges from 0 to 2π
+* @returns A new `Vector3` instance.
+* @since 1.0.0
+*/
+const fromSpherical = fromSpherical$1;
+/**
+* Calculates the magnitude of a `Vector3`.
+*
+* @param vector - The vector to calculate the magnitude of.
+* @returns The magnitude of the vector.
+* @since 1.0.0
+*/
+const magnitude = magnitude$1;
+/**
+* Calculates the length of a `Vector3`.
+*
+* @param vector - The vector to calculate the length of.
+* @returns The length of the vector.
+* @see {@link magnitude}
+* @since 1.0.0
+*/
+const length = magnitude;
+/**
+* Normalizes a `Vector3`.
+*
+* @param vector - The vector to normalize.
+* @returns A new `Vector3` instance with the same direction as the input vector, but with a magnitude of 1.
+* @since 1.0.0
+*/
+const normalize = normalize$1;
+const dot = dot$1;
+const cross = cross$1;
+/**
+* Returns the components of a `Vector3` as an array.
+*
+* @param v - The vector to get the components of.
+* @returns An array containing the x, y, and z components of the vector.
+* @since 1.0.0
+*/
+const components = components$1;
+/**
+* Calculates the softmax of a `Vector3`.
+*
+* @param v - The vector to calculate the softmax of.
+* @returns A new `Vector3` instance representing the softmax of the input vector.
+* @since 1.0.0
+*/
+const softmax = softmax$1;
+/**
+* Creates a zero vector.
+*
+* @since 1.0.0
+*/
+const zero = make(0);
+/**
+* Creates a unit vector.
+*
+* @since 1.0.0
+*/
+const unit = make(1);
+/**
+* Creates a unit vector in the x direction.
+*
+* @since 1.0.0
+*/
+const unitX = make(1, 0, 0);
+/**
+* Creates a unit vector in the y direction.
+*
+* @since 1.0.0
+*/
+const unitY = make(0, 1, 0);
+/**
+* Creates a unit vector in the z direction.
+*
+* @since 1.0.0
+*/
+const unitZ = make(0, 0, 1);
+const add = add$1;
+const subtract = subtract$1;
+const hadamard = hadamard$1;
+const scale = scale$1;
+/**
+* Gets the x component of a `Vector3`.
+*
+* @param v - The vector to get the x component of.
+* @returns The x component of the vector.
+* @since 1.0.0
+*/
+const getX = getX$1;
+const setX = setX$1;
+/**
+* Gets the y component of a `Vector3`.
+*
+* @param v - The vector of which to get the y component.
+* @returns The y component of the vector.
+* @since 1.0.0
+*/
+const getY = getY$1;
+const setY = setY$1;
+/**
+* Gets the z component of a `Vector3`.
+*
+* @param v - The vector of which to get the z component.
+* @returns The z component of the vector.
+* @since 1.0.0
+*/
+const getZ = getZ$1;
+const setZ = setZ$1;
+/**
+* Gets the radius of a `Vector3`.
+*
+* @param v - The vector of which to get the radius.
+* @returns The radius of the vector.
+* @since 1.0.0
+*/
+const getR = magnitude;
+const setR = setR$1;
+/**
+* Gets the polar angle (theta) of a `Vector3`.
+*
+* @param v - The vector of which to get the polar angle.
+* @returns The polar angle of the vector.
+* @since 1.0.0
+*/
+const getTheta = getTheta$1;
+const setTheta = setTheta$1;
+/**
+* Gets the azimuthal angle (phi) of a `Vector3`.
+*
+* @param v - The vector of which to get the azimuthal angle.
+* @returns The azimuthal angle of the vector.
+* @since 1.0.0
+*/
+const getPhi = getPhi$1;
+const setPhi = setPhi$1;
+//#endregion
+export { vector3_exports as n, make as t };
+
+//# sourceMappingURL=vector3-D-tv_aKL.mjs.map

package/dist/shared/vector3-D-tv_aKL.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"vector3-D-tv_aKL.mjs","names":["internal.isVector3","internal.equals","internal.make","internal.transpose","internal.fromSpherical","internal.magnitude","internal.normalize","internal.dot","internal.cross","internal.components","internal.softmax","internal.add","internal.subtract","internal.hadamard","internal.scale","internal.getX","internal.setX","internal.getY","internal.setY","internal.getZ","internal.setZ","internal.setR","internal.getTheta","internal.setTheta","internal.getPhi","internal.setPhi"],"sources":["../../src/vector/vector3.ts"],"sourcesContent":["import type { ThreeDimensional } from '../dimensions'\nimport type { Pipeable } from '../utils'\nimport type { Vector3TypeId } from './vector3.internal'\nimport * as internal from './vector3.internal'\n\n/**\n * A 3D vector.\n *\n * All fields are readonly and immutable, and all operations create new instances.\n *\n * @since 1.0.0\n */\nexport interface Vector3 extends Pipeable, ThreeDimensional<number> {\n  readonly [Vector3TypeId]: Vector3TypeId\n}\n\n/**\n * Checks if a value is a `Vector3`.\n *\n * @param v - The value to check.\n * @returns `true` if the value is a `Vector3`, `false` otherwise.\n * @since 1.0.0\n */\nexport const isVector3: (v: unknown) => v is Vector3 = internal.isVector3\n\nexport const equals: {\n  /**\n   * Checks if two `Vector3` 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: Vector3, b: Vector3): boolean\n  /**\n   * Checks if two `Vector3` 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: Vector3): (a: Vector3) => boolean\n} = internal.equals\n\nexport const make: {\n  /**\n   * Creates a new `Vector3` instance.\n   *\n   * @param xyz - The x, y, and z components of the vector.\n   * @returns A new `Vector3` instance.\n   * @since 1.0.0\n   */\n  (xyz: number): Vector3\n  /**\n   * Creates a new `Vector3` instance.\n   *\n   * @param x - The x component of the vector.\n   * @param yz - The y and z components of the vector.\n   * @returns A new `Vector3` instance.\n   * @since 1.0.0\n   */\n  (x: number, yz: number): Vector3\n  /**\n   * Creates a new `Vector3` 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   * @returns A new `Vector3` instance.\n   * @since 1.0.0\n   */\n  (x: number, y: number, z: number): Vector3\n} = internal.make\n\n/**\n * Transposes a 3-tuple of items into one or more `Vector3`s, one per channel\n * extracted by the projection function. See {@link Vector4.transpose} for the\n * full operation description; this is the 3-component analog.\n *\n * @param inputs - Exactly three 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 `Vector3`s with the same arity as the projection's return tuple.\n * @since 2.1.0\n */\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 } = internal.transpose\n\n/**\n * Creates a new `Vector3` instance from spherical coordinates.\n *\n * @param r - The radius.\n * @param theta - The polar angle, in radians. Ranges from 0 to π\n * @param phi - The azimuthal angle, in radians. Ranges from 0 to 2π\n * @returns A new `Vector3` instance.\n * @since 1.0.0\n */\nexport const fromSpherical: (r: number, theta: number, phi: number) => Vector3 =\n  internal.fromSpherical\n\n/**\n * Calculates the magnitude of a `Vector3`.\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: Vector3) => number = internal.magnitude\n\n/**\n * Calculates the length of a `Vector3`.\n *\n * @param vector - The vector to calculate the length of.\n * @returns The length of the vector.\n * @see {@link magnitude}\n * @since 1.0.0\n */\nexport const length: (vector: Vector3) => number = magnitude\n\n/**\n * Normalizes a `Vector3`.\n *\n * @param vector - The vector to normalize.\n * @returns A new `Vector3` 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: Vector3) => Vector3 = internal.normalize\n\nexport const dot: {\n  /**\n   * Calculates the dot product of two `Vector3` 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: Vector3, b: Vector3): number\n  /**\n   * Calculates the dot product of two `Vector3` instances.\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: Vector3): (a: Vector3) => number\n} = internal.dot\n\nexport const cross: {\n  /**\n   * Calculates the cross product of two `Vector3` instances.\n   *\n   * @param a - The first vector.\n   * @param b - The second vector.\n   * @returns A new `Vector3` instance representing the cross product of the two vectors.\n   * @since 1.0.0\n   */\n  (a: Vector3, b: Vector3): Vector3\n  /**\n   * Calculates the cross product of two `Vector3` instances.\n   *\n   * @param b - The second vector.\n   * @returns A function that takes the first vector and returns the cross product.\n   * @since 1.0.0\n   */\n  (b: Vector3): (a: Vector3) => Vector3\n} = internal.cross\n\n/**\n * Returns the components of a `Vector3` as an array.\n *\n * @param v - The vector to get the components of.\n * @returns An array containing the x, y, and z components of the vector.\n * @since 1.0.0\n */\nexport const components: (v: Vector3) => [number, number, number] = internal.components\n\n/**\n * Calculates the softmax of a `Vector3`.\n *\n * @param v - The vector to calculate the softmax of.\n * @returns A new `Vector3` instance representing the softmax of the input vector.\n * @since 1.0.0\n */\nexport const softmax: (v: Vector3) => Vector3 = 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\n/**\n * Creates a unit vector in the x direction.\n *\n * @since 1.0.0\n */\nexport const unitX = make(1, 0, 0)\n\n/**\n * Creates a unit vector in the y direction.\n *\n * @since 1.0.0\n */\nexport const unitY = make(0, 1, 0)\n\n/**\n * Creates a unit vector in the z direction.\n *\n * @since 1.0.0\n */\nexport const unitZ = make(0, 0, 1)\n\nexport const add: {\n  /**\n   * Adds two `Vector3` instances.\n   *\n   * @param a - The first vector.\n   * @param b - The second vector.\n   * @returns A new `Vector3` instance representing the sum of the two vectors.\n   * @since 1.0.0\n   */\n  (a: Vector3, b: Vector3): Vector3\n  /**\n   * Adds two `Vector3` instances.\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: Vector3): (a: Vector3) => Vector3\n} = internal.add\n\nexport const subtract: {\n  /**\n   * Subtracts one `Vector3` instance from another.\n   *\n   * @param a - The vector to subtract from.\n   * @param b - The vector to subtract.\n   * @returns A new `Vector3` instance representing the difference of the two vectors.\n   * @since 1.0.0\n   */\n  (a: Vector3, b: Vector3): Vector3\n  /**\n   * Subtracts one `Vector3` instance from another.\n   *\n   * @param b - The vector to subtract.\n   * @returns A function that takes the first vector and returns the difference.\n   * @since 1.0.0\n   */\n  (b: Vector3): (a: Vector3) => Vector3\n} = internal.subtract\n\nexport const hadamard: {\n  /**\n   * Calculates the Hadamard product of two `Vector3` instances.\n   *\n   * The Hadamard product is an element-wise multiplication of two vectors.\n   *\n   * @param a - The first vector.\n   * @param b - The second vector.\n   * @returns A new `Vector3` instance representing the Hadamard product of the two vectors.\n   * @since 1.0.0\n   */\n  (a: Vector3, b: Vector3): Vector3\n  /**\n   * Calculates the Hadamard product of two `Vector3` instances.\n   *\n   * The Hadamard product is an element-wise multiplication of two vectors.\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: Vector3): (a: Vector3) => Vector3\n} = internal.hadamard\n\nexport const scale: {\n  /**\n   * Scales a `Vector3` instance by a scalar value.\n   *\n   * @param s - The scalar value to scale by.\n   * @return A function that takes a vector and returns the scaled vector.\n   * @since 1.0.0\n   */\n  (s: number): (v: Vector3) => Vector3\n  /**\n   * Scales a `Vector3` instance by a scalar value.\n   *\n   * @param s - The scalar value to scale by.\n   * @param v - The vector to scale.\n   * @returns A new `Vector3` instance representing the scaled vector.\n   * @since 1.0.0\n   */\n  (v: Vector3, s: number): Vector3\n} = internal.scale\n\n/**\n * Gets the x component of a `Vector3`.\n *\n * @param v - The vector to get the x component of.\n * @returns The x component of the vector.\n * @since 1.0.0\n */\nexport const getX: (v: Vector3) => number = internal.getX\n\nexport const setX: {\n  /**\n   * Sets the x component of a `Vector3`.\n   *\n   * @param v - The vector to set the x component of.\n   * @param x - The new x component.\n   * @returns A new `Vector3` instance with the updated x component.\n   * @since 1.0.0\n   */\n  (v: Vector3, x: number): Vector3\n  /**\n   * Sets the x component of a `Vector3`.\n   *\n   * @param x - The new x component.\n   * @returns A function that takes the vector and returns a new `Vector3` instance with the updated x component.\n   * @since 1.0.0\n   */\n  (x: number): (v: Vector3) => Vector3\n} = internal.setX\n\n/**\n * Gets the y component of a `Vector3`.\n *\n * @param v - The vector of which to get the y component.\n * @returns The y component of the vector.\n * @since 1.0.0\n */\nexport const getY: (v: Vector3) => number = internal.getY\n\nexport const setY: {\n  /**\n   * Sets the y component of a `Vector3`.\n   *\n   * @param v - The vector of which to set the y component.\n   * @param y - The new y component.\n   * @returns A new `Vector3` instance with the updated y component.\n   * @since 1.0.0\n   */\n  (v: Vector3, y: number): Vector3\n  /**\n   * Sets the y component of a `Vector3`.\n   *\n   * @param y - The new y component.\n   * @returns A function that takes the vector and returns a new `Vector3` instance with the updated y component.\n   * @since 1.0.0\n   */\n  (y: number): (v: Vector3) => Vector3\n} = internal.setY\n\n/**\n * Gets the z component of a `Vector3`.\n *\n * @param v - The vector of which to get the z component.\n * @returns The z component of the vector.\n * @since 1.0.0\n */\nexport const getZ: (v: Vector3) => number = internal.getZ\n\nexport const setZ: {\n  /**\n   * Sets the z component of a `Vector3`.\n   *\n   * @param v - The vector of which to set the z component.\n   * @param z - The new z component.\n   * @returns A new `Vector3` instance with the updated z component.\n   * @since 1.0.0\n   */\n  (v: Vector3, z: number): Vector3\n  /**\n   * Sets the z component of a `Vector3`.\n   *\n   * @param z - The new z component.\n   * @returns A function that takes the vector and returns a new `Vector3` instance with the updated z component.\n   * @since 1.0.0\n   */\n  (z: number): (v: Vector3) => Vector3\n} = internal.setZ\n\n/**\n * Gets the radius of a `Vector3`.\n *\n * @param v - The vector of which to get the radius.\n * @returns The radius of the vector.\n * @since 1.0.0\n */\nexport const getR: (v: Vector3) => number = magnitude\n\nexport const setR: {\n  /**\n   * Sets the radius of a `Vector3`.\n   *\n   * @param v - The vector of which to set the radius.\n   * @param r - The new radius.\n   * @returns A new `Vector3` instance with the updated radius.\n   * @since 1.0.0\n   */\n  (v: Vector3, r: number): Vector3\n  /**\n   * Sets the radius of a `Vector3`.\n   *\n   * @param r - The new radius.\n   * @returns A function that takes the vector and returns the updated vector.\n   * @since 1.0.0\n   */\n  (r: number): (v: Vector3) => Vector3\n} = internal.setR\n\n/**\n * Gets the polar angle (theta) of a `Vector3`.\n *\n * @param v - The vector of which to get the polar angle.\n * @returns The polar angle of the vector.\n * @since 1.0.0\n */\nexport const getTheta: (v: Vector3) => number = internal.getTheta\n\nexport const setTheta: {\n  /**\n   * Sets the polar angle (theta) of a `Vector3`.\n   *\n   * @param v - The vector of which to set the polar angle.\n   * @param theta - The new polar angle.\n   * @returns A new `Vector3` instance with the updated polar angle.\n   * @since 1.0.0\n   */\n  (v: Vector3, theta: number): Vector3\n  /**\n   * Sets the polar angle (theta) of a `Vector3`.\n   *\n   * @param theta - The new polar angle.\n   * @returns A function that takes the vector and returns the updated vector.\n   * @since 1.0.0\n   */\n  (theta: number): (v: Vector3) => Vector3\n} = internal.setTheta\n\n/**\n * Gets the azimuthal angle (phi) of a `Vector3`.\n *\n * @param v - The vector of which to get the azimuthal angle.\n * @returns The azimuthal angle of the vector.\n * @since 1.0.0\n */\nexport const getPhi: (v: Vector3) => number = internal.getPhi\n\nexport const setPhi: {\n  /**\n   * Sets the azimuthal angle (phi) of a `Vector3`.\n   *\n   * @param v - The vector of which to set the azimuthal angle.\n   * @param phi - The new azimuthal angle.\n   * @returns A new `Vector3` instance with the updated azimuthal angle.\n   * @since 1.0.0\n   */\n  (v: Vector3, phi: number): Vector3\n  /**\n   * Sets the azimuthal angle (phi) of a `Vector3`.\n   *\n   * @param phi - The new azimuthal angle.\n   * @returns A function that takes the vector and returns the updated vector.\n   * @since 1.0.0\n   */\n  (phi: number): (v: Vector3) => Vector3\n} = internal.setPhi\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuBA,MAAa,YAA0CA;AAEvD,MAAa,SAoBTC;AAEJ,MAAa,OA4BTC;;;;;;;;;;;AAYJ,MAAa,YAGsCC;;;;;;;;;;AAWnD,MAAa,gBACXC;;;;;;;;AASF,MAAa,YAAyCC;;;;;;;;;AAUtD,MAAa,SAAsC;;;;;;;;AASnD,MAAa,YAA0CC;AAEvD,MAAa,MAkBTC;AAEJ,MAAa,QAkBTC;;;;;;;;AASJ,MAAa,aAAuDC;;;;;;;;AASpE,MAAa,UAAmCC;;;;;;AAOhD,MAAa,OAAO,KAAK,EAAE;;;;;;AAO3B,MAAa,OAAO,KAAK,EAAE;;;;;;AAO3B,MAAa,QAAQ,KAAK,GAAG,GAAG,EAAE;;;;;;AAOlC,MAAa,QAAQ,KAAK,GAAG,GAAG,EAAE;;;;;;AAOlC,MAAa,QAAQ,KAAK,GAAG,GAAG,EAAE;AAElC,MAAa,MAkBTC;AAEJ,MAAa,WAkBTC;AAEJ,MAAa,WAsBTC;AAEJ,MAAa,QAkBTC;;;;;;;;AASJ,MAAa,OAA+BC;AAE5C,MAAa,OAkBTC;;;;;;;;AASJ,MAAa,OAA+BC;AAE5C,MAAa,OAkBTC;;;;;;;;AASJ,MAAa,OAA+BC;AAE5C,MAAa,OAkBTC;;;;;;;;AASJ,MAAa,OAA+B;AAE5C,MAAa,OAkBTC;;;;;;;;AASJ,MAAa,WAAmCC;AAEhD,MAAa,WAkBTC;;;;;;;;AASJ,MAAa,SAAiCC;AAE9C,MAAa,SAkBTC"}

package/dist/shared/vector4-5KbjoHVj.mjs

@@ -0,0 +1,109 @@
+import { t as __exportAll } from "./chunk-25Hzd3z8.mjs";
+import { a as hadamard$1, c as make$1, d as softmax$1, f as subtract$1, i as equals$1, l as normalize$1, n as components$1, o as isVector4$1, p as transpose$1, r as dot$1, s as magnitude$1, t as add$1, u as scale$1 } from "./vector4.internal-5XcaX12X.mjs";
+//#region src/vector/vector4.ts
+var vector4_exports = /* @__PURE__ */ __exportAll({
+	add: () => add,
+	components: () => components,
+	dot: () => dot,
+	equals: () => equals,
+	hadamard: () => hadamard,
+	isVector4: () => isVector4,
+	magnitude: () => magnitude,
+	make: () => make,
+	normalize: () => normalize,
+	scale: () => scale,
+	softmax: () => softmax,
+	subtract: () => subtract,
+	transpose: () => transpose,
+	unit: () => unit,
+	zero: () => zero
+});
+/**
+* Checks if a value is a `Vector4`.
+*
+* @param v - The value to check.
+* @returns `true` if the value is a `Vector4`, `false` otherwise.
+* @since 1.0.0
+*/
+const isVector4 = isVector4$1;
+const equals = equals$1;
+const make = make$1;
+/**
+* Transposes a 4-tuple of items into one or more `Vector4`s, one per channel
+* extracted by the projection function.
+*
+* For each output channel, takes the corresponding number from each of the
+* four projected items and packs them into a `Vector4` — the data-layout
+* transformation NumPy calls a transpose, FP calls `unzip`, GPUs call a
+* gather, and DSP people inexplicably call deinterleaving.
+*
+* The projection's return-tuple arity determines the number of output
+* vectors, and that arity is preserved in the return type.
+*
+* @example
+* ```ts
+* // Pack the x and y coordinates of four control points into two Vector4s.
+* const [xs, ys] = Vector4.transpose(
+*   [p0, p1, p2, p3],
+*   (p) => [p.x, p.y],
+* )
+* ```
+*
+* @param inputs - Exactly four items of any type.
+* @param project - A function returning a fixed-arity tuple of numbers — one per output channel.
+* @returns A tuple of `Vector4`s with the same arity as the projection's return tuple.
+* @since 2.1.0
+*/
+const transpose = transpose$1;
+/**
+* Gets the magnitude of a `Vector4`.
+*
+* @param vector - The vector to calculate the magnitude of.
+* @returns The magnitude of the vector.
+* @since 1.0.0
+*/
+const magnitude = magnitude$1;
+/**
+* Normalizes a `Vector4`.
+*
+* @param vector - The vector to normalize.
+* @returns A new `Vector4` instance with the same direction as the input vector but with a magnitude of 1.
+* @since 1.0.0
+*/
+const normalize = normalize$1;
+const dot = dot$1;
+/**
+* Returns the components of a `Vector4` as an array.
+*
+* @param v - The vector to get the components of.
+* @returns An array containing the x, y, z, and w components of the vector.
+* @since 1.0.0
+*/
+const components = components$1;
+/**
+* Applies the softmax function to a `Vector4`.
+*
+* @param v - The vector to calculate the softmax of.
+* @returns A new `Vector4` instance representing the softmax of the input vector.
+*/
+const softmax = softmax$1;
+/**
+* Creates a zero vector.
+*
+* @since 1.0.0
+*/
+const zero = make(0);
+/**
+* Creates a unit vector.
+*
+* @since 1.0.0
+*/
+const unit = make(1);
+const add = add$1;
+const subtract = subtract$1;
+const hadamard = hadamard$1;
+const scale = scale$1;
+//#endregion
+export { transpose as n, vector4_exports as r, make as t };
+
+//# sourceMappingURL=vector4-5KbjoHVj.mjs.map

package/dist/shared/vector4-5KbjoHVj.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"vector4-5KbjoHVj.mjs","names":["internal.isVector4","internal.equals","internal.make","internal.transpose","internal.magnitude","internal.normalize","internal.dot","internal.components","internal.softmax","internal.add","internal.subtract","internal.hadamard","internal.scale"],"sources":["../../src/vector/vector4.ts"],"sourcesContent":["import type { FourDimensional } from '../dimensions'\nimport type { Pipeable } from '../utils'\nimport type { Vector4TypeId } from './vector4.internal'\nimport * as internal from './vector4.internal'\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 * 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.1.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"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AAuBA,MAAa,YAA0CA;AAEvD,MAAa,SAoBTC;AAEJ,MAAa,OAuCTC;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BJ,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"}

package/dist/shared/vector4.internal-5XcaX12X.mjs

@@ -0,0 +1,163 @@
+import { Pipeable, dual } from "../utils.mjs";
+import { epsEquals } 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];
+	}
+};
+const isVector3 = (v) => typeof v === "object" && v !== null && Vector3TypeId in v;
+const equals$1 = dual(2, (a, b) => epsEquals(a.x, b.x) && epsEquals(a.y, b.y) && epsEquals(a.z, b.z));
+const make$1 = (v0, v1 = v0, v2 = v1) => new Vector3Impl(v0, v1, v2);
+const transpose$1 = (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$1(a[i], b[i], c[i]));
+	return result;
+};
+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));
+const magnitude$1 = (vector) => Math.hypot(vector.x, vector.y, vector.z);
+const normalize$1 = (vector) => {
+	const m = magnitude$1(vector);
+	return make$1(vector.x / m, vector.y / m, vector.z / m);
+};
+const dot$1 = dual(2, (a, b) => a.x * b.x + a.y * b.y + a.z * b.z);
+const cross = dual(2, (a, b) => {
+	return make$1(a.y * b.z - a.z * b.y, a.z * b.x - a.x * b.z, a.x * b.y - a.y * b.x);
+});
+const components$1 = (v) => [
+	v.x,
+	v.y,
+	v.z
+];
+const softmax$1 = (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$1(v0 / sum, v1 / sum, v2 / sum);
+};
+const add$1 = dual(2, (a, b) => make$1(a.x + b.x, a.y + b.y, a.z + b.z));
+const subtract$1 = dual(2, (a, b) => make$1(a.x - b.x, a.y - b.y, a.z - b.z));
+const hadamard$1 = dual(2, (a, b) => make$1(a.x * b.x, a.y * b.y, a.z * b.z));
+const scale$1 = dual(2, (v, s) => s === 1 ? v : make$1(v.x * s, v.y * s, v.z * s));
+const getX = (v) => v.x;
+const setX = dual(2, (v, x) => make$1(x, v.y, v.z));
+const getY = (v) => v.y;
+const setY = dual(2, (v, y) => make$1(v.x, y, v.z));
+const getZ = (v) => v.z;
+const setZ = dual(2, (v, z) => make$1(v.x, v.y, z));
+const setR = dual(2, (v, r) => scale$1(r / magnitude$1(v))(v));
+const getTheta = (v) => Math.acos(v.z / magnitude$1(v));
+const setTheta = dual(2, (v, phi) => {
+	const m = magnitude$1(v);
+	const sinTheta = Math.sin(phi);
+	return make$1(m * sinTheta * Math.cos(v.y), m * sinTheta * Math.sin(v.y), m * Math.cos(phi));
+});
+const getPhi = (v) => Math.atan2(v.y, v.x);
+const setPhi = dual(2, (v, theta) => {
+	const m = magnitude$1(v);
+	return make$1(m * Math.cos(theta), m * Math.sin(theta), v.z);
+});
+//#endregion
+//#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];
+	}
+};
+const isVector4 = (v) => typeof v === "object" && v !== null && Vector4TypeId in v;
+const equals = dual(2, (a, b) => epsEquals(a.x, b.x) && epsEquals(a.y, b.y) && epsEquals(a.z, b.z) && epsEquals(a.w, b.w));
+const make = (v0, v1 = v0, v2 = v1, v3 = v2) => new Vector4Impl(v0, v1, v2, v3);
+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;
+};
+const magnitude = (vector) => Math.hypot(vector.x, vector.y, vector.z, vector.w);
+const normalize = (vector) => {
+	const m = magnitude(vector);
+	return make(vector.x / m, vector.y / m, vector.z / m, vector.w / m);
+};
+const dot = dual(2, (a, b) => a.x * b.x + a.y * b.y + a.z * b.z + a.w * b.w);
+const components = (v) => [
+	v.x,
+	v.y,
+	v.z,
+	v.w
+];
+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);
+};
+const add = dual(2, (a, b) => make(a.x + b.x, a.y + b.y, a.z + b.z, a.w + b.w));
+const subtract = dual(2, (a, b) => make(a.x - b.x, a.y - b.y, a.z - b.z, a.w - b.w));
+const hadamard = dual(2, (a, b) => make(a.x * b.x, a.y * b.y, a.z * b.z, a.w * b.w));
+const scale = dual(2, (v, s) => s === 1 ? v : make(v.x * s, v.y * s, v.z * s, v.w * s));
+//#endregion
+export { scale$1 as A, getY as C, magnitude$1 as D, isVector3 as E, setY as F, setZ as I, softmax$1 as L, setR as M, setTheta as N, make$1 as O, setX as P, subtract$1 as R, getX as S, hadamard$1 as T, dot$1 as _, hadamard as a, getPhi as b, make as c, softmax as d, subtract as f, cross as g, components$1 as h, equals as i, setPhi as j, normalize$1 as k, normalize as l, add$1 as m, components as n, isVector4 as o, transpose as p, dot as r, magnitude as s, add as t, scale as u, equals$1 as v, getZ as w, getTheta as x, fromSpherical as y, transpose$1 as z };
+
+//# sourceMappingURL=vector4.internal-5XcaX12X.mjs.map