@fimbul-works/vec 1.0.3 → 2.0.0

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

@@ -0,0 +1,8 @@
+import type { ArrayVector2D } from "./types.js";
+/**
+ * Adds one 2D vectors.
+ * @param {ArrayVector2D} xy1 - First vector as `[x, y]`
+ * @param {ArrayVector2D} xy2 - Second vector as `[x, y]`
+ * @returns {ArrayVector2D} The sum of the vectors
+ */
+export declare const add2D: (xy1: ArrayVector2D, xy2: ArrayVector2D) => ArrayVector2D;

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

@@ -0,0 +1,7 @@
+/**
+ * Adds one 2D vectors.
+ * @param {ArrayVector2D} xy1 - First vector as `[x, y]`
+ * @param {ArrayVector2D} xy2 - Second vector as `[x, y]`
+ * @returns {ArrayVector2D} The sum of the vectors
+ */
+export const add2D = (xy1, xy2) => [xy1[0] + xy2[0], xy1[1] + xy2[1]];

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

@@ -0,0 +1,8 @@
+import type { ArrayVector2D } from "./types.js";
+/**
+ * Calculates the angle between two 2D vectors.
+ * @param {ArrayVector2D} xy1 - First vector as `[x, y]`
+ * @param {ArrayVector2D} xy2 - Second vector as `[x, y]`
+ * @returns {number} Angle between the vectors in radians
+ */
+export declare const angleBetween2D: (xy1: ArrayVector2D, xy2: ArrayVector2D) => number;

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

@@ -0,0 +1,7 @@
+/**
+ * Calculates the angle between two 2D vectors.
+ * @param {ArrayVector2D} xy1 - First vector as `[x, y]`
+ * @param {ArrayVector2D} xy2 - Second vector as `[x, y]`
+ * @returns {number} Angle between the vectors in radians
+ */
+export const angleBetween2D = (xy1, xy2) => Math.atan2(xy1[0] * xy2[1] - xy1[1] * xy2[0], xy1[0] * xy2[0] + xy1[1] * xy2[1]);

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

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

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

@@ -0,0 +1,6 @@
+/**
+ * Gets the angle between a 2D vector and the positive x-axis in radians.
+ * @param {ArrayVector2D} xy - Vector as `[x, y]`
+ * @returns {number} Angle in radians, always in the range [0, 2π)
+ */
+export const angleX2D = (xy) => Math.atan2(xy[1], xy[0] + (xy[1] < 0 ? Math.PI : 0));

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

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

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

@@ -0,0 +1,6 @@
+/**
+ * Gets the angle between a 2D vector and the positive y-axis in radians.
+ * @param {ArrayVector2D} xy - Vector as `[x, y]`
+ * @returns {number} Angle in radians, always in the range [0, 2π)
+ */
+export const angleY2D = (xy) => Math.atan2(xy[0], xy[1] + (xy[0] < 0 ? Math.PI : 0));

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

@@ -0,0 +1,10 @@
+import type { ArrayVector2D } from "./types.js";
+/**
+ * Clamps the magnitude of a 2D vector between a minimum and maximum value.
+ * @param {ArrayVector2D} xy - Vector as `[x, y]`
+ * @param {number} min - Minimum magnitude
+ * @param {number} max - Maximum magnitude
+ * @param {number} [m] - Optional current magnitude (default: `magnitude2D(xy)`)
+ * @returns {ArrayVector2D} The clamped vector
+ */
+export declare const clamp2D: (xy: ArrayVector2D, min: number, max: number, m?: number) => ArrayVector2D;

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

@@ -0,0 +1,10 @@
+import { magnitude2D } from "./magnitude-2d.js";
+/**
+ * Clamps the magnitude of a 2D vector between a minimum and maximum value.
+ * @param {ArrayVector2D} xy - Vector as `[x, y]`
+ * @param {number} min - Minimum magnitude
+ * @param {number} max - Maximum magnitude
+ * @param {number} [m] - Optional current magnitude (default: `magnitude2D(xy)`)
+ * @returns {ArrayVector2D} The clamped vector
+ */
+export const clamp2D = (xy, min, max, m = magnitude2D(xy)) => m > max ? [(xy[0] / m) * max, (xy[1] / m) * max] : m < min ? [(xy[0] / m) * min, (xy[1] / m) * min] : xy;

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

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

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

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

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

@@ -0,0 +1,8 @@
+import type { ArrayVector2D } from "./types.js";
+/**
+ * Calculates the cross product of two 2D vectors.
+ * @param {ArrayVector2D} xy1 - First vector as `[x, y]`
+ * @param {ArrayVector2D} xy2 - Second vector as `[x, y]`
+ * @returns {number} Cross product
+ */
+export declare const cross2D: (xy1: ArrayVector2D, xy2: ArrayVector2D) => number;

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

@@ -0,0 +1,7 @@
+/**
+ * Calculates the cross product of two 2D vectors.
+ * @param {ArrayVector2D} xy1 - First vector as `[x, y]`
+ * @param {ArrayVector2D} xy2 - Second vector as `[x, y]`
+ * @returns {number} Cross product
+ */
+export const cross2D = (xy1, xy2) => xy1[0] * xy2[1] - xy1[1] * xy2[0];

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

@@ -0,0 +1,8 @@
+import type { ArrayVector2D } from "./types.js";
+/**
+ * Calculate the Euclidean distance between two 2D vectors.
+ * @param {ArrayVector2D} xy1 - First vector as `[x, y]`
+ * @param {ArrayVector2D} xy2 - Second vector as `[x, y]`
+ * @returns {number} Euclidean distance
+ */
+export declare const distance2D: (xy1: ArrayVector2D, xy2: ArrayVector2D) => number;

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

@@ -0,0 +1,7 @@
+/**
+ * Calculate the Euclidean distance between two 2D vectors.
+ * @param {ArrayVector2D} xy1 - First vector as `[x, y]`
+ * @param {ArrayVector2D} xy2 - Second vector as `[x, y]`
+ * @returns {number} Euclidean distance
+ */
+export const distance2D = (xy1, xy2) => Math.sqrt((xy2[0] - xy1[0]) ** 2 + (xy2[1] - xy1[1]) ** 2);

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

@@ -0,0 +1,8 @@
+import type { ArrayVector2D } from "./types.js";
+/**
+ * Calculates the Chebyshev distance between two 2D vectors.
+ * @param {ArrayVector2D} xy1 - First vector as `[x, y]`
+ * @param {ArrayVector2D} xy2 - Second vector as `[x, y]`
+ * @returns {number} Chebyshev distance
+ */
+export declare const distanceChebyshev2D: (xy1: ArrayVector2D, xy2: ArrayVector2D) => number;

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

@@ -0,0 +1,11 @@
+/**
+ * Calculates the Chebyshev distance between two 2D vectors.
+ * @param {ArrayVector2D} xy1 - First vector as `[x, y]`
+ * @param {ArrayVector2D} xy2 - Second vector as `[x, y]`
+ * @returns {number} Chebyshev distance
+ */
+export const distanceChebyshev2D = (xy1, xy2) => {
+    const absX = Math.abs(xy1[0] - xy2[0]);
+    const absY = Math.abs(xy1[1] - xy2[1]);
+    return absX >= absY ? absX : absY;
+};

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

@@ -0,0 +1,8 @@
+import type { ArrayVector2D } from "./types.js";
+/**
+ * Calculates the Manhattan distance between two 2D vectors.
+ * @param {ArrayVector2D} xy1 - First vector as `[x, y]`
+ * @param {ArrayVector2D} xy2 - Second vector as `[x, y]`
+ * @returns {number} Manhattan distance
+ */
+export declare const distanceManhattan2D: (xy1: ArrayVector2D, xy2: ArrayVector2D) => number;

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

@@ -0,0 +1,7 @@
+/**
+ * Calculates the Manhattan distance between two 2D vectors.
+ * @param {ArrayVector2D} xy1 - First vector as `[x, y]`
+ * @param {ArrayVector2D} xy2 - Second vector as `[x, y]`
+ * @returns {number} Manhattan distance
+ */
+export const distanceManhattan2D = (xy1, xy2) => Math.abs(xy2[0] - xy1[0]) + Math.abs(xy2[1] - xy1[1]);

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

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

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

@@ -0,0 +1,8 @@
+/**
+ * Calculates the Minkowski distance between two 2D vectors.
+ * @param {ArrayVector2D} xy1 - First vector as `[x, y]`
+ * @param {ArrayVector2D} xy2 - Second vector as `[x, y]`
+ * @param {number} p - Order of the Minkowski distance
+ * @returns {number} Minkowski distance
+ */
+export const distanceMinkowski2D = (xy1, xy2, p) => (Math.abs(xy1[0] - xy2[0]) ** p + Math.abs(xy1[1] - xy2[1]) ** p) ** (1 / p);

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

@@ -0,0 +1,8 @@
+import type { ArrayVector2D } from "./types.js";
+/**
+ * Calculates the squared Euclidean distance between two 2D vectors.
+ * @param {ArrayVector2D} xy1 - First vector as `[x, y]`
+ * @param {ArrayVector2D} xy2 - Second vector as `[x, y]`
+ * @returns {number} Squared distance
+ */
+export declare const distanceSq2D: (xy1: ArrayVector2D, xy2: ArrayVector2D) => number;

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

@@ -0,0 +1,7 @@
+/**
+ * Calculates the squared Euclidean distance between two 2D vectors.
+ * @param {ArrayVector2D} xy1 - First vector as `[x, y]`
+ * @param {ArrayVector2D} xy2 - Second vector as `[x, y]`
+ * @returns {number} Squared distance
+ */
+export const distanceSq2D = (xy1, xy2) => (xy2[0] - xy1[0]) ** 2 + (xy2[1] - xy1[1]) ** 2;

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

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

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

@@ -0,0 +1,10 @@
+/**
+ * Divides one 2D vector with another.
+ * @param {ArrayVector2D} xy1 - First vector as `[x, y]`
+ * @param {ArrayVector2D} xy2 - Second vector as `[x, y]`
+ * @returns {ArrayVector2D} The divided value
+ */
+export const divide2D = (xy1, xy2) => [
+    xy2[0] === 0 ? Number.POSITIVE_INFINITY : xy1[0] / xy2[0],
+    xy2[1] === 0 ? Number.POSITIVE_INFINITY : xy1[1] / xy2[1],
+];

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

@@ -0,0 +1,8 @@
+import type { ArrayVector2D } from "./types.js";
+/**
+ * Calculates the dot product of two vectors.
+ * @param {ArrayVector2D} xy1 - First vector as `[x, y]`
+ * @param {ArrayVector2D} xy2 - Second vector as `[x, y]`
+ * @returns {number} Dot product
+ */
+export declare const dot2D: (xy1: ArrayVector2D, xy2: ArrayVector2D) => number;

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

@@ -0,0 +1,7 @@
+/**
+ * Calculates the dot product of two vectors.
+ * @param {ArrayVector2D} xy1 - First vector as `[x, y]`
+ * @param {ArrayVector2D} xy2 - Second vector as `[x, y]`
+ * @returns {number} Dot product
+ */
+export const dot2D = (xy1, xy2) => xy1[0] * xy2[0] + xy1[1] * xy2[1];

package/dist/esm/2d/from-angle-x-2d.d.ts

@@ -0,0 +1,8 @@
+import type { ArrayVector2D } from "./types.js";
+/**
+ * Creates an ArrayVector2D from x-axis angle.
+ * @param {number} phi - Angle in radians
+ * @param {number} magnitude - Optional magnitude of the vector (default: `1`)
+ * @returns {ArrayVector2D} Vector
+ */
+export declare const fromAngleX2D: (phi: number, magnitude?: number) => ArrayVector2D;

package/dist/esm/2d/from-angle-x-2d.js

@@ -0,0 +1,10 @@
+/**
+ * Creates an ArrayVector2D from x-axis angle.
+ * @param {number} phi - Angle in radians
+ * @param {number} magnitude - Optional magnitude of the vector (default: `1`)
+ * @returns {ArrayVector2D} Vector
+ */
+export const fromAngleX2D = (phi, magnitude = 1) => [
+    magnitude * Math.cos(phi),
+    magnitude * Math.sin(phi),
+];

package/dist/esm/2d/from-angle-y-2d.d.ts

@@ -0,0 +1,8 @@
+import type { ArrayVector2D } from "./types.js";
+/**
+ * Creates an ArrayVector2D from y-axis angle.
+ * @param {number} phi - Angle in radians
+ * @param {number} magnitude - Optional magnitude of the vector (default: `1`)
+ * @returns {ArrayVector2D} Vector
+ */
+export declare const fromAngleY2D: (phi: number, magnitude?: number) => ArrayVector2D;

package/dist/esm/2d/from-angle-y-2d.js

@@ -0,0 +1,10 @@
+/**
+ * Creates an ArrayVector2D from y-axis angle.
+ * @param {number} phi - Angle in radians
+ * @param {number} magnitude - Optional magnitude of the vector (default: `1`)
+ * @returns {ArrayVector2D} Vector
+ */
+export const fromAngleY2D = (phi, magnitude = 1) => [
+    magnitude * -Math.sin(phi),
+    magnitude * Math.cos(phi),
+];

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

@@ -0,0 +1,10 @@
+import type { ArrayVector2D } from "./types.js";
+/**
+ * Creates an `ArrayVector2D` from an object with x and y properties.
+ * @param {{ x: number, y: number }} vector2D - Object with x and y properties
+ * @returns {ArrayVector2D} 2D vector as an array
+ */
+export declare const fromObject2D: ({ x, y }: {
+    x: number;
+    y: number;
+}) => ArrayVector2D;

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

@@ -0,0 +1,6 @@
+/**
+ * Creates an `ArrayVector2D` from an object with x and y properties.
+ * @param {{ x: number, y: number }} vector2D - Object with x and y properties
+ * @returns {ArrayVector2D} 2D vector as an array
+ */
+export const fromObject2D = ({ x, y }) => [x, y];

package/dist/esm/2d/from-polar-coords-2d.d.ts

@@ -0,0 +1,8 @@
+import type { ArrayVector2D } from "./types.js";
+/**
+ * Creates an `ArrayVector2D` from polar coordinates.
+ * @param {number} phi - Angle in radians
+ * @param {number} [m] - Optional magnitude (default: `1`)
+ * @returns {ArrayVector2D} Vector
+ */
+export declare const fromPolarCoords2D: (phi: number, m?: number) => ArrayVector2D;

package/dist/esm/2d/from-polar-coords-2d.js

@@ -0,0 +1,7 @@
+/**
+ * Creates an `ArrayVector2D` from polar coordinates.
+ * @param {number} phi - Angle in radians
+ * @param {number} [m] - Optional magnitude (default: `1`)
+ * @returns {ArrayVector2D} Vector
+ */
+export const fromPolarCoords2D = (phi, m = 1) => [m * Math.cos(phi), m * Math.sin(phi)];

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

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

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

@@ -0,0 +1,6 @@
+/**
+ * Create an immutable 2D vector.
+ * @param {ArrayVector2D} xy - Vector as `[x, y]`
+ * @returns {Readonly<ArrayVector2D>} The immutable vector
+ */
+export const immutable2D = (xy) => Object.freeze([xy[0], xy[1]]);

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

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

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

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

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

@@ -0,0 +1,8 @@
+import type { ArrayVector2D } from "./types.js";
+/**
+ * Checks if two 2D vectors are equal.
+ * @param {ArrayVector2D} xy1 - First vector as `[x, y]`
+ * @param {ArrayVector2D} xy2 - Second vector as `[x, y]`
+ * @returns {boolean} `true` if the vectors are equal, `false` otherwise
+ */
+export declare const isEqual2D: (xy1: ArrayVector2D, xy2: ArrayVector2D) => boolean;

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

@@ -0,0 +1,7 @@
+/**
+ * Checks if two 2D vectors are equal.
+ * @param {ArrayVector2D} xy1 - First vector as `[x, y]`
+ * @param {ArrayVector2D} xy2 - Second vector as `[x, y]`
+ * @returns {boolean} `true` if the vectors are equal, `false` otherwise
+ */
+export const isEqual2D = (xy1, xy2) => xy1[0] === xy2[0] && xy1[1] === xy2[1];

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

@@ -0,0 +1,9 @@
+import type { ArrayVector2D } from "./types.js";
+/**
+ * Compares a 2D vector with another vector using an epsilon value for floating-point comparison.
+ * @param {ArrayVector2D} xy1 - First vector as `[x, y]`
+ * @param {ArrayVector2D} xy2 - Second vector as `[x, y]`
+ * @param {number} epsilon - Maximum difference between components to consider them equal (default: `Number.EPSILON`)
+ * @returns {boolean} `true` if the vectors are equal, `false` otherwise
+ */
+export declare const isEqualApprox2D: (xy1: ArrayVector2D, xy2: ArrayVector2D, epsilon?: number) => boolean;

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

@@ -0,0 +1,8 @@
+/**
+ * Compares a 2D vector with another vector using an epsilon value for floating-point comparison.
+ * @param {ArrayVector2D} xy1 - First vector as `[x, y]`
+ * @param {ArrayVector2D} xy2 - Second vector as `[x, y]`
+ * @param {number} epsilon - Maximum difference between components to consider them equal (default: `Number.EPSILON`)
+ * @returns {boolean} `true` if the vectors are equal, `false` otherwise
+ */
+export const isEqualApprox2D = (xy1, xy2, epsilon = Number.EPSILON) => Math.abs(xy1[0] - xy2[0]) <= epsilon && Math.abs(xy1[1] - xy2[1]) <= epsilon;

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

@@ -0,0 +1,7 @@
+import type { ArrayVector2D } from "./types.js";
+/**
+ * Checks if a vector has infinite components.
+ * @param {ArrayVector2D} xy - Vector as `[x, y]`
+ * @returns {ArrayVector2D} `true` if the vector has infinite components, `false` otherwise
+ */
+export declare const isInfinite2D: (xy: ArrayVector2D) => boolean;

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

@@ -0,0 +1,9 @@
+/**
+ * Checks if a vector has infinite components.
+ * @param {ArrayVector2D} xy - Vector as `[x, y]`
+ * @returns {ArrayVector2D} `true` if the vector has infinite components, `false` otherwise
+ */
+export const isInfinite2D = (xy) => xy[0] === Number.POSITIVE_INFINITY ||
+    xy[0] === Number.NEGATIVE_INFINITY ||
+    xy[1] === Number.POSITIVE_INFINITY ||
+    xy[1] === Number.NEGATIVE_INFINITY;

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

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

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

@@ -0,0 +1,6 @@
+/**
+ * Checks if a vector has NaN components.
+ * @param {ArrayVector2D} xy - Vector as `[x, y]`
+ * @returns {boolean} `true` if the vector has `NaN` components, `false` otherwise.
+ */
+export const isNaN2D = (xy) => Number.isNaN(xy[0]) || Number.isNaN(xy[1]);

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

@@ -0,0 +1,8 @@
+import type { ArrayVector2D } from "./types.js";
+/**
+ * Checks if two 2D vectors are opposite.
+ * @param {ArrayVector2D} xy1 - First vector as `[x, y]`
+ * @param {ArrayVector2D} xy2 - Second vector as `[x, y]`
+ * @returns {boolean} `true` if the vectors are opposite, `false` otherwise
+ */
+export declare const isOpposite2D: (xy1: ArrayVector2D, xy2: ArrayVector2D) => boolean;

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

@@ -0,0 +1,7 @@
+/**
+ * Checks if two 2D vectors are opposite.
+ * @param {ArrayVector2D} xy1 - First vector as `[x, y]`
+ * @param {ArrayVector2D} xy2 - Second vector as `[x, y]`
+ * @returns {boolean} `true` if the vectors are opposite, `false` otherwise
+ */
+export const isOpposite2D = (xy1, xy2) => xy1[0] === -xy2[0] && xy1[1] === -xy2[1];

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

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

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

@@ -0,0 +1,6 @@
+/**
+ * Checks if a vector is zero.
+ * @param {ArrayVector2D} xy - Vector as `[x, y]`
+ * @returns {boolean} `true` if the vector is zero, `false` otherwise
+ */
+export const isZero2D = (xy) => xy[0] === 0 && xy[1] === 0;

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

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

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

@@ -0,0 +1,11 @@
+/**
+ * Performs linear interpolation between two 2D vectors.
+ * @param {ArrayVector2D} xy1 - First vector as `[x, y]`
+ * @param {ArrayVector2D} xy2 - Second vector as `[x, y]`
+ * @param {number} t - Interpolation parameter
+ * @returns {ArrayVector2D} The interpolated vector
+ */
+export const lerp2D = (xy1, xy2, t) => [
+    xy1[0] + (xy2[0] - xy1[0]) * t,
+    xy1[1] + (xy2[1] - xy1[1]) * t,
+];

package/dist/esm/2d/limit-max-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} max - Maximum magnitude
+ * @param {number} [m] - Optional current magnitude (default: `magnitude2D(xy)`)
+ * @returns {ArrayVector2D} The limited vector
+ */
+export declare const limitMax2D: (xy: ArrayVector2D, max: number, m?: number) => ArrayVector2D;

package/dist/esm/2d/limit-max-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} max - Maximum magnitude
+ * @param {number} [m] - Optional current magnitude (default: `magnitude2D(xy)`)
+ * @returns {ArrayVector2D} The limited vector
+ */
+export const limitMax2D = (xy, max, m = magnitude2D(xy)) => m > max ? [(xy[0] / m) * max, (xy[1] / m) * max] : xy;