@fimbul-works/vec 1.0.3 → 2.0.0

package/dist/esm/4d/is-infinite-4d.js

@@ -0,0 +1,13 @@
+/**
+ * Checks if a 4D vector has infinite components.
+ * @param {ArrayVector4D} xyzw - Vector as `[x, y, z, w]`
+ * @returns {boolean} `true` if vector has infinite components, `false` otherwise
+ */
+export const isInfinite4D = (xyzw) => xyzw[0] === Number.POSITIVE_INFINITY ||
+    xyzw[0] === Number.NEGATIVE_INFINITY ||
+    xyzw[1] === Number.POSITIVE_INFINITY ||
+    xyzw[1] === Number.NEGATIVE_INFINITY ||
+    xyzw[2] === Number.POSITIVE_INFINITY ||
+    xyzw[2] === Number.NEGATIVE_INFINITY ||
+    xyzw[3] === Number.POSITIVE_INFINITY ||
+    xyzw[3] === Number.NEGATIVE_INFINITY;

package/dist/esm/4d/is-nan-4d.d.ts

@@ -0,0 +1,7 @@
+import type { ArrayVector4D } from "./types.js";
+/**
+ * Checks if a 4D vector has NaN components.
+ * @param {ArrayVector4D} xyzw - Vector as `[x, y, z, w]`
+ * @returns {boolean} `true` if vector has `NaN` components, `false` otherwise
+ */
+export declare const isNan4D: (xyzw: ArrayVector4D) => boolean;

package/dist/esm/4d/is-nan-4d.js

@@ -0,0 +1,6 @@
+/**
+ * Checks if a 4D vector has NaN components.
+ * @param {ArrayVector4D} xyzw - Vector as `[x, y, z, w]`
+ * @returns {boolean} `true` if vector has `NaN` components, `false` otherwise
+ */
+export const isNan4D = (xyzw) => Number.isNaN(xyzw[0]) || Number.isNaN(xyzw[1]) || Number.isNaN(xyzw[2]) || Number.isNaN(xyzw[3]);

package/dist/esm/4d/is-opposite-4d.d.ts

@@ -0,0 +1,8 @@
+import type { ArrayVector4D } from "./types.js";
+/**
+ * Checks if two 4D vectors are opposite.
+ * @param {ArrayVector4D} xyzw1 - First vector as `[x, y, z, w]`
+ * @param {ArrayVector4D} xyzw2 - Second vector as `[x, y, z, w]`
+ * @returns {boolean} `true` if vectors are opposite
+ */
+export declare const isOpposite4D: (xyzw1: ArrayVector4D, xyzw2: ArrayVector4D) => boolean;

package/dist/esm/4d/is-opposite-4d.js

@@ -0,0 +1,7 @@
+/**
+ * Checks if two 4D vectors are opposite.
+ * @param {ArrayVector4D} xyzw1 - First vector as `[x, y, z, w]`
+ * @param {ArrayVector4D} xyzw2 - Second vector as `[x, y, z, w]`
+ * @returns {boolean} `true` if vectors are opposite
+ */
+export const isOpposite4D = (xyzw1, xyzw2) => xyzw1[0] === -xyzw2[0] && xyzw1[1] === -xyzw2[1] && xyzw1[2] === -xyzw2[2] && xyzw1[3] === -xyzw2[3];

package/dist/esm/4d/is-zero-4d.d.ts

@@ -0,0 +1,7 @@
+import type { ArrayVector4D } from "./types.js";
+/**
+ * Checks if a 4D vector is zero.
+ * @param {ArrayVector4D} xyzw - Vector as `[x, y, z, w]`
+ * @returns {boolean} `true` if vector is zero, `false` otherwise
+ */
+export declare const isZero4D: (xyzw: ArrayVector4D) => boolean;

package/dist/esm/4d/is-zero-4d.js

