@fimbul-works/vec 1.0.3 → 2.0.0

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

@@ -0,0 +1,60 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Documentation for functional 4D Vector array operations.
+ * @module ArrayVector4D
+ */
+__exportStar(require("./add-4d.js"), exports);
+__exportStar(require("./angle-between-4d.js"), exports);
+__exportStar(require("./angle-w-4d.js"), exports);
+__exportStar(require("./angle-x-4d.js"), exports);
+__exportStar(require("./angle-y-4d.js"), exports);
+__exportStar(require("./angle-z-4d.js"), exports);
+__exportStar(require("./clamp-4d.js"), exports);
+__exportStar(require("./clone-4d.js"), exports);
+__exportStar(require("./distance-4d.js"), exports);
+__exportStar(require("./distance-chebyshev-4d.js"), exports);
+__exportStar(require("./distance-manhattan-4d.js"), exports);
+__exportStar(require("./distance-minkowski-4d.js"), exports);
+__exportStar(require("./distance-sq-4d.js"), exports);
+__exportStar(require("./divide-4d.js"), exports);
+__exportStar(require("./dot-4d.js"), exports);
+__exportStar(require("./from-object-4d.js"), exports);
+__exportStar(require("./immutable-4d.js"), exports);
+__exportStar(require("./is-equal-4d.js"), exports);
+__exportStar(require("./is-equal-approx-4d.js"), exports);
+__exportStar(require("./is-infinite-4d.js"), exports);
+__exportStar(require("./is-nan-4d.js"), exports);
+__exportStar(require("./is-opposite-4d.js"), exports);
+__exportStar(require("./is-zero-4d.js"), exports);
+__exportStar(require("./lerp-4d.js"), exports);
+__exportStar(require("./limit-max-4d.js"), exports);
+__exportStar(require("./limit-min-4d.js"), exports);
+__exportStar(require("./look-at-4d.js"), exports);
+__exportStar(require("./magnitude-4d.js"), exports);
+__exportStar(require("./magnitude-sq-4d.js"), exports);
+__exportStar(require("./multiply-4d.js"), exports);
+__exportStar(require("./negate-4d.js"), exports);
+__exportStar(require("./normalize-4d.js"), exports);
+__exportStar(require("./one-4d.js"), exports);
+__exportStar(require("./project-4d.js"), exports);
+__exportStar(require("./random-4d.js"), exports);
+__exportStar(require("./reflect-4d.js"), exports);
+__exportStar(require("./set-magnitude-4d.js"), exports);
+__exportStar(require("./subtract-4d.js"), exports);
+__exportStar(require("./types.js"), exports);
+__exportStar(require("./zero-4d.js"), exports);

package/dist/cjs/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/cjs/4d/is-equal-4d.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isEqual4D = void 0;
+/**
+ * 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
+ */
+const isEqual4D = (xyzw1, xyzw2) => xyzw1[0] === xyzw2[0] && xyzw1[1] === xyzw2[1] && xyzw1[2] === xyzw2[2] && xyzw1[3] === xyzw2[3];
+exports.isEqual4D = isEqual4D;

package/dist/cjs/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/cjs/4d/is-equal-approx-4d.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isEqualApprox4D = void 0;
+/**
+ * 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
+ */
+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;
+exports.isEqualApprox4D = isEqualApprox4D;

package/dist/cjs/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/cjs/4d/is-infinite-4d.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isInfinite4D = void 0;
+/**
+ * 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
+ */
+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;
+exports.isInfinite4D = isInfinite4D;

package/dist/cjs/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/cjs/4d/is-nan-4d.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isNan4D = void 0;
+/**
+ * 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
+ */
+const isNan4D = (xyzw) => Number.isNaN(xyzw[0]) || Number.isNaN(xyzw[1]) || Number.isNaN(xyzw[2]) || Number.isNaN(xyzw[3]);
+exports.isNan4D = isNan4D;

