@fimbul-works/vec 1.1.0 → 2.0.0

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

@@ -0,0 +1,8 @@
+import type { ArrayVector3D } from "./types";
+/**
+ * Subtracts a 3D vector from another.
+ * @param {ArrayVector3D} xyz1 - First vector as `[x, y, z]`
+ * @param {ArrayVector3D} xyz2 - Second vector as `[x, y, z]`
+ * @returns {ArrayVector3D} The difference between the vectors
+ */
+export declare const subtract3D: (xyz1: ArrayVector3D, xyz2: ArrayVector3D) => ArrayVector3D;

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

@@ -0,0 +1,11 @@
+/**
+ * Subtracts a 3D vector from another.
+ * @param {ArrayVector3D} xyz1 - First vector as `[x, y, z]`
+ * @param {ArrayVector3D} xyz2 - Second vector as `[x, y, z]`
+ * @returns {ArrayVector3D} The difference between the vectors
+ */
+export const subtract3D = (xyz1, xyz2) => [
+    xyz1[0] - xyz2[0],
+    xyz1[1] - xyz2[1],
+    xyz1[2] - xyz2[2],
+];

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

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

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

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

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

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

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

@@ -0,0 +1,5 @@
+/**
+ * Creates a zero 3D vector.
+ * @returns {ArrayVector3D} Vector `[0, 0, 0]`
+ */
+export const zero3D = () => [0, 0, 0];

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

@@ -0,0 +1,8 @@
+import type { ArrayVector4D } from "./types.js";
+/**
+ * Adds 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 sum of the vectors
+ */
+export declare const add4D: (xyzw1: ArrayVector4D, xyzw2: ArrayVector4D) => ArrayVector4D;

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

@@ -0,0 +1,12 @@
+/**
+ * Adds 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 sum of the vectors
+ */
+export const add4D = (xyzw1, xyzw2) => [
+    xyzw1[0] + xyzw2[0],
+    xyzw1[1] + xyzw2[1],
+    xyzw1[2] + xyzw2[2],
+    xyzw1[3] + xyzw2[3],
+];

package/dist/esm/4d/angle-between-4d.d.ts

@@ -0,0 +1,10 @@
+import type { ArrayVector4D } from "./types.js";
+/**
+ * Calculates the angle 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} [m1] - Optional magnitude of the first vector (default: `magnitude4D(xyzw1)`)
+ * @param {number} [m2] - Optional magnitude of the second vector (default: `magnitude4D(xyzw2)`)
+ * @returns {number} The angle in radians
+ */
+export declare const angleBetween4D: (xyzw1: ArrayVector4D, xyzw2: ArrayVector4D, m1?: number, m2?: number) => number;

package/dist/esm/4d/angle-between-4d.js

@@ -0,0 +1,11 @@
+import { dot4D } from "./dot-4d.js";
+import { magnitude4D } from "./magnitude-4d.js";
+/**
+ * Calculates the angle 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} [m1] - Optional magnitude of the first vector (default: `magnitude4D(xyzw1)`)
+ * @param {number} [m2] - Optional magnitude of the second vector (default: `magnitude4D(xyzw2)`)
+ * @returns {number} The angle in radians
+ */
+export const angleBetween4D = (xyzw1, xyzw2, m1 = magnitude4D(xyzw1), m2 = magnitude4D(xyzw2)) => Math.acos(dot4D(xyzw1, xyzw2) / (m1 * m2));

package/dist/esm/4d/angle-w-4d.d.ts

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

package/dist/esm/4d/angle-w-4d.js

@@ -0,0 +1,6 @@
+/**
+ * Calculates the angle between a 4D vector and the positive w-axis.
+ * @param {ArrayVector4D} xyzw - Vector as `[x, y, z, w]`
+ * @returns {number} The angle in radians
+ */
+export const angleW4D = (xyzw) => Math.atan2(Math.sqrt(xyzw[0] ** 2 + xyzw[1] ** 2 + xyzw[2] ** 2), xyzw[3]);

package/dist/esm/4d/angle-x-4d.d.ts

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

package/dist/esm/4d/angle-x-4d.js