@@ -0,0 +1,6 @@
+/**
+ * Checks if a 4D vector is zero.
+ * @param {ArrayVector4D} xyzw - Vector as `[x, y, z, w]`
+ * @returns {boolean} `true` if vector is zero, `false` otherwise
+ */
+export const isZero4D = (xyzw) => xyzw[0] === 0 && xyzw[1] === 0 && xyzw[2] === 0 && xyzw[3] === 0;

package/dist/esm/4d/lerp-4d.d.ts

@@ -0,0 +1,9 @@
+import type { ArrayVector4D } from "./types.js";
+/**
+ * Performs linear interpolation between two 4D vectors.
+ * @param {ArrayVector4D} xyzw1 - First vector as `[x, y, z, w]`
+ * @param {ArrayVector4D} xyzw2 - Second vector as `[x, y, z, w]`
+ * @param {number} t - Interpolation parameter
+ * @returns {ArrayVector4D} The interpolated vector
+ */
+export declare const lerp4D: (xyzw1: ArrayVector4D, xyzw2: ArrayVector4D, t: number) => ArrayVector4D;

package/dist/esm/4d/lerp-4d.js

@@ -0,0 +1,13 @@
+/**
+ * Performs linear interpolation between two 4D vectors.
+ * @param {ArrayVector4D} xyzw1 - First vector as `[x, y, z, w]`
+ * @param {ArrayVector4D} xyzw2 - Second vector as `[x, y, z, w]`
+ * @param {number} t - Interpolation parameter
+ * @returns {ArrayVector4D} The interpolated vector
+ */
+export const lerp4D = (xyzw1, xyzw2, t) => [
+    xyzw1[0] + (xyzw2[0] - xyzw1[0]) * t,
+    xyzw1[1] + (xyzw2[1] - xyzw1[1]) * t,
+    xyzw1[2] + (xyzw2[2] - xyzw1[2]) * t,
+    xyzw1[3] + (xyzw2[3] - xyzw1[3]) * t,
+];

package/dist/esm/4d/limit-max-4d.d.ts

@@ -0,0 +1,9 @@
+import type { ArrayVector4D } from "./types.js";
+/**
+ * Limits the maximum magnitude of a 4D vector.
+ * @param {ArrayVector4D} xyzw - Vector as `[x, y, z, w]`
+ * @param {number} max - Maximum magnitude
+ * @param {number} [m] - Optional current magnitude (default: `magnitude4D(xyzw)`)
+ * @returns {ArrayVector4D} Vector with limited magnitude
+ */
+export declare const limitMax4D: (xyzw: ArrayVector4D, max: number, m?: number) => ArrayVector4D;

package/dist/esm/4d/limit-max-4d.js

@@ -0,0 +1,9 @@
+import { magnitude4D } from "./magnitude-4d.js";
+/**
+ * Limits the maximum magnitude of a 4D vector.
+ * @param {ArrayVector4D} xyzw - Vector as `[x, y, z, w]`
+ * @param {number} max - Maximum magnitude
+ * @param {number} [m] - Optional current magnitude (default: `magnitude4D(xyzw)`)
+ * @returns {ArrayVector4D} Vector with limited magnitude
+ */
+export const limitMax4D = (xyzw, max, m = magnitude4D(xyzw)) => m > max ? [(xyzw[0] / m) * max, (xyzw[1] / m) * max, (xyzw[2] / m) * max, (xyzw[3] / m) * max] : xyzw;

package/dist/esm/4d/limit-min-4d.d.ts

@@ -0,0 +1,9 @@
+import type { ArrayVector4D } from "./types.js";
+/**
+ * Limits the minimum magnitude of a 4D vector.
+ * @param {ArrayVector4D} xyzw - Vector as `[x, y, z, w]`
+ * @param {number} min - Minimum magnitude
+ * @param {number} [m] - Optional current magnitude (default: `magnitude4D(xyzw)`)
+ * @returns {ArrayVector4D} Vector with limited magnitude
+ */
+export declare const limitMin4D: (xyzw: ArrayVector4D, min: number, m?: number) => ArrayVector4D;

package/dist/esm/4d/limit-min-4d.js

