@fimbul-works/vec 1.0.3 → 2.0.0

package/dist/cjs/2d/reflect-2d.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reflect2D = void 0;
+const dot_2d_js_1 = require("./dot-2d.js");
+/**
+ * Reflects the vector across a normal vector.
+ * The normal vector should be normalized (unit length).
+ * @param {ArrayVector2D} xy - Vector as `[x, y]` to reflect
+ * @param {ArrayVector2D} normal - Normal vector to reflect across (must be normalized)
+ * @returns {ArrayVector2D} The reflected vector
+ */
+const reflect2D = (xy, normal) => {
+    const dot = (0, dot_2d_js_1.dot2D)(xy, normal);
+    return [xy[0] - 2 * dot * normal[0], xy[1] - 2 * dot * normal[1]];
+};
+exports.reflect2D = reflect2D;

package/dist/cjs/2d/rotate-2d.d.ts

@@ -0,0 +1,9 @@
+import type { ArrayVector2D } from "./types.js";
+/**
+ * Rotates a 2D point around an arbitrary axis point
+ * @param {ArrayVector2D} xy - Point to rotate
+ * @param {number} phi - Rotation angle in radians
+ * @param {ArrayVector2D} axis - Rotation axis point (default: `[0, 0]`)
+ * @returns {ArrayVector2D} The rotated vector
+ */
+export declare const rotate2D: (xy: ArrayVector2D, phi: number, axis?: ArrayVector2D) => ArrayVector2D;

package/dist/cjs/2d/rotate-2d.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rotate2D = void 0;
+/**
+ * Rotates a 2D point around an arbitrary axis point
+ * @param {ArrayVector2D} xy - Point to rotate
+ * @param {number} phi - Rotation angle in radians
+ * @param {ArrayVector2D} axis - Rotation axis point (default: `[0, 0]`)
+ * @returns {ArrayVector2D} The rotated vector
+ */
+const rotate2D = (xy, phi, axis = [0, 0]) => {
+    const cos = Math.cos(phi);
+    const sin = Math.sin(phi);
+    // No need to translate if axis is [0, 0]
+    if (axis[0] === 0 && axis[1] === 0) {
+        return [xy[0] * cos - xy[1] * sin, xy[0] * sin + xy[1] * cos];
+    }
+    // Translate point to origin (relative to axis)
+    const translatedX = xy[0] - axis[0];
+    const translatedY = xy[1] - axis[1];
+    // Rotate around origin
+    const rotatedX = translatedX * cos - translatedY * sin;
+    const rotatedY = translatedX * sin + translatedY * cos;
+    // Translate back
+    return [rotatedX + axis[0], rotatedY + axis[1]];
+};
+exports.rotate2D = rotate2D;

package/dist/cjs/2d/set-magnitude-2d.d.ts

@@ -0,0 +1,9 @@
+import type { ArrayVector2D } from "./types.js";
+/**
+ * Sets the magnitude (length) of a 2D vector, maintaining its direction.
+ * @param {ArrayVector2D} xy - Vector as `[x, y]`
+ * @param {number} newMag - New magnitude
+ * @param {number} [m] - Optional current magnitude (default: `magnitude2D(xy)`)
+ * @returns {ArrayVector2D} The adjusted vector
+ */
+export declare const setMagnitude2D: (xy: ArrayVector2D, newMag: number, m?: number) => ArrayVector2D;

package/dist/cjs/2d/set-magnitude-2d.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setMagnitude2D = void 0;
+const magnitude_2d_js_1 = require("./magnitude-2d.js");
+/**
+ * Sets the magnitude (length) of a 2D vector, maintaining its direction.
+ * @param {ArrayVector2D} xy - Vector as `[x, y]`
+ * @param {number} newMag - New magnitude
+ * @param {number} [m] - Optional current magnitude (default: `magnitude2D(xy)`)
+ * @returns {ArrayVector2D} The adjusted vector
+ */
+const setMagnitude2D = (xy, newMag, m = (0, magnitude_2d_js_1.magnitude2D)(xy)) => [
+    (xy[0] / m) * newMag,
+    (xy[1] / m) * newMag,
+];
+exports.setMagnitude2D = setMagnitude2D;

package/dist/cjs/2d/subtract-2d.d.ts

