@fimbul-works/vec 1.0.3 → 2.0.0

package/dist/cjs/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/cjs/2d/from-angle-y-2d.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fromAngleY2D = void 0;
+/**
+ * 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
+ */
+const fromAngleY2D = (phi, magnitude = 1) => [
+    magnitude * -Math.sin(phi),
+    magnitude * Math.cos(phi),
+];
+exports.fromAngleY2D = fromAngleY2D;

package/dist/cjs/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/cjs/2d/from-object-2d.js

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

package/dist/cjs/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/cjs/2d/from-polar-coords-2d.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fromPolarCoords2D = void 0;
+/**
+ * Creates an `ArrayVector2D` from polar coordinates.
+ * @param {number} phi - Angle in radians
+ * @param {number} [m] - Optional magnitude (default: `1`)
+ * @returns {ArrayVector2D} Vector
+ */
+const fromPolarCoords2D = (phi, m = 1) => [m * Math.cos(phi), m * Math.sin(phi)];
+exports.fromPolarCoords2D = fromPolarCoords2D;

package/dist/cjs/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/cjs/2d/immutable-2d.js

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

package/dist/cjs/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/cjs/2d/index.js

@@ -0,0 +1,63 @@
+"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 2D Vector array operations.
+ * @module ArrayVector2D
+ */
+__exportStar(require("./add-2d.js"), exports);
+__exportStar(require("./angle-between-2d.js"), exports);
+__exportStar(require("./angle-x-2d.js"), exports);
+__exportStar(require("./angle-y-2d.js"), exports);
+__exportStar(require("./clamp-2d.js"), exports);
+__exportStar(require("./clone-2d.js"), exports);
+__exportStar(require("./cross-2d.js"), exports);
+__exportStar(require("./distance-2d.js"), exports);
+__exportStar(require("./distance-chebyshev-2d.js"), exports);
+__exportStar(require("./distance-manhattan-2d.js"), exports);
+__exportStar(require("./distance-minkowski-2d.js"), exports);
+__exportStar(require("./distance-sq-2d.js"), exports);
+__exportStar(require("./divide-2d.js"), exports);
+__exportStar(require("./dot-2d.js"), exports);
+__exportStar(require("./from-angle-x-2d.js"), exports);
+__exportStar(require("./from-angle-y-2d.js"), exports);
+__exportStar(require("./from-object-2d.js"), exports);
+__exportStar(require("./from-polar-coords-2d.js"), exports);
+__exportStar(require("./immutable-2d.js"), exports);
+__exportStar(require("./is-equal-2d.js"), exports);
+__exportStar(require("./is-equal-approx-2d.js"), exports);
+__exportStar(require("./is-infinite-2d.js"), exports);
+__exportStar(require("./is-nan-2d.js"), exports);
+__exportStar(require("./is-opposite-2d.js"), exports);
+__exportStar(require("./is-zero-2d.js"), exports);
+__exportStar(require("./lerp-2d.js"), exports);
+__exportStar(require("./limit-max-2d.js"), exports);
+__exportStar(require("./limit-min-2d.js"), exports);
+__exportStar(require("./look-at-2d.js"), exports);
+__exportStar(require("./magnitude-2d.js"), exports);
+__exportStar(require("./magnitude-sq-2d.js"), exports);
+__exportStar(require("./multiply-2d.js"), exports);
+__exportStar(require("./negate-2d.js"), exports);
+__exportStar(require("./normalize-2d.js"), exports);
+__exportStar(require("./one-2d.js"), exports);
+__exportStar(require("./project-2d.js"), exports);
+__exportStar(require("./random-2d.js"), exports);
+__exportStar(require("./reflect-2d.js"), exports);
+__exportStar(require("./rotate-2d.js"), exports);
+__exportStar(require("./set-magnitude-2d.js"), exports);
+__exportStar(require("./subtract-2d.js"), exports);
+__exportStar(require("./types.js"), exports);
+__exportStar(require("./zero-2d.js"), exports);

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

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

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

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isEqualApprox2D = void 0;
+/**
+ * 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
+ */
+const isEqualApprox2D = (xy1, xy2, epsilon = Number.EPSILON) => Math.abs(xy1[0] - xy2[0]) <= epsilon && Math.abs(xy1[1] - xy2[1]) <= epsilon;
+exports.isEqualApprox2D = isEqualApprox2D;

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

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isInfinite2D = void 0;
+/**
+ * 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
+ */
+const isInfinite2D = (xy) => xy[0] === Number.POSITIVE_INFINITY ||
+    xy[0] === Number.NEGATIVE_INFINITY ||
+    xy[1] === Number.POSITIVE_INFINITY ||
+    xy[1] === Number.NEGATIVE_INFINITY;
+exports.isInfinite2D = isInfinite2D;

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

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

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

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

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

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isZero2D = void 0;
+/**
+ * Checks if a vector is zero.
+ * @param {ArrayVector2D} xy - Vector as `[x, y]`
+ * @returns {boolean} `true` if the vector is zero, `false` otherwise
+ */
+const isZero2D = (xy) => xy[0] === 0 && xy[1] === 0;
+exports.isZero2D = isZero2D;

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

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

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

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

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

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

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

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lookAt2D = void 0;
+const magnitude_2d_js_1 = require("./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
+ */
+const lookAt2D = (xy1, xy2, m1 = (0, magnitude_2d_js_1.magnitude2D)(xy1), m2 = (0, magnitude_2d_js_1.magnitude2D)(xy2)) => [(xy2[0] / m2) * m1, (xy2[1] / m2) * m1];
+exports.lookAt2D = lookAt2D;

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

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.magnitude2D = void 0;
+/**
+ * Calculates the magnitude of a 2D vector.
+ * @param {ArrayVector2D} xy - Vector as `[x, y]`
+ * @returns {number} Magnitude of the vector
+ */
+const magnitude2D = (xy) => Math.sqrt(xy[0] ** 2 + xy[1] ** 2);
+exports.magnitude2D = magnitude2D;

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

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.magnitudeSq2D = void 0;
+/**
+ * Calculate the squared magnitude of a 2D vector.
+ * @param {ArrayVector2D} xy - Vector as `[x, y]`
+ * @returns {number} Squared magnitude
+ */
+const magnitudeSq2D = (xy) => xy[0] ** 2 + xy[1] ** 2;
+exports.magnitudeSq2D = magnitudeSq2D;

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

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

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

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

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

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalize2D = void 0;
+const magnitude_2d_js_1 = require("./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
+ */
+const normalize2D = (xy, m = (0, magnitude_2d_js_1.magnitude2D)(xy)) => m === 0 ? [0, 0] : [xy[0] / m, xy[1] / m];
+exports.normalize2D = normalize2D;

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

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

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

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.project2D = void 0;
+const magnitude_2d_js_1 = require("./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
+ */
+const project2D = (xy1, xy2, m1 = (0, magnitude_2d_js_1.magnitude2D)(xy1), m2 = (0, magnitude_2d_js_1.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];
+};
+exports.project2D = project2D;

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

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.random2D = void 0;
+/**
+ * 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
+ */
+const random2D = (random = Math.random) => {
+    const phi = random() * Math.PI * 2;
+    return [Math.cos(phi), Math.sin(phi)];
+};
+exports.random2D = random2D;

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