@@ -0,0 +1,9 @@
+import { magnitude4D } from "./magnitude-4d.js";
+/**
+ * Limits the minimum magnitude of a 4D vector.
+ * @param {ArrayVector4D} xyzw - Vector as `[x, y, z, w]`
+ * @param {number} min - Minimum magnitude
+ * @param {number} [m] - Optional current magnitude (default: `magnitude4D(xyzw)`)
+ * @returns {ArrayVector4D} Vector with limited magnitude
+ */
+export const limitMin4D = (xyzw, min, m = magnitude4D(xyzw)) => m < min ? [(xyzw[0] / m) * min, (xyzw[1] / m) * min, (xyzw[2] / m) * min, (xyzw[3] / m) * min] : xyzw;

package/dist/esm/4d/look-at-4d.d.ts

@@ -0,0 +1,10 @@
+import type { ArrayVector4D } from "./types.js";
+/**
+ * Makes a 4D vector point towards another vector.
+ * @param {ArrayVector4D} xyzw1 - First vector as `[x, y, z, w]`
+ * @param {ArrayVector4D} xyzw2 - Second vector as `[x, y, z, w]` (target to look at)
+ * @param {number} [m1] - Optional current magnitude of the first vector (default: `magnitude4D(xyzw1)`)
+ * @param {number} [m2] - Optional current magnitude of the second vector (default: `magnitude4D(xyzw2)`)
+ * @returns {number} Vector pointing at the target with the magnitude of xyzw1
+ */
+export declare const lookAt4D: (xyzw1: ArrayVector4D, xyzw2: ArrayVector4D, m1?: number, m2?: number) => ArrayVector4D;

package/dist/esm/4d/look-at-4d.js

@@ -0,0 +1,10 @@
+import { magnitude4D } from "./magnitude-4d.js";
+/**
+ * Makes a 4D vector point towards another vector.
+ * @param {ArrayVector4D} xyzw1 - First vector as `[x, y, z, w]`
+ * @param {ArrayVector4D} xyzw2 - Second vector as `[x, y, z, w]` (target to look at)
+ * @param {number} [m1] - Optional current magnitude of the first vector (default: `magnitude4D(xyzw1)`)
+ * @param {number} [m2] - Optional current magnitude of the second vector (default: `magnitude4D(xyzw2)`)
+ * @returns {number} Vector pointing at the target with the magnitude of xyzw1
+ */
+export const lookAt4D = (xyzw1, xyzw2, m1 = magnitude4D(xyzw1), m2 = magnitude4D(xyzw2)) => [(xyzw2[0] / m2) * m1, (xyzw2[1] / m2) * m1, (xyzw2[2] / m2) * m1, (xyzw2[3] / m2) * m1];

package/dist/esm/4d/magnitude-4d.d.ts

@@ -0,0 +1,7 @@
+import type { ArrayVector4D } from "./types.js";
+/**
+ * Calculates the magnitude (length) of a 4D vector.
+ * @param {ArrayVector4D} xyzw - Vector as `[x, y, z, w]`
+ * @returns {number} The magnitude
+ */
+export declare const magnitude4D: (xyzw: ArrayVector4D) => number;

package/dist/esm/4d/magnitude-4d.js

@@ -0,0 +1,6 @@
+/**
+ * Calculates the magnitude (length) of a 4D vector.
+ * @param {ArrayVector4D} xyzw - Vector as `[x, y, z, w]`
+ * @returns {number} The magnitude
+ */
+export const magnitude4D = (xyzw) => Math.sqrt(xyzw[0] ** 2 + xyzw[1] ** 2 + xyzw[2] ** 2 + xyzw[3] ** 2);

package/dist/esm/4d/magnitude-sq-4d.d.ts

@@ -0,0 +1,8 @@
+import type { ArrayVector4D } from "./types.js";
+/**
+ * Calculates the squared magnitude of a 4D vector.
+ * Faster than magnitude for comparisons.
+ * @param {ArrayVector4D} xyzw - Vector as `[x, y, z, w]`
+ * @returns {number} The squared magnitude
+ */
+export declare const magnitudeSq4D: (xyzw: ArrayVector4D) => number;