@@ -0,0 +1,8 @@
+import type { ArrayVector2D } from "./types.js";
+/**
+ * Subtracts a 2D vector from another.
+ * @param {ArrayVector2D} xy1 - First vector as `[x, y]`
+ * @param {ArrayVector2D} xy2 - Second vector as `[x, y]`
+ * @returns {ArrayVector2D} The difference between vectors
+ */
+export declare const subtract2D: (xy1: ArrayVector2D, xy2: ArrayVector2D) => ArrayVector2D;

package/dist/cjs/2d/subtract-2d.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.subtract2D = void 0;
+/**
+ * Subtracts a 2D vector from another.
+ * @param {ArrayVector2D} xy1 - First vector as `[x, y]`
+ * @param {ArrayVector2D} xy2 - Second vector as `[x, y]`
+ * @returns {ArrayVector2D} The difference between vectors
+ */
+const subtract2D = (xy1, xy2) => [xy1[0] - xy2[0], xy1[1] - xy2[1]];
+exports.subtract2D = subtract2D;

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

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

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

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

package/dist/cjs/2d/zero-2d.d.ts

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

package/dist/cjs/2d/zero-2d.js

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

package/dist/cjs/3d/add-3d.d.ts

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

package/dist/cjs/3d/add-3d.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.add3D = void 0;
+/**
+ * Adds two 3D vectors.
+ * @param {ArrayVector3D} xyz1 - First vector as `[x, y, z]` as [x, y, z]
+ * @param {ArrayVector3D} xyz2 - Second vector as `[x, y, z]` as [x, y, z]
+ * @returns {ArrayVector3D} The sum of the vectors
+ */
+const add3D = (xyz1, xyz2) => [
+    xyz1[0] + xyz2[0],
+    xyz1[1] + xyz2[1],
+    xyz1[2] + xyz2[2],
+];
+exports.add3D = add3D;

package/dist/cjs/3d/angle-between-3d.d.ts

@@ -0,0 +1,10 @@
+import type { ArrayVector3D } from "./types";
+/**
+ * Calculates the angle between two 3D vectors.
+ * @param {ArrayVector3D} xyz1 - First vector as `[x, y, z]`
+ * @param {ArrayVector3D} xyz2 - Second vector as `[x, y, z]`
+ * @param {number} [m1] - Optional first vector magnitude (default: `magnitude3D(xyz1)`)
+ * @param {number} [m2] - Optional second vector magnitude (default: `magnitude3D(xyz2)`)
+ * @returns {number} Angle between the vectors in radians
+ */
+export declare const angleBetween3D: (xyz1: ArrayVector3D, xyz2: ArrayVector3D, m1?: number, m2?: number) => number;

package/dist/cjs/3d/angle-between-3d.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.angleBetween3D = void 0;
+const magnitude_3d_1 = require("./magnitude-3d");
+/**
+ * Calculates the angle between two 3D vectors.
+ * @param {ArrayVector3D} xyz1 - First vector as `[x, y, z]`
+ * @param {ArrayVector3D} xyz2 - Second vector as `[x, y, z]`
+ * @param {number} [m1] - Optional first vector magnitude (default: `magnitude3D(xyz1)`)
+ * @param {number} [m2] - Optional second vector magnitude (default: `magnitude3D(xyz2)`)
+ * @returns {number} Angle between the vectors in radians
+ */
+const angleBetween3D = (xyz1, xyz2, m1 = (0, magnitude_3d_1.magnitude3D)(xyz1), m2 = (0, magnitude_3d_1.magnitude3D)(xyz2)) => Math.acos((xyz1[0] * xyz2[0] + xyz1[1] * xyz2[1] + xyz1[2] * xyz2[2]) / (m1 * m2));
+exports.angleBetween3D = angleBetween3D;

package/dist/cjs/3d/angle-x-3d.d.ts

@@ -0,0 +1,7 @@
+import type { ArrayVector3D } from "./types";
+/**
+ * Gets the angle between a 3D vector and the positive x-axis in radians.
+ * @param {ArrayVector3D} xyz - Vector as `[x, y, z]`
+ * @returns {number} Angle in radians, always in the range [0, 2π)
+ */
+export declare const angleX3D: (xyz: ArrayVector3D) => number;

package/dist/cjs/3d/angle-x-3d.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.angleX3D = void 0;
+/**
+ * Gets the angle between a 3D vector and the positive x-axis in radians.
+ * @param {ArrayVector3D} xyz - Vector as `[x, y, z]`
+ * @returns {number} Angle in radians, always in the range [0, 2π)
+ */
+const angleX3D = (xyz) => Math.atan2(Math.sqrt(xyz[1] ** 2 + xyz[2] ** 2), xyz[0]);
+exports.angleX3D = angleX3D;