package/dist/cjs/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/cjs/4d/is-opposite-4d.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isOpposite4D = void 0;
+/**
+ * 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
+ */
+const isOpposite4D = (xyzw1, xyzw2) => xyzw1[0] === -xyzw2[0] && xyzw1[1] === -xyzw2[1] && xyzw1[2] === -xyzw2[2] && xyzw1[3] === -xyzw2[3];
+exports.isOpposite4D = isOpposite4D;

package/dist/cjs/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/cjs/4d/is-zero-4d.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isZero4D = void 0;
+/**
+ * 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
+ */
+const isZero4D = (xyzw) => xyzw[0] === 0 && xyzw[1] === 0 && xyzw[2] === 0 && xyzw[3] === 0;
+exports.isZero4D = isZero4D;

package/dist/cjs/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/cjs/4d/lerp-4d.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lerp4D = void 0;
+/**
+ * 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
+ */
+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,
+];
+exports.lerp4D = lerp4D;

package/dist/cjs/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/cjs/4d/limit-max-4d.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.limitMax4D = void 0;
+const magnitude_4d_js_1 = require("./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
+ */
+const limitMax4D = (xyzw, max, m = (0, magnitude_4d_js_1.magnitude4D)(xyzw)) => m > max ? [(xyzw[0] / m) * max, (xyzw[1] / m) * max, (xyzw[2] / m) * max, (xyzw[3] / m) * max] : xyzw;
+exports.limitMax4D = limitMax4D;

package/dist/cjs/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/cjs/4d/limit-min-4d.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.limitMin4D = void 0;
+const magnitude_4d_js_1 = require("./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
+ */
+const limitMin4D = (xyzw, min, m = (0, magnitude_4d_js_1.magnitude4D)(xyzw)) => m < min ? [(xyzw[0] / m) * min, (xyzw[1] / m) * min, (xyzw[2] / m) * min, (xyzw[3] / m) * min] : xyzw;
+exports.limitMin4D = limitMin4D;

package/dist/cjs/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/cjs/4d/look-at-4d.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lookAt4D = void 0;
+const magnitude_4d_js_1 = require("./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
+ */
+const lookAt4D = (xyzw1, xyzw2, m1 = (0, magnitude_4d_js_1.magnitude4D)(xyzw1), m2 = (0, magnitude_4d_js_1.magnitude4D)(xyzw2)) => [(xyzw2[0] / m2) * m1, (xyzw2[1] / m2) * m1, (xyzw2[2] / m2) * m1, (xyzw2[3] / m2) * m1];
+exports.lookAt4D = lookAt4D;

package/dist/cjs/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/cjs/4d/magnitude-4d.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.magnitude4D = void 0;
+/**
+ * Calculates the magnitude (length) of a 4D vector.
+ * @param {ArrayVector4D} xyzw - Vector as `[x, y, z, w]`
+ * @returns {number} The magnitude
+ */
+const magnitude4D = (xyzw) => Math.sqrt(xyzw[0] ** 2 + xyzw[1] ** 2 + xyzw[2] ** 2 + xyzw[3] ** 2);
+exports.magnitude4D = magnitude4D;

package/dist/cjs/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/cjs/4d/magnitude-sq-4d.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.magnitudeSq4D = void 0;
+/**
+ * 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
+ */
+const magnitudeSq4D = (xyzw) => xyzw[0] ** 2 + xyzw[1] ** 2 + xyzw[2] ** 2 + xyzw[3] ** 2;
+exports.magnitudeSq4D = magnitudeSq4D;

package/dist/cjs/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/cjs/4d/multiply-4d.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.multiply4D = void 0;
+/**
+ * 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
+ */
+const multiply4D = (xyzw1, xyzw2) => [
+    xyzw1[0] * xyzw2[0],
+    xyzw1[1] * xyzw2[1],
+    xyzw1[2] * xyzw2[2],
+    xyzw1[3] * xyzw2[3],
+];
+exports.multiply4D = multiply4D;

package/dist/cjs/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/cjs/4d/negate-4d.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.negate4D = void 0;
+/**
+ * Negates a 4D vector.
+ * @param {ArrayVector4D} xyzw - Vector as `[x, y, z, w]`
+ * @returns {ArrayVector4D} The negated vector
+ */
+const negate4D = (xyzw) => [-xyzw[0], -xyzw[1], -xyzw[2], -xyzw[3]];
+exports.negate4D = negate4D;

package/dist/cjs/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/cjs/4d/normalize-4d.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalize4D = void 0;
+const magnitude_4d_js_1 = require("./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
+ */
+const normalize4D = (xyzw, m = (0, magnitude_4d_js_1.magnitude4D)(xyzw)) => [
+    xyzw[0] / m,
+    xyzw[1] / m,
+    xyzw[2] / m,
+    xyzw[3] / m,
+];
+exports.normalize4D = normalize4D;

package/dist/cjs/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/cjs/4d/one-4d.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.one4D = void 0;
+/**
+ * Creates a 4D vector with all components set to 1.
+ * @returns {ArrayVector4D} A vector `[1, 1, 1, 1]`
+ */
+const one4D = () => [1, 1, 1, 1];
+exports.one4D = one4D;

package/dist/cjs/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/cjs/4d/project-4d.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.project4D = void 0;
+const dot_4d_js_1 = require("./dot-4d.js");
+const magnitude_4d_js_1 = require("./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
+ */
+const project4D = (xyzw1, xyzw2, m1 = (0, magnitude_4d_js_1.magnitude4D)(xyzw1), m2 = (0, magnitude_4d_js_1.magnitude4D)(xyzw2)) => {
+    const f = m1 * Math.cos(Math.acos((0, dot_4d_js_1.dot4D)(xyzw1, xyzw2) / (m1 * m2)));
+    return [(xyzw2[0] / m2) * f, (xyzw2[1] / m2) * f, (xyzw2[2] / m2) * f, (xyzw2[3] / m2) * f];
+};
+exports.project4D = project4D;

package/dist/cjs/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/cjs/4d/random-4d.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.random4D = void 0;
+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
+ */
+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];
+};
+exports.random4D = random4D;

package/dist/cjs/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/cjs/4d/reflect-4d.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reflect4D = void 0;
+const dot_4d_js_1 = require("./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
+ */
+const reflect4D = (xyzw, normal) => {
+    const dot = (0, dot_4d_js_1.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],
+    ];
+};
+exports.reflect4D = reflect4D;

package/dist/cjs/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/cjs/4d/set-magnitude-4d.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setMagnitude4D = void 0;
+const magnitude_4d_js_1 = require("./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
+ */
+const setMagnitude4D = (xyzw, newMag, m = (0, magnitude_4d_js_1.magnitude4D)(xyzw)) => [
+    (xyzw[0] / m) * newMag,
+    (xyzw[1] / m) * newMag,
+    (xyzw[2] / m) * newMag,
+    (xyzw[3] / m) * newMag,
+];
+exports.setMagnitude4D = setMagnitude4D;

package/dist/cjs/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/cjs/4d/subtract-4d.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.subtract4D = void 0;
+/**
+ * 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
+ */
+const subtract4D = (xyzw1, xyzw2) => [
+    xyzw1[0] - xyzw2[0],
+    xyzw1[1] - xyzw2[1],
+    xyzw1[2] - xyzw2[2],
+    xyzw1[3] - xyzw2[3],
+];
+exports.subtract4D = subtract4D;

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

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

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/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/cjs/4d/zero-4d.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.zero4D = void 0;
+/**
+ * Creates a zero 4D vector.
+ * @returns {ArrayVector4D} A zero vector `[0, 0, 0, 0]`
+ */
+const zero4D = () => [0, 0, 0, 0];
+exports.zero4D = zero4D;