package/dist/esm/4d/magnitude-sq-4d.js

@@ -0,0 +1,7 @@
+/**
+ * Calculates the squared magnitude of a 4D vector.
+ * Faster than magnitude for comparisons.
+ * @param {ArrayVector4D} xyzw - Vector as `[x, y, z, w]`
+ * @returns {number} The squared magnitude
+ */
+export const magnitudeSq4D = (xyzw) => xyzw[0] ** 2 + xyzw[1] ** 2 + xyzw[2] ** 2 + xyzw[3] ** 2;

package/dist/esm/4d/multiply-4d.d.ts

@@ -0,0 +1,8 @@
+import type { ArrayVector4D } from "./types.js";
+/**
+ * Multiplies two 4D vectors component-wise.
+ * @param {ArrayVector4D} xyzw1 - First vector as `[x, y, z, w]`
+ * @param {ArrayVector4D} xyzw2 - Second vector as `[x, y, z, w]`
+ * @returns {ArrayVector4D} The multiplied vector
+ */
+export declare const multiply4D: (xyzw1: ArrayVector4D, xyzw2: ArrayVector4D) => ArrayVector4D;

package/dist/esm/4d/multiply-4d.js

@@ -0,0 +1,12 @@
+/**
+ * Multiplies two 4D vectors component-wise.
+ * @param {ArrayVector4D} xyzw1 - First vector as `[x, y, z, w]`
+ * @param {ArrayVector4D} xyzw2 - Second vector as `[x, y, z, w]`
+ * @returns {ArrayVector4D} The multiplied vector
+ */
+export const multiply4D = (xyzw1, xyzw2) => [
+    xyzw1[0] * xyzw2[0],
+    xyzw1[1] * xyzw2[1],
+    xyzw1[2] * xyzw2[2],
+    xyzw1[3] * xyzw2[3],
+];

package/dist/esm/4d/negate-4d.d.ts

@@ -0,0 +1,7 @@
+import type { ArrayVector4D } from "./types.js";
+/**
+ * Negates a 4D vector.
+ * @param {ArrayVector4D} xyzw - Vector as `[x, y, z, w]`
+ * @returns {ArrayVector4D} The negated vector
+ */
+export declare const negate4D: (xyzw: ArrayVector4D) => ArrayVector4D;

package/dist/esm/4d/negate-4d.js

@@ -0,0 +1,6 @@
+/**
+ * Negates a 4D vector.
+ * @param {ArrayVector4D} xyzw - Vector as `[x, y, z, w]`
+ * @returns {ArrayVector4D} The negated vector
+ */
+export const negate4D = (xyzw) => [-xyzw[0], -xyzw[1], -xyzw[2], -xyzw[3]];

package/dist/esm/4d/normalize-4d.d.ts

@@ -0,0 +1,8 @@
+import type { ArrayVector4D } from "./types.js";
+/**
+ * Normalizes a 4D vector to unit length.
+ * @param {ArrayVector4D} xyzw - Vector as `[x, y, z, w]`
+ * @param {number} [m] - Optional current magnitude (default: `magnitude4D(xyzw)`)
+ * @returns {ArrayVector4D} The normalized vector
+ */
+export declare const normalize4D: (xyzw: ArrayVector4D, m?: number) => ArrayVector4D;

package/dist/esm/4d/normalize-4d.js

@@ -0,0 +1,13 @@
+import { magnitude4D } from "./magnitude-4d.js";
+/**
+ * Normalizes a 4D vector to unit length.
+ * @param {ArrayVector4D} xyzw - Vector as `[x, y, z, w]`
+ * @param {number} [m] - Optional current magnitude (default: `magnitude4D(xyzw)`)
+ * @returns {ArrayVector4D} The normalized vector
+ */
+export const normalize4D = (xyzw, m = magnitude4D(xyzw)) => [
+    xyzw[0] / m,
+    xyzw[1] / m,
+    xyzw[2] / m,
+    xyzw[3] / m,
+];