package/dist/cjs/3d/angle-y-3d.d.ts

@@ -0,0 +1,7 @@
+import type { ArrayVector3D } from "./types";
+/**
+ * Gets the angle between a 3D vector and the positive y-axis in radians.
+ * @param {ArrayVector3D} xyz - Vector as `[x, y, z]`
+ * @returns {number} Angle in radians, always in the range [0, 2π)
+ */
+export declare const angleY3D: (xyz: ArrayVector3D) => number;

package/dist/cjs/3d/angle-y-3d.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.angleY3D = void 0;
+/**
+ * Gets the angle between a 3D vector and the positive y-axis in radians.
+ * @param {ArrayVector3D} xyz - Vector as `[x, y, z]`
+ * @returns {number} Angle in radians, always in the range [0, 2π)
+ */
+const angleY3D = (xyz) => Math.atan2(Math.sqrt(xyz[2] ** 2 + xyz[0] ** 2), xyz[1]);
+exports.angleY3D = angleY3D;

package/dist/cjs/3d/angle-z-3d.d.ts

@@ -0,0 +1,7 @@
+import type { ArrayVector3D } from "./types";
+/**
+ * Gets the angle between a 3D vector and the positive z-axis in radians.
+ * @param {ArrayVector3D} xyz - Vector as `[x, y, z]`
+ * @returns {number} Angle in radians, always in the range [0, 2π)
+ */
+export declare const angleZ3D: (xyz: ArrayVector3D) => number;

package/dist/cjs/3d/angle-z-3d.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.angleZ3D = void 0;
+/**
+ * Gets the angle between a 3D vector and the positive z-axis in radians.
+ * @param {ArrayVector3D} xyz - Vector as `[x, y, z]`
+ * @returns {number} Angle in radians, always in the range [0, 2π)
+ */
+const angleZ3D = (xyz) => Math.atan2(Math.sqrt(xyz[0] ** 2 + xyz[1] ** 2), xyz[2]);
+exports.angleZ3D = angleZ3D;

package/dist/cjs/3d/clamp-3d.d.ts

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

package/dist/cjs/3d/clamp-3d.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clamp3D = void 0;
+const magnitude_3d_1 = require("./magnitude-3d");
+/**
+ * Clamps the magnitude of a vector between min and max.
+ * @param {ArrayVector3D} xyz - Vector as `[x, y, z]`
+ * @param {number} min - Minimum magnitude
+ * @param {number} max - Maximum magnitude
+ * @param {number} [m] - Optional current magnitude (default: `magnitude3D(xyz)`)
+ * @returns {ArrayVector3D} The clamped vector
+ */
+const clamp3D = (xyz, min, max, m = (0, magnitude_3d_1.magnitude3D)(xyz)) => m > max
+    ? [(xyz[0] / m) * max, (xyz[1] / m) * max, (xyz[2] / m) * max]
+    : m < min
+        ? [(xyz[0] / m) * min, (xyz[1] / m) * min, (xyz[2] / m) * min]
+        : xyz;
+exports.clamp3D = clamp3D;

package/dist/cjs/3d/clone-3d.d.ts

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

package/dist/cjs/3d/clone-3d.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clone3D = void 0;
+/**
+ * Clone a 3D vector.
+ * @param {ArrayVector3D} xyz - Vector as `[x, y, z]`
+ * @returns {ArrayVector3D} The cloned vector
+ */
+const clone3D = (xyz) => [xyz[0], xyz[1], xyz[2]];
+exports.clone3D = clone3D;

package/dist/cjs/3d/cross-3d.d.ts

@@ -0,0 +1,8 @@
+import type { ArrayVector3D } from "./types.js";
+/**
+ * Calculates the cross product of two 3D vectors.
+ * @param {ArrayVector3D} xyz1 - First vector as `[x, y, z]`
+ * @param {ArrayVector3D} xyz2 - Second vector as `[x, y, z]`
+ * @returns {ArrayVector3D} The cross product
+ */
+export declare const cross3D: (xyz1: ArrayVector3D, xyz2: ArrayVector3D) => ArrayVector3D;