@@ -0,0 +1,6 @@
+/**
+ * Calculates the angle between a 4D vector and the positive x-axis.
+ * @param {ArrayVector4D} xyzw - Vector as `[x, y, z, w]`
+ * @returns {number} The angle in radians
+ */
+export const angleX4D = (xyzw) => Math.atan2(Math.sqrt(xyzw[1] ** 2 + xyzw[2] ** 2 + xyzw[3] ** 2), xyzw[0]);

package/dist/esm/4d/angle-y-4d.d.ts

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

package/dist/esm/4d/angle-y-4d.js

@@ -0,0 +1,6 @@
+/**
+ * Calculates the angle between a 4D vector and the positive y-axis.
+ * @param {ArrayVector4D} xyzw - Vector as `[x, y, z, w]`
+ * @returns {number} The angle in radians
+ */
+export const angleY4D = (xyzw) => Math.atan2(Math.sqrt(xyzw[2] ** 2 + xyzw[3] ** 2 + xyzw[0] ** 2), xyzw[1]);

package/dist/esm/4d/angle-z-4d.d.ts

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

package/dist/esm/4d/angle-z-4d.js

@@ -0,0 +1,6 @@
+/**
+ * Calculates the angle between a 4D vector and the positive z-axis.
+ * @param {ArrayVector4D} xyzw - Vector as `[x, y, z, w]`
+ * @returns {number} The angle in radians
+ */
+export const angleZ4D = (xyzw) => Math.atan2(Math.sqrt(xyzw[3] ** 2 + xyzw[0] ** 2 + xyzw[1] ** 2), xyzw[2]);

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

@@ -0,0 +1,10 @@
+import type { ArrayVector4D } from "./types.js";
+/**
+ * Clamps the magnitude of a 4D vector between min and max.
+ * @param {ArrayVector4D} xyzw - Vector as `[x, y, z, w]`
+ * @param {number} min - Minimum magnitude
+ * @param {number} max - Maximum magnitude
+ * @param {number} [m] - Optional current magnitude (default: `magnitude4D(xyzw)`)
+ * @returns {ArrayVector4D} The clamped vector
+ */
+export declare const clamp4D: (xyzw: ArrayVector4D, min: number, max: number, m?: number) => ArrayVector4D;

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

@@ -0,0 +1,14 @@
+import { magnitude4D } from "./magnitude-4d.js";
+/**
+ * Clamps the magnitude of a 4D vector between min and max.
+ * @param {ArrayVector4D} xyzw - Vector as `[x, y, z, w]`
+ * @param {number} min - Minimum magnitude
+ * @param {number} max - Maximum magnitude
+ * @param {number} [m] - Optional current magnitude (default: `magnitude4D(xyzw)`)
+ * @returns {ArrayVector4D} The clamped vector
+ */
+export const clamp4D = (xyzw, min, max, m = magnitude4D(xyzw)) => m > max
+    ? [(xyzw[0] / m) * max, (xyzw[1] / m) * max, (xyzw[2] / m) * max, (xyzw[3] / m) * max]
+    : m < min
+        ? [(xyzw[0] / m) * min, (xyzw[1] / m) * min, (xyzw[2] / m) * min, (xyzw[3] / m) * min]
+        : xyzw;

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

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

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

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

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

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

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

@@ -0,0 +1,7 @@
+/**
+ * Calculates the Euclidean distance between two 4D vectors.
+ * @param {ArrayVector4D} xyzw1 - First vector as `[x, y, z, w]`
+ * @param {ArrayVector4D} xyzw2 - Second vector as `[x, y, z, w]`
+ * @returns {number} The distance
+ */
+export const distance4D = (xyzw1, xyzw2) => Math.sqrt((xyzw1[0] - xyzw2[0]) ** 2 + (xyzw1[1] - xyzw2[1]) ** 2 + (xyzw1[2] - xyzw2[2]) ** 2 + (xyzw1[3] - xyzw2[3]) ** 2);

package/dist/esm/4d/distance-chebyshev-4d.d.ts

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

package/dist/esm/4d/distance-chebyshev-4d.js