package/dist/esm/4d/one-4d.d.ts

@@ -0,0 +1,6 @@
+import type { ArrayVector4D } from "./types.js";
+/**
+ * Creates a 4D vector with all components set to 1.
+ * @returns {ArrayVector4D} A vector `[1, 1, 1, 1]`
+ */
+export declare const one4D: () => ArrayVector4D;

package/dist/esm/4d/one-4d.js

@@ -0,0 +1,5 @@
+/**
+ * Creates a 4D vector with all components set to 1.
+ * @returns {ArrayVector4D} A vector `[1, 1, 1, 1]`
+ */
+export const one4D = () => [1, 1, 1, 1];

package/dist/esm/4d/project-4d.d.ts

@@ -0,0 +1,10 @@
+import type { ArrayVector4D } from "./types.js";
+/**
+ * Projects one 4D vector onto another.
+ * @param {ArrayVector4D} xyzw1 - First vector as `[x, y, z, w]`
+ * @param {ArrayVector4D} xyzw2 - Second vector as `[x, y, z, w]` to project onto
+ * @param {number} [m1] - Optional current magnitude (default: `magnitude4D(xyzw1)`)
+ * @param {number} [m2] - Optional current magnitude (default: `magnitude4D(xyzw2)`)
+ * @returns {ArrayVector4D} The projected vector
+ */
+export declare const project4D: (xyzw1: ArrayVector4D, xyzw2: ArrayVector4D, m1?: number, m2?: number) => ArrayVector4D;

package/dist/esm/4d/project-4d.js

@@ -0,0 +1,14 @@
+import { dot4D } from "./dot-4d.js";
+import { magnitude4D } from "./magnitude-4d.js";
+/**
+ * Projects one 4D vector onto another.
+ * @param {ArrayVector4D} xyzw1 - First vector as `[x, y, z, w]`
+ * @param {ArrayVector4D} xyzw2 - Second vector as `[x, y, z, w]` to project onto
+ * @param {number} [m1] - Optional current magnitude (default: `magnitude4D(xyzw1)`)
+ * @param {number} [m2] - Optional current magnitude (default: `magnitude4D(xyzw2)`)
+ * @returns {ArrayVector4D} The projected vector
+ */
+export const project4D = (xyzw1, xyzw2, m1 = magnitude4D(xyzw1), m2 = magnitude4D(xyzw2)) => {
+    const f = m1 * Math.cos(Math.acos(dot4D(xyzw1, xyzw2) / (m1 * m2)));
+    return [(xyzw2[0] / m2) * f, (xyzw2[1] / m2) * f, (xyzw2[2] / m2) * f, (xyzw2[3] / m2) * f];
+};

package/dist/esm/4d/random-4d.d.ts

@@ -0,0 +1,7 @@
+import type { ArrayVector4D } from "./types.js";
+/**
+ * Creates a random unit 4D vector.
+ * @param {() => number} random - A function that returns a random number between 0 and 1 (default: `Math.random`)
+ * @returns {ArrayVector4D} A random unit vector
+ */
+export declare const random4D: (random?: () => number) => ArrayVector4D;

package/dist/esm/4d/random-4d.js

@@ -0,0 +1,17 @@
+const { sqrt, log, sin, cos, PI } = Math;
+/**
+ * Creates a random unit 4D vector.
+ * @param {() => number} random - A function that returns a random number between 0 and 1 (default: `Math.random`)
+ * @returns {ArrayVector4D} A random unit vector
+ */
+export const random4D = (random = Math.random) => {
+    // 1. Generate four numbers from a Normal Distribution (Box-Muller transform)
+    const x = sqrt(-2 * log(random())) * cos(2 * PI * random());
+    const y = sqrt(-2 * log(random())) * sin(2 * PI * random());
+    const z = sqrt(-2 * log(random())) * cos(2 * PI * random());
+    const w = sqrt(-2 * log(random())) * sin(2 * PI * random());
+    // 2. Calculate the current length
+    const length = sqrt(x * x + y * y + z * z + w * w);
+    // 3. Divide by length to make it a unit vector
+    return [x / length, y / length, z / length, w / length];
+};