package/dist/cjs/3d/cross-3d.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cross3D = void 0;
+/**
+ * Calculates the cross product of two 3D vectors.
+ * @param {ArrayVector3D} xyz1 - First vector as `[x, y, z]`
+ * @param {ArrayVector3D} xyz2 - Second vector as `[x, y, z]`
+ * @returns {ArrayVector3D} The cross product
+ */
+const cross3D = (xyz1, xyz2) => [
+    xyz1[1] * xyz2[2] - xyz1[2] * xyz2[1],
+    xyz1[2] * xyz2[0] - xyz1[0] * xyz2[2],
+    xyz1[0] * xyz2[1] - xyz1[1] * xyz2[0],
+];
+exports.cross3D = cross3D;

package/dist/cjs/3d/distance-3d.d.ts

@@ -0,0 +1,8 @@
+import type { ArrayVector3D } from "./types";
+/**
+ * Calculates the Euclidean distance between two 3D vectors.
+ * @param {ArrayVector3D} xyz1 - First vector as `[x, y, z]`
+ * @param {ArrayVector3D} xyz2 - Second vector as `[x, y, z]`
+ * @returns {number} Euclidian distance
+ */
+export declare const distance3D: (xyz1: ArrayVector3D, xyz2: ArrayVector3D) => number;

package/dist/cjs/3d/distance-3d.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.distance3D = void 0;
+/**
+ * Calculates the Euclidean distance between two 3D vectors.
+ * @param {ArrayVector3D} xyz1 - First vector as `[x, y, z]`
+ * @param {ArrayVector3D} xyz2 - Second vector as `[x, y, z]`
+ * @returns {number} Euclidian distance
+ */
+const distance3D = (xyz1, xyz2) => Math.sqrt((xyz1[0] - xyz2[0]) ** 2 + (xyz1[1] - xyz2[1]) ** 2 + (xyz1[2] - xyz2[2]) ** 2);
+exports.distance3D = distance3D;

package/dist/cjs/3d/distance-chebyshev-3d.d.ts

@@ -0,0 +1,8 @@
+import type { ArrayVector3D } from "./types";
+/**
+ * Calculates the Chebyshev distance between two 3D vectors.
+ * @param {ArrayVector3D} xyz1 - First vector as `[x, y, z]` as
+ * @param {ArrayVector3D} xyz2 - Second vector as `[x, y, z]` as
+ * @returns {number} Chebyshev distance
+ */
+export declare const distanceChebyshev3D: (xyz1: ArrayVector3D, xyz2: ArrayVector3D) => number;

package/dist/cjs/3d/distance-chebyshev-3d.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.distanceChebyshev3D = void 0;
+/**
+ * Calculates the Chebyshev distance between two 3D vectors.
+ * @param {ArrayVector3D} xyz1 - First vector as `[x, y, z]` as
+ * @param {ArrayVector3D} xyz2 - Second vector as `[x, y, z]` as
+ * @returns {number} Chebyshev distance
+ */
+const distanceChebyshev3D = (xyz1, xyz2) => {
+    const absX = Math.abs(xyz1[0] - xyz2[0]);
+    const absY = Math.abs(xyz1[1] - xyz2[1]);
+    const absZ = Math.abs(xyz1[2] - xyz2[2]);
+    return absX >= absY && absX >= absZ ? absX : absY >= absZ ? absY : absZ;
+};
+exports.distanceChebyshev3D = distanceChebyshev3D;

package/dist/cjs/3d/distance-manhattan-3d.d.ts

@@ -0,0 +1,8 @@
+import type { ArrayVector3D } from "./types";
+/**
+ * Calculates the Manhattan distance between two 3D vectors.
+ * @param {ArrayVector3D} xyz1 - First vector as `[x, y, z]`
+ * @param {ArrayVector3D} xyz2 - Second vector as `[x, y, z]`
+ * @returns {number} Manhattan distance
+ */
+export declare const distanceManhattan3D: (xyz1: ArrayVector3D, xyz2: ArrayVector3D) => number;

package/dist/cjs/3d/distance-manhattan-3d.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.distanceManhattan3D = void 0;
+/**
+ * Calculates the Manhattan distance between two 3D vectors.
+ * @param {ArrayVector3D} xyz1 - First vector as `[x, y, z]`
+ * @param {ArrayVector3D} xyz2 - Second vector as `[x, y, z]`
+ * @returns {number} Manhattan distance
+ */
+const distanceManhattan3D = (xyz1, xyz2) => Math.abs(xyz1[0] - xyz2[0]) + Math.abs(xyz1[1] - xyz2[1]) + Math.abs(xyz1[2] - xyz2[2]);
+exports.distanceManhattan3D = distanceManhattan3D;

package/dist/cjs/3d/distance-minkowski-3d.d.ts