@@ -0,0 +1,19 @@
+/**
+ * Calculates the Chebyshev distance between two 4D vectors.
+ * @param {ArrayVector4D} xyzw1 - First vector as `[x, y, z, w]`
+ * @param {ArrayVector4D} xyzw2 - Second vector as `[x, y, z, w]`
+ * @returns {number} The Chebyshev distance
+ */
+export const distanceChebyshev4D = (xyzw1, xyzw2) => {
+    const absX = Math.abs(xyzw1[0] - xyzw2[0]);
+    const absY = Math.abs(xyzw1[1] - xyzw2[1]);
+    const absZ = Math.abs(xyzw1[2] - xyzw2[2]);
+    const absW = Math.abs(xyzw1[3] - xyzw2[3]);
+    return absX >= absY && absX >= absZ && absX >= absW
+        ? absX
+        : absY >= absZ && absY >= absW
+            ? absY
+            : absZ >= absW
+                ? absZ
+                : absW;
+};

package/dist/esm/4d/distance-manhattan-4d.d.ts

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

package/dist/esm/4d/distance-manhattan-4d.js

@@ -0,0 +1,10 @@
+/**
+ * Calculates the Manhattan distance between two 4D vectors.
+ * @param {ArrayVector4D} xyzw1 - First vector as `[x, y, z, w]`
+ * @param {ArrayVector4D} xyzw2 - Second vector as `[x, y, z, w]`
+ * @returns {number} The Manhattan distance
+ */
+export const distanceManhattan4D = (xyzw1, xyzw2) => Math.abs(xyzw1[0] - xyzw2[0]) +
+    Math.abs(xyzw1[1] - xyzw2[1]) +
+    Math.abs(xyzw1[2] - xyzw2[2]) +
+    Math.abs(xyzw1[3] - xyzw2[3]);

package/dist/esm/4d/distance-minkowski-4d.d.ts

@@ -0,0 +1,9 @@
+import type { ArrayVector4D } from "./types.js";
+/**
+ * Calculates the Minkowski distance 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} p - The order of the Minkowski distance
+ * @returns {number} The Minkowski distance
+ */
+export declare const distanceMinkowski4D: (xyzw1: ArrayVector4D, xyzw2: ArrayVector4D, p: number) => number;

package/dist/esm/4d/distance-minkowski-4d.js

@@ -0,0 +1,12 @@
+/**
+ * Calculates the Minkowski distance 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} p - The order of the Minkowski distance
+ * @returns {number} The Minkowski distance
+ */
+export const distanceMinkowski4D = (xyzw1, xyzw2, p) => (Math.abs(xyzw1[0] - xyzw2[0]) ** p +
+    Math.abs(xyzw1[1] - xyzw2[1]) ** p +
+    Math.abs(xyzw1[2] - xyzw2[2]) ** p +
+    Math.abs(xyzw1[3] - xyzw2[3]) ** p) **
+    (1 / p);

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

@@ -0,0 +1,9 @@
+import type { ArrayVector4D } from "./types.js";
+/**
+ * Calculates the squared Euclidean distance between two 4D vectors.
+ * Faster than distance for comparisons.
+ * @param {ArrayVector4D} xyzw1 - First vector as `[x, y, z, w]`
+ * @param {ArrayVector4D} xyzw2 - Second vector as `[x, y, z, w]`
+ * @returns {number} The squared distance
+ */
+export declare const distanceSq4D: (xyzw1: ArrayVector4D, xyzw2: ArrayVector4D) => number;

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

@@ -0,0 +1,8 @@
+/**
+ * Calculates the squared Euclidean distance between two 4D vectors.
+ * Faster than distance for comparisons.
+ * @param {ArrayVector4D} xyzw1 - First vector as `[x, y, z, w]`
+ * @param {ArrayVector4D} xyzw2 - Second vector as `[x, y, z, w]`
+ * @returns {number} The squared distance
+ */
+export const distanceSq4D = (xyzw1, xyzw2) => (xyzw1[0] - xyzw2[0]) ** 2 + (xyzw1[1] - xyzw2[1]) ** 2 + (xyzw1[2] - xyzw2[2]) ** 2 + (xyzw1[3] - xyzw2[3]) ** 2;

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

@@ -0,0 +1,8 @@
+import type { ArrayVector4D } from "./types.js";
+/**
+ * Divides 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 divided vector
+ */
+export declare const divide4D: (xyzw1: ArrayVector4D, xyzw2: ArrayVector4D) => ArrayVector4D;

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