package/dist/esm/4d/reflect-4d.d.ts

@@ -0,0 +1,9 @@
+import type { ArrayVector4D } from "./types.js";
+/**
+ * Reflects a 4D vector across a normal vector.
+ * The normal vector should be normalized (unit length).
+ * @param {ArrayVector4D} xyzw - Vector as `[x, y, z, w]`
+ * @param {ArrayVector4D} normal - Normal vector (must be normalized)
+ * @returns {ArrayVector4D} The reflected vector
+ */
+export declare const reflect4D: (xyzw: ArrayVector4D, normal: ArrayVector4D) => ArrayVector4D;

package/dist/esm/4d/reflect-4d.js

@@ -0,0 +1,17 @@
+import { dot4D } from "./dot-4d.js";
+/**
+ * Reflects a 4D vector across a normal vector.
+ * The normal vector should be normalized (unit length).
+ * @param {ArrayVector4D} xyzw - Vector as `[x, y, z, w]`
+ * @param {ArrayVector4D} normal - Normal vector (must be normalized)
+ * @returns {ArrayVector4D} The reflected vector
+ */
+export const reflect4D = (xyzw, normal) => {
+    const dot = dot4D(xyzw, normal);
+    return [
+        xyzw[0] - 2 * dot * normal[0],
+        xyzw[1] - 2 * dot * normal[1],
+        xyzw[2] - 2 * dot * normal[2],
+        xyzw[3] - 2 * dot * normal[3],
+    ];
+};

package/dist/esm/4d/set-magnitude-4d.d.ts

@@ -0,0 +1,9 @@
+import type { ArrayVector4D } from "./types.js";
+/**
+ * Sets the magnitude of a 4D vector while maintaining its direction.
+ * @param {ArrayVector4D} xyzw - Vector as `[x, y, z, w]`
+ * @param {number} newMag - The new magnitude
+ * @param {number} [m] - Optional current magnitude (default: `magnitude4D(xyzw)`)
+ * @returns {ArrayVector4D} Vector with the new magnitude
+ */
+export declare const setMagnitude4D: (xyzw: ArrayVector4D, newMag: number, m?: number) => ArrayVector4D;

package/dist/esm/4d/set-magnitude-4d.js

@@ -0,0 +1,14 @@
+import { magnitude4D } from "./magnitude-4d.js";
+/**
+ * Sets the magnitude of a 4D vector while maintaining its direction.
+ * @param {ArrayVector4D} xyzw - Vector as `[x, y, z, w]`
+ * @param {number} newMag - The new magnitude
+ * @param {number} [m] - Optional current magnitude (default: `magnitude4D(xyzw)`)
+ * @returns {ArrayVector4D} Vector with the new magnitude
+ */
+export const setMagnitude4D = (xyzw, newMag, m = magnitude4D(xyzw)) => [
+    (xyzw[0] / m) * newMag,
+    (xyzw[1] / m) * newMag,
+    (xyzw[2] / m) * newMag,
+    (xyzw[3] / m) * newMag,
+];

package/dist/esm/4d/subtract-4d.d.ts

@@ -0,0 +1,8 @@
+import type { ArrayVector4D } from "./types.js";
+/**
+ * Subtracts two 4D vectors.
+ * @param {ArrayVector4D} xyzw1 - First vector as `[x, y, z, w]`
+ * @param {ArrayVector4D} xyzw2 - Second vector as `[x, y, z, w]`
+ * @returns {ArrayVector4D} The difference of the vectors
+ */
+export declare const subtract4D: (xyzw1: ArrayVector4D, xyzw2: ArrayVector4D) => ArrayVector4D;

package/dist/esm/4d/subtract-4d.js