@@ -0,0 +1,9 @@
+import type { ArrayVector3D } from "./types";
+/**
+ * Calculates the Minkowski distance between two 3D vectors.
+ * @param {ArrayVector3D} xyz1 - First vector as `[x, y, z]`
+ * @param {ArrayVector3D} xyz2 - Second vector as `[x, y, z]`
+ * @param {number} p - Order of the Minkowski distance
+ * @returns {number} Minkowski distance
+ */
+export declare const distanceMinkowski3D: (xyz1: ArrayVector3D, xyz2: ArrayVector3D, p: number) => number;

package/dist/cjs/3d/distance-minkowski-3d.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.distanceMinkowski3D = void 0;
+/**
+ * Calculates the Minkowski distance between two 3D vectors.
+ * @param {ArrayVector3D} xyz1 - First vector as `[x, y, z]`
+ * @param {ArrayVector3D} xyz2 - Second vector as `[x, y, z]`
+ * @param {number} p - Order of the Minkowski distance
+ * @returns {number} Minkowski distance
+ */
+const distanceMinkowski3D = (xyz1, xyz2, p) => (Math.abs(xyz1[0] - xyz2[0]) ** p + Math.abs(xyz1[1] - xyz2[1]) ** p + Math.abs(xyz1[2] - xyz2[2]) ** p) ** (1 / p);
+exports.distanceMinkowski3D = distanceMinkowski3D;

package/dist/cjs/3d/distance-sq-3d.d.ts

@@ -0,0 +1,8 @@
+import type { ArrayVector3D } from "./types";
+/**
+ * Calculates the squared Euclidean distance between two 3D vectors.
+ * @param {ArrayVector3D} xyz1 - First vector as `[x, y, z]`
+ * @param {ArrayVector3D} xyz2 - Second vector as `[x, y, z]`
+ * @returns {number} Squared Euclidian distance
+ */
+export declare const distanceSq3D: (xyz1: ArrayVector3D, xyz2: ArrayVector3D) => number;

package/dist/cjs/3d/distance-sq-3d.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.distanceSq3D = void 0;
+/**
+ * Calculates the squared Euclidean distance between two 3D vectors.
+ * @param {ArrayVector3D} xyz1 - First vector as `[x, y, z]`
+ * @param {ArrayVector3D} xyz2 - Second vector as `[x, y, z]`
+ * @returns {number} Squared Euclidian distance
+ */
+const distanceSq3D = (xyz1, xyz2) => (xyz1[0] - xyz2[0]) ** 2 + (xyz1[1] - xyz2[1]) ** 2 + (xyz1[2] - xyz2[2]) ** 2;
+exports.distanceSq3D = distanceSq3D;

package/dist/cjs/3d/divide-3d.d.ts

@@ -0,0 +1,8 @@
+import type { ArrayVector3D } from "./types.js";
+/**
+ * Divides one 3D vector with another.
+ * @param {ArrayVector3D} xyz1 - First vector as `[x, y, z]`
+ * @param {ArrayVector3D} xyz2 - Second vector as `[x, y, z]`
+ * @returns {ArrayVector3D} The divided vector
+ */
+export declare const divide3D: (xyz1: ArrayVector3D, xyz2: ArrayVector3D) => ArrayVector3D;

package/dist/cjs/3d/divide-3d.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.divide3D = void 0;
+/**
+ * Divides one 3D vector with another.
+ * @param {ArrayVector3D} xyz1 - First vector as `[x, y, z]`
+ * @param {ArrayVector3D} xyz2 - Second vector as `[x, y, z]`
+ * @returns {ArrayVector3D} The divided vector
+ */
+const divide3D = (xyz1, xyz2) => [
+    xyz2[0] === 0 ? Number.POSITIVE_INFINITY : xyz1[0] / xyz2[0],
+    xyz2[1] === 0 ? Number.POSITIVE_INFINITY : xyz1[1] / xyz2[1],
+    xyz2[2] === 0 ? Number.POSITIVE_INFINITY : xyz1[2] / xyz2[2],
+];
+exports.divide3D = divide3D;

package/dist/cjs/3d/dot-3d.d.ts

@@ -0,0 +1,8 @@
+import type { ArrayVector3D } from "./types";
+/**
+ * Calculates the dot product of two 3D vectors.
+ * @param {ArrayVector3D} xyz1 - First vector as `[x, y, z]`
+ * @param {ArrayVector3D} xyz2 - Second vector as `[x, y, z]`
+ * @returns {number} Dot product
+ */
+export declare const dot3D: (xyz1: ArrayVector3D, xyz2: ArrayVector3D) => number;