@@ -0,0 +1,12 @@
+/**
+ * Divides 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 divided vector
+ */
+export const divide4D = (xyzw1, xyzw2) => [
+    xyzw2[0] === 0 ? Number.POSITIVE_INFINITY : xyzw1[0] / xyzw2[0],
+    xyzw2[1] === 0 ? Number.POSITIVE_INFINITY : xyzw1[1] / xyzw2[1],
+    xyzw2[2] === 0 ? Number.POSITIVE_INFINITY : xyzw1[2] / xyzw2[2],
+    xyzw2[3] === 0 ? Number.POSITIVE_INFINITY : xyzw1[3] / xyzw2[3],
+];

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

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

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

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

package/dist/esm/4d/from-object-4d.d.ts

@@ -0,0 +1,12 @@
+import type { ArrayVector4D } from "./types.js";
+/**
+ * Creates a 4D vector from an object with x, y, z, w properties.
+ * @param {{ x: number; y: number; z: number; w: number }} obj - Object with x, y, z, w properties
+ * @returns {ArrayVector4D} 4D vector
+ */
+export declare const fromObject4D: ({ x, y, z, w }: {
+    x: number;
+    y: number;
+    z: number;
+    w: number;
+}) => ArrayVector4D;

package/dist/esm/4d/from-object-4d.js

@@ -0,0 +1,11 @@
+/**
+ * Creates a 4D vector from an object with x, y, z, w properties.
+ * @param {{ x: number; y: number; z: number; w: number }} obj - Object with x, y, z, w properties
+ * @returns {ArrayVector4D} 4D vector
+ */
+export const fromObject4D = ({ x, y, z, w }) => [
+    x,
+    y,
+    z,
+    w,
+];

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

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

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

@@ -0,0 +1,6 @@
+/**
+ * Create an immutable 4D vector.
+ * @param {ArrayVector4D} xyzw - Vector as `[x, y, z, w]`
+ * @returns {Readonly<ArrayVector4D>} The immutable vector
+ */
+export const immutable4D = (xyzw) => Object.freeze([xyzw[0], xyzw[1], xyzw[2], xyzw[3]]);

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

@@ -0,0 +1,44 @@
+/**
+ * Documentation for functional 4D Vector array operations.
+ * @module ArrayVector4D
+ */
+export * from "./add-4d.js";
+export * from "./angle-between-4d.js";
+export * from "./angle-w-4d.js";
+export * from "./angle-x-4d.js";
+export * from "./angle-y-4d.js";
+export * from "./angle-z-4d.js";
+export * from "./clamp-4d.js";
+export * from "./clone-4d.js";
+export * from "./distance-4d.js";
+export * from "./distance-chebyshev-4d.js";
+export * from "./distance-manhattan-4d.js";
+export * from "./distance-minkowski-4d.js";
+export * from "./distance-sq-4d.js";
+export * from "./divide-4d.js";
+export * from "./dot-4d.js";
+export * from "./from-object-4d.js";
+export * from "./immutable-4d.js";
+export * from "./is-equal-4d.js";
+export * from "./is-equal-approx-4d.js";
+export * from "./is-infinite-4d.js";
+export * from "./is-nan-4d.js";
+export * from "./is-opposite-4d.js";
+export * from "./is-zero-4d.js";
+export * from "./lerp-4d.js";
+export * from "./limit-max-4d.js";
+export * from "./limit-min-4d.js";
+export * from "./look-at-4d.js";
+export * from "./magnitude-4d.js";
+export * from "./magnitude-sq-4d.js";
+export * from "./multiply-4d.js";
+export * from "./negate-4d.js";
+export * from "./normalize-4d.js";
+export * from "./one-4d.js";
+export * from "./project-4d.js";
+export * from "./random-4d.js";
+export * from "./reflect-4d.js";
+export * from "./set-magnitude-4d.js";
+export * from "./subtract-4d.js";
+export * from "./types.js";
+export * from "./zero-4d.js";

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