@@ -0,0 +1,12 @@
+/**
+ * Subtracts two 4D vectors.
+ * @param {ArrayVector4D} xyzw1 - First vector as `[x, y, z, w]`
+ * @param {ArrayVector4D} xyzw2 - Second vector as `[x, y, z, w]`
+ * @returns {ArrayVector4D} The difference of the vectors
+ */
+export const subtract4D = (xyzw1, xyzw2) => [
+    xyzw1[0] - xyzw2[0],
+    xyzw1[1] - xyzw2[1],
+    xyzw1[2] - xyzw2[2],
+    xyzw1[3] - xyzw2[3],
+];

package/dist/esm/4d/types.d.ts

@@ -0,0 +1,4 @@
+/**
+ * 4D vector as an array.
+ */
+export type ArrayVector4D = [number, number, number, number];

package/dist/esm/4d/types.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/4d/zero-4d.d.ts

@@ -0,0 +1,6 @@
+import type { ArrayVector4D } from "./types.js";
+/**
+ * Creates a zero 4D vector.
+ * @returns {ArrayVector4D} A zero vector `[0, 0, 0, 0]`
+ */
+export declare const zero4D: () => ArrayVector4D;

package/dist/esm/4d/zero-4d.js

@@ -0,0 +1,5 @@
+/**
+ * Creates a zero 4D vector.
+ * @returns {ArrayVector4D} A zero vector `[0, 0, 0, 0]`
+ */
+export const zero4D = () => [0, 0, 0, 0];

package/dist/esm/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./2d/index.js";
+export * from "./3d/index.js";
+export * from "./4d/index.js";
+export * from "./slerp.js";
+export * from "./vec2.js";
+export * from "./vec3.js";
+export * from "./vec4.js";

package/dist/esm/index.js

@@ -0,0 +1,7 @@
+export * from "./2d/index.js";
+export * from "./3d/index.js";
+export * from "./4d/index.js";
+export * from "./slerp.js";
+export * from "./vec2.js";
+export * from "./vec3.js";
+export * from "./vec4.js";

package/dist/esm/slerp.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Documentation for spherical linear interpolation functions.
+ * @module Slerp
+ */
+/**
+ * Spherical linear interpolation for angles (in radians).
+ * Handles wrapping around 2π correctly.
+ * @param {number} from - Start angle in radians
+ * @param {number} to - End angle in radians
+ * @param {number} t - Interpolation factor (0-1)
+ * @returns {number} Interpolated angle
+ */
+export declare const slerp: (from: number, to: number, t: number) => number;
+/**
+ * Spherical linear interpolation for angles (in degrees).
+ * @param {number} from - Start angle in degrees
+ * @param {number} to - End angle in degrees
+ * @param {number} t - Interpolation factor (0-1)
+ * @returns {number} Interpolated angle
+ */
+export declare const slerpDegrees: (from: number, to: number, t: number) => number;

package/dist/esm/slerp.js

@@ -0,0 +1,23 @@
+/**
+ * Documentation for spherical linear interpolation functions.
+ * @module Slerp
+ */
+const PI2 = 2 * Math.PI;
+const PI3 = 3 * Math.PI;
+/**
+ * Spherical linear interpolation for angles (in radians).
+ * Handles wrapping around 2π correctly.
+ * @param {number} from - Start angle in radians
+ * @param {number} to - End angle in radians
+ * @param {number} t - Interpolation factor (0-1)
+ * @returns {number} Interpolated angle
+ */
+export const slerp = (from, to, t) => from + (((((to - from) % PI2) + PI3) % PI2) - Math.PI) * t;
+/**
+ * Spherical linear interpolation for angles (in degrees).
+ * @param {number} from - Start angle in degrees
+ * @param {number} to - End angle in degrees
+ * @param {number} t - Interpolation factor (0-1)
+ * @returns {number} Interpolated angle
+ */
+export const slerpDegrees = (from, to, t) => from + (((((to - from) % 360) + 540) % 360) - 180) * t;