package/dist/cjs/3d/dot-3d.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dot3D = void 0;
+/**
+ * Calculates the dot product of two 3D vectors.
+ * @param {ArrayVector3D} xyz1 - First vector as `[x, y, z]`
+ * @param {ArrayVector3D} xyz2 - Second vector as `[x, y, z]`
+ * @returns {number} Dot product
+ */
+const dot3D = (xyz1, xyz2) => xyz1[0] * xyz2[0] + xyz1[1] * xyz2[1] + xyz1[2] * xyz2[2];
+exports.dot3D = dot3D;

package/dist/cjs/3d/from-cylindrical-coords-3d.d.ts

@@ -0,0 +1,9 @@
+import type { ArrayVector3D } from "./types";
+/**
+ * Creates a vector from cylindrical coordinates.
+ * @param {number} r - Radius
+ * @param {number} phi - Angle in radians
+ * @param {number} z - Vector z axis
+ * @returns {ArrayVector3D} Vector
+ */
+export declare const fromCylindricalCoords: (r: number, phi: number, z: number) => ArrayVector3D;

package/dist/cjs/3d/from-cylindrical-coords-3d.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fromCylindricalCoords = void 0;
+/**
+ * Creates a vector from cylindrical coordinates.
+ * @param {number} r - Radius
+ * @param {number} phi - Angle in radians
+ * @param {number} z - Vector z axis
+ * @returns {ArrayVector3D} Vector
+ */
+const fromCylindricalCoords = (r, phi, z) => [
+    r * Math.cos(phi),
+    r * Math.sin(phi),
+    z,
+];
+exports.fromCylindricalCoords = fromCylindricalCoords;

package/dist/cjs/3d/from-object-3d.d.ts

@@ -0,0 +1,11 @@
+import type { ArrayVector3D } from "./types.js";
+/**
+ * Creates an ArrayVector3D from an object with x, y and z properties.
+ * @param {{ x: number; y: number; z: number }} vector3D - Object with x, y and z properties
+ * @returns {ArrayVector3D} Vector
+ */
+export declare const fromObject3D: ({ x, y, z }: {
+    x: number;
+    y: number;
+    z: number;
+}) => ArrayVector3D;

package/dist/cjs/3d/from-object-3d.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fromObject3D = void 0;
+/**
+ * Creates an ArrayVector3D from an object with x, y and z properties.
+ * @param {{ x: number; y: number; z: number }} vector3D - Object with x, y and z properties
+ * @returns {ArrayVector3D} Vector
+ */
+const fromObject3D = ({ x, y, z }) => [x, y, z];
+exports.fromObject3D = fromObject3D;

package/dist/cjs/3d/from-spherical-coords-3d.d.ts

@@ -0,0 +1,9 @@
+import type { ArrayVector3D } from "./types";
+/**
+ * Creates a 3D vector from spherical coordinates.
+ * @param {number} theta - First angle
+ * @param {number} phi - Second angle
+ * @param {number} [m] - Optional magnitude (default: `1`)
+ * @returns {ArrayVector3D} Vector
+ */
+export declare const fromSphericalCoords3D: (theta: number, phi: number, m?: number) => ArrayVector3D;

package/dist/cjs/3d/from-spherical-coords-3d.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fromSphericalCoords3D = void 0;
+/**
+ * Creates a 3D vector from spherical coordinates.
+ * @param {number} theta - First angle
+ * @param {number} phi - Second angle
+ * @param {number} [m] - Optional magnitude (default: `1`)
+ * @returns {ArrayVector3D} Vector
+ */
+const fromSphericalCoords3D = (theta, phi, m = 1) => [
+    m * Math.sin(theta) * Math.cos(phi),
+    m * Math.sin(theta) * Math.sin(phi),
+    m * Math.cos(theta),
+];
+exports.fromSphericalCoords3D = fromSphericalCoords3D;

package/dist/cjs/3d/immutable-3d.d.ts

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

package/dist/cjs/3d/immutable-3d.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.immutable3D = void 0;
+/**
+ * Create an immutable 3D vector.
+ * @param {ArrayVector3D} xyz - Vector as `[x, y, z]`
+ * @returns {Readonly<ArrayVector3D>} The immutable vector
+ */
+const immutable3D = (xyz) => Object.freeze([xyz[0], xyz[1], xyz[2]]);
+exports.immutable3D = immutable3D;