@@ -0,0 +1,44 @@
+/**
+ * Documentation for functional 4D Vector array operations.
+ * @module ArrayVector4D
+ */
+export * from "./add-4d.js";
+export * from "./angle-between-4d.js";
+export * from "./angle-w-4d.js";
+export * from "./angle-x-4d.js";
+export * from "./angle-y-4d.js";
+export * from "./angle-z-4d.js";
+export * from "./clamp-4d.js";
+export * from "./clone-4d.js";
+export * from "./distance-4d.js";
+export * from "./distance-chebyshev-4d.js";
+export * from "./distance-manhattan-4d.js";
+export * from "./distance-minkowski-4d.js";
+export * from "./distance-sq-4d.js";
+export * from "./divide-4d.js";
+export * from "./dot-4d.js";
+export * from "./from-object-4d.js";
+export * from "./immutable-4d.js";
+export * from "./is-equal-4d.js";
+export * from "./is-equal-approx-4d.js";
+export * from "./is-infinite-4d.js";
+export * from "./is-nan-4d.js";
+export * from "./is-opposite-4d.js";
+export * from "./is-zero-4d.js";
+export * from "./lerp-4d.js";
+export * from "./limit-max-4d.js";
+export * from "./limit-min-4d.js";
+export * from "./look-at-4d.js";
+export * from "./magnitude-4d.js";
+export * from "./magnitude-sq-4d.js";
+export * from "./multiply-4d.js";
+export * from "./negate-4d.js";
+export * from "./normalize-4d.js";
+export * from "./one-4d.js";
+export * from "./project-4d.js";
+export * from "./random-4d.js";
+export * from "./reflect-4d.js";
+export * from "./set-magnitude-4d.js";
+export * from "./subtract-4d.js";
+export * from "./types.js";
+export * from "./zero-4d.js";

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

@@ -0,0 +1,8 @@
+import type { ArrayVector4D } from "./types.js";
+/**
+ * Checks if two 4D vectors are exactly equal.
+ * @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 equal, `false` otherwse
+ */
+export declare const isEqual4D: (xyzw1: ArrayVector4D, xyzw2: ArrayVector4D) => boolean;

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

@@ -0,0 +1,7 @@
+/**
+ * Checks if two 4D vectors are exactly equal.
+ * @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 equal, `false` otherwse
+ */
+export const isEqual4D = (xyzw1, xyzw2) => xyzw1[0] === xyzw2[0] && xyzw1[1] === xyzw2[1] && xyzw1[2] === xyzw2[2] && xyzw1[3] === xyzw2[3];

package/dist/esm/4d/is-equal-approx-4d.d.ts

@@ -0,0 +1,9 @@
+import type { ArrayVector4D } from "./types.js";
+/**
+ * Checks if two 4D vectors are approximately equal within epsilon.
+ * @param {ArrayVector4D} xyzw1 - First vector as `[x, y, z, w]`
+ * @param {ArrayVector4D} xyzw2 - Second vector as `[x, y, z, w]`
+ * @param {number} epsilon - Maximum difference (default: `Number.EPSILON`)
+ * @returns {boolean} `true` if vectors are approximately equal, `false` otherwise
+ */
+export declare const isEqualApprox4D: (xyzw1: ArrayVector4D, xyzw2: ArrayVector4D, epsilon?: number) => boolean;

package/dist/esm/4d/is-equal-approx-4d.js

@@ -0,0 +1,11 @@
+/**
+ * Checks if two 4D vectors are approximately equal within epsilon.
+ * @param {ArrayVector4D} xyzw1 - First vector as `[x, y, z, w]`
+ * @param {ArrayVector4D} xyzw2 - Second vector as `[x, y, z, w]`
+ * @param {number} epsilon - Maximum difference (default: `Number.EPSILON`)
+ * @returns {boolean} `true` if vectors are approximately equal, `false` otherwise
+ */
+export const isEqualApprox4D = (xyzw1, xyzw2, epsilon = Number.EPSILON) => Math.abs(xyzw1[0] - xyzw2[0]) <= epsilon &&
+    Math.abs(xyzw1[1] - xyzw2[1]) <= epsilon &&
+    Math.abs(xyzw1[2] - xyzw2[2]) <= epsilon &&
+    Math.abs(xyzw1[3] - xyzw2[3]) <= epsilon;

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

@@ -0,0 +1,7 @@
+import type { ArrayVector4D } from "./types.js";
+/**
+ * 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 declare const isInfinite4D: (xyzw: ArrayVector4D) => boolean;

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;