@fimbul-works/vec 1.0.3 → 2.0.0

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

@@ -0,0 +1,9 @@
+import type { ArrayVector2D } from "./types.js";
+/**
+ * Limits the maximum magnitude of a 2D vector.
+ * @param {ArrayVector2D} xy - Vector as `[x, y]`
+ * @param {number} min - Minimum magnitude
+ * @param {number} [m] - Optional current magnitude (default: `magnitude2D(xy)`)
+ * @returns {ArrayVector2D} The limited vector
+ */
+export declare const limitMin2D: (xy: ArrayVector2D, min: number, m?: number) => ArrayVector2D;

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

@@ -0,0 +1,9 @@
+import { magnitude2D } from "./magnitude-2d.js";
+/**
+ * Limits the maximum magnitude of a 2D vector.
+ * @param {ArrayVector2D} xy - Vector as `[x, y]`
+ * @param {number} min - Minimum magnitude
+ * @param {number} [m] - Optional current magnitude (default: `magnitude2D(xy)`)
+ * @returns {ArrayVector2D} The limited vector
+ */
+export const limitMin2D = (xy, min, m = magnitude2D(xy)) => m < min ? [(xy[0] / m) * min, (xy[1] / m) * min] : xy;

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

@@ -0,0 +1,10 @@
+import type { ArrayVector2D } from "./types.js";
+/**
+ * Calculates the 2D vector angle of a vector pointing at another.
+ * @param {ArrayVector2D} xy1 - First vector as `[x, y]`
+ * @param {ArrayVector2D} xy2 - Second vector as `[x, y]` (target to look at)
+ * @param {number} [m1] - Optional current magnitude of the first vector (default: magnitude2D(xy1))
+ * @param {number} [m2] - Optional current magnitude of the second vector (default: magnitude2D(xy2))
+ * @returns {ArrayVector2D} Vector pointing at the target with the magnitude of xy1
+ */
+export declare const lookAt2D: (xy1: ArrayVector2D, xy2: ArrayVector2D, m1?: number, m2?: number) => ArrayVector2D;

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

@@ -0,0 +1,10 @@
+import { magnitude2D } from "./magnitude-2d.js";
+/**
+ * Calculates the 2D vector angle of a vector pointing at another.
+ * @param {ArrayVector2D} xy1 - First vector as `[x, y]`
+ * @param {ArrayVector2D} xy2 - Second vector as `[x, y]` (target to look at)
+ * @param {number} [m1] - Optional current magnitude of the first vector (default: magnitude2D(xy1))
+ * @param {number} [m2] - Optional current magnitude of the second vector (default: magnitude2D(xy2))
+ * @returns {ArrayVector2D} Vector pointing at the target with the magnitude of xy1
+ */
+export const lookAt2D = (xy1, xy2, m1 = magnitude2D(xy1), m2 = magnitude2D(xy2)) => [(xy2[0] / m2) * m1, (xy2[1] / m2) * m1];

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

@@ -0,0 +1,7 @@
+import type { ArrayVector2D } from "./types.js";
+/**
+ * Calculates the magnitude of a 2D vector.
+ * @param {ArrayVector2D} xy - Vector as `[x, y]`
+ * @returns {number} Magnitude of the vector
+ */
+export declare const magnitude2D: (xy: ArrayVector2D) => number;

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

@@ -0,0 +1,6 @@
+/**
+ * Calculates the magnitude of a 2D vector.
+ * @param {ArrayVector2D} xy - Vector as `[x, y]`
+ * @returns {number} Magnitude of the vector
+ */
+export const magnitude2D = (xy) => Math.sqrt(xy[0] ** 2 + xy[1] ** 2);

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

@@ -0,0 +1,7 @@
+import type { ArrayVector2D } from "./types.js";
+/**
+ * Calculate the squared magnitude of a 2D vector.
+ * @param {ArrayVector2D} xy - Vector as `[x, y]`
+ * @returns {number} Squared magnitude
+ */
+export declare const magnitudeSq2D: (xy: ArrayVector2D) => number;

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

@@ -0,0 +1,6 @@
+/**
+ * Calculate the squared magnitude of a 2D vector.
+ * @param {ArrayVector2D} xy - Vector as `[x, y]`
+ * @returns {number} Squared magnitude
+ */
+export const magnitudeSq2D = (xy) => xy[0] ** 2 + xy[1] ** 2;

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

@@ -0,0 +1,8 @@
+import type { ArrayVector2D } from "./types.js";
+/**
+ * Multiplies one 2D vector with another component-wise.
+ * @param {ArrayVector2D} xy1 - First vector as `[x, y]`
+ * @param {ArrayVector2D} xy2 - Second vector as `[x, y]`
+ * @returns {ArrayVector2D} The multiplied vector
+ */
+export declare const multiply2D: (xy1: ArrayVector2D, xy2: ArrayVector2D) => ArrayVector2D;

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

@@ -0,0 +1,7 @@
+/**
+ * Multiplies one 2D vector with another component-wise.
+ * @param {ArrayVector2D} xy1 - First vector as `[x, y]`
+ * @param {ArrayVector2D} xy2 - Second vector as `[x, y]`
+ * @returns {ArrayVector2D} The multiplied vector
+ */
+export const multiply2D = (xy1, xy2) => [xy1[0] * xy2[0], xy1[1] * xy2[1]];

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

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

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

@@ -0,0 +1,6 @@
+/**
+ * Negates a 2D vector.
+ * @param {ArrayVector2D} xy - Vector as `[x, y]`
+ * @returns {ArrayVector2D} The negated vector
+ */
+export const negate2D = (xy) => [-xy[0], -xy[1]];

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

@@ -0,0 +1,8 @@
+import type { ArrayVector2D } from "./types.js";
+/**
+ * Normalize a 2D vector.
+ * @param {ArrayVector2D} xy - Vector as `[x, y]`
+ * @param {number} [m] - Optional current magnitude (default: `magnitude2D(xy)`)
+ * @returns {ArrayVector2D} The normalized vector
+ */
+export declare const normalize2D: (xy: ArrayVector2D, m?: number) => ArrayVector2D;

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

@@ -0,0 +1,8 @@
+import { magnitude2D } from "./magnitude-2d.js";
+/**
+ * Normalize a 2D vector.
+ * @param {ArrayVector2D} xy - Vector as `[x, y]`
+ * @param {number} [m] - Optional current magnitude (default: `magnitude2D(xy)`)
+ * @returns {ArrayVector2D} The normalized vector
+ */
+export const normalize2D = (xy, m = magnitude2D(xy)) => m === 0 ? [0, 0] : [xy[0] / m, xy[1] / m];

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

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

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

@@ -0,0 +1,5 @@
+/**
+ * Creates a 2D vector with all components set to 1.0.
+ * @returns {ArrayVector2D} Vector `[1, 1]`
+ */
+export const one2D = () => [1, 1];

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

@@ -0,0 +1,10 @@
+import type { ArrayVector2D } from "./types.js";
+/**
+ * Projects one 2D vector onto another.
+ * @param {ArrayVector2D} xy1 - Vector to project
+ * @param {ArrayVector2D} xy2 - Vector to project onto
+ * @param {number} [m1] - Optional magnitude of the first vector (default: `magnitude2D(xy1)`)
+ * @param {number} [m2] - Optional magnitude of the second vector (default: `magnitude2D(xy2)`)
+ * @returns {ArrayVector2D} The projected vector
+ */
+export declare const project2D: (xy1: ArrayVector2D, xy2: ArrayVector2D, m1?: number, m2?: number) => ArrayVector2D;

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

@@ -0,0 +1,13 @@
+import { magnitude2D } from "./magnitude-2d.js";
+/**
+ * Projects one 2D vector onto another.
+ * @param {ArrayVector2D} xy1 - Vector to project
+ * @param {ArrayVector2D} xy2 - Vector to project onto
+ * @param {number} [m1] - Optional magnitude of the first vector (default: `magnitude2D(xy1)`)
+ * @param {number} [m2] - Optional magnitude of the second vector (default: `magnitude2D(xy2)`)
+ * @returns {ArrayVector2D} The projected vector
+ */
+export const project2D = (xy1, xy2, m1 = magnitude2D(xy1), m2 = magnitude2D(xy2)) => {
+    const f = m1 * Math.cos(Math.atan2(xy1[0] * xy2[1] - xy1[1] * xy2[0], xy1[0] * xy2[0] + xy1[1] * xy2[1]));
+    return [(xy2[0] / m2) * f, (xy2[1] / m2) * f];
+};

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

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

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

@@ -0,0 +1,9 @@
+/**
+ * Creates a random unit 2D vector.
+ * @param {() => void} random - A function that returns a random number between 0 and 1 (default: `Math.random`)
+ * @returns {ArrayVector2D} Random unit vector
+ */
+export const random2D = (random = Math.random) => {
+    const phi = random() * Math.PI * 2;
+    return [Math.cos(phi), Math.sin(phi)];
+};

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

@@ -0,0 +1,9 @@
+import type { ArrayVector2D } from "./types.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
+ */
+export declare const reflect2D: (xy: ArrayVector2D, normal: ArrayVector2D) => ArrayVector2D;

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

@@ -0,0 +1,12 @@
+import { dot2D } from "./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
+ */
+export const reflect2D = (xy, normal) => {
+    const dot = dot2D(xy, normal);
+    return [xy[0] - 2 * dot * normal[0], xy[1] - 2 * dot * normal[1]];
+};

package/dist/esm/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/esm/2d/rotate-2d.js

@@ -0,0 +1,23 @@
+/**
+ * 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 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]];
+};

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

@@ -0,0 +1,12 @@
+import { magnitude2D } from "./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
+ */
+export const setMagnitude2D = (xy, newMag, m = magnitude2D(xy)) => [
+    (xy[0] / m) * newMag,
+    (xy[1] / m) * newMag,
+];

package/dist/esm/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/esm/2d/subtract-2d.js

@@ -0,0 +1,7 @@
+/**
+ * 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 const subtract2D = (xy1, xy2) => [xy1[0] - xy2[0], xy1[1] - xy2[1]];

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

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

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

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

package/dist/esm/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/esm/2d/zero-2d.js

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

package/dist/esm/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/esm/3d/add-3d.js

@@ -0,0 +1,11 @@
+/**
+ * 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 const add3D = (xyz1, xyz2) => [
+    xyz1[0] + xyz2[0],
+    xyz1[1] + xyz2[1],
+    xyz1[2] + xyz2[2],
+];

package/dist/esm/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/esm/3d/angle-between-3d.js

@@ -0,0 +1,10 @@
+import { magnitude3D } from "./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
+ */
+export const angleBetween3D = (xyz1, xyz2, m1 = magnitude3D(xyz1), m2 = magnitude3D(xyz2)) => Math.acos((xyz1[0] * xyz2[0] + xyz1[1] * xyz2[1] + xyz1[2] * xyz2[2]) / (m1 * m2));

package/dist/esm/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/esm/3d/angle-x-3d.js

@@ -0,0 +1,6 @@
+/**
+ * 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 const angleX3D = (xyz) => Math.atan2(Math.sqrt(xyz[1] ** 2 + xyz[2] ** 2), xyz[0]);

package/dist/esm/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/esm/3d/angle-y-3d.js

@@ -0,0 +1,6 @@
+/**
+ * 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 const angleY3D = (xyz) => Math.atan2(Math.sqrt(xyz[2] ** 2 + xyz[0] ** 2), xyz[1]);

package/dist/esm/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/esm/3d/angle-z-3d.js

@@ -0,0 +1,6 @@
+/**
+ * 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 const angleZ3D = (xyz) => Math.atan2(Math.sqrt(xyz[0] ** 2 + xyz[1] ** 2), xyz[2]);

package/dist/esm/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/esm/3d/clamp-3d.js

@@ -0,0 +1,14 @@
+import { magnitude3D } from "./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
+ */
+export const clamp3D = (xyz, min, max, m = 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;

package/dist/esm/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/esm/3d/clone-3d.js

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

package/dist/esm/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/esm/3d/cross-3d.js

@@ -0,0 +1,11 @@
+/**
+ * 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 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],
+];

package/dist/esm/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/esm/3d/distance-3d.js

@@ -0,0 +1,7 @@
+/**
+ * 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 const distance3D = (xyz1, xyz2) => Math.sqrt((xyz1[0] - xyz2[0]) ** 2 + (xyz1[1] - xyz2[1]) ** 2 + (xyz1[2] - xyz2[2]) ** 2);

package/dist/esm/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/esm/3d/distance-chebyshev-3d.js

@@ -0,0 +1,12 @@
+/**
+ * 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 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;
+};

package/dist/esm/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/esm/3d/distance-manhattan-3d.js

@@ -0,0 +1,7 @@
+/**
+ * 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 const distanceManhattan3D = (xyz1, xyz2) => Math.abs(xyz1[0] - xyz2[0]) + Math.abs(xyz1[1] - xyz2[1]) + Math.abs(xyz1[2] - xyz2[2]);

package/dist/esm/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/esm/3d/distance-minkowski-3d.js

@@ -0,0 +1,8 @@
+/**
+ * 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 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);

package/dist/esm/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/esm/3d/distance-sq-3d.js

@@ -0,0 +1,7 @@
+/**
+ * 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 const distanceSq3D = (xyz1, xyz2) => (xyz1[0] - xyz2[0]) ** 2 + (xyz1[1] - xyz2[1]) ** 2 + (xyz1[2] - xyz2[2]) ** 2;

package/dist/esm/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/esm/3d/divide-3d.js

@@ -0,0 +1,11 @@
+/**
+ * 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 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],
+];

package/dist/esm/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;