@fimbul-works/vec 1.0.3 → 2.0.0

package/README.md

@@ -1,85 +1,208 @@
-# @fimbul-works/vec
-
-A high-performance TypeScript vector math library providing 2D, 3D, and 4D vector operations with a focus on performance and type safety.
-
-[![npm version](https://badge.fury.io/js/%40fimbul-works%2Fvec.svg)](https://www.npmjs.com/package/@fimbul-works/vec)
-[![TypeScript](https://badges.frapsoft.com/typescript/code/typescript.svg?v=101)](https://github.com/microsoft/TypeScript)
-
-## Features
-
-- 🚀 **Optimized Performance**: Uses `Float64Array` with magnitude caching and private fields
-- 🛡️ **Type Safety**: Full TypeScript support with strict typing and readonly options
-- 📏 **Multiple Distance Metrics**: Euclidean, Manhattan, Chebyshev, and Minkowski
-- 🔒 **Immutability Support**: Both mutable and immutable operation modes
-- 🎮 **Graphics Ready**: Homogeneous coordinates and transformation support
-- 🧮 **Math Features**: Comprehensive geometric and arithmetic operations
-- ⚡ **Memory Efficient**: Zero-allocation options for performance-critical code
-
-## Installation
-
-```bash
-npm install @fimbul-works/vec
-```
-
-## Quick Start
-
-```typescript
-import { Vec2, Vec3, Vec4 } from "@fimbul-works/vec";
-
-// Create and manipulate vectors
-const position = new Vec2(100, 200);
-const direction = new Vec2(1, 0).rotate(Math.PI / 4);
-const movement = Vec2.scale(direction, 5);
-
-position.add(movement);
-
-// 3D graphics with homogeneous coordinates
-const point = new Vec4(x, y, z, 1);    // Point in 3D space
-const vector = new Vec4(dx, dy, dz, 0); // Direction in 3D space
-```
-
-## Zero-Allocation Usage
-
-```typescript
-// Reuse vectors to avoid garbage collection
-const result = new Vec2();
-const temp = new Vec2();
-
-// Chain operations without creating intermediates
-position
-  .add(velocity.scale(deltaTime, temp))
-  .clamp(0, 100);
-```
-
-## Core Operations
-
-```typescript
-// Static operations (immutable)
-const sum = Vec2.add(v1, v2);
-const dot = Vec3.dot(v1, v2);
-const cross = Vec3.cross(v1, v2);
-
-// Method chaining (mutable)
-const result = new Vec3(1, 0, 0)
-  .rotate(angle)
-  .scale(2)
-  .normalize();
-
-// Distance calculations
-const dist = v1.distance(v2);
-const manhattan = v1.distanceManhattan(v2);
-```
-
-## Complete API Documentation
-
-- [Vec2 API Documentation](./VEC2.md)
-- [Vec3 API Documentation](./VEC3.md)
-- [Vec4 API Documentation](./VEC4.md)
-
-## License
-
-MIT License - See [LICENSE](LICENSE) file for details.
-
----
-
-Built with ⚡ by [FimbulWorks](https://github.com/fimbul-works)
+# @fimbul-works/vec
+
+A high-performance TypeScript vector math library providing both **functional** and **object-oriented** APIs for 2D, 3D, and 4D vector operations with a focus on performance, type safety, and immutability.
+
+[![npm version](https://badge.fury.io/js/%40fimbul-works%2Fvec.svg)](https://www.npmjs.com/package/@fimbul-works/vec)
+[![TypeScript](https://badges.frapsoft.com/typescript/code/typescript.svg?v=101)](https://github.com/microsoft/TypeScript)
+
+## ✨ Highlights
+
+- **🎯 Two API Styles**: Choose between modern functional API (arrays) or classic OOP API (classes)
+- **🛡️ Type Safe**: Full TypeScript support with strict typing and array tuple types
+- **📏 Multiple Distance Metrics**: Euclidean, Manhattan, Chebyshev, and Minkowski
+- **🎮 Graphics Ready**: Homogeneous coordinates and RGB/RGBA color support
+- **🧮 Comprehensive**: Complete set of vector operations for game dev, graphics, and physics
+- **🌳 Tree-Shakeable**: Import only what you need with the functional API
+
+## 📦 Installation
+
+```bash
+npm install @fimbul-works/vec
+```
+
+## 🚀 Quick Start
+
+### Functional API (Recommended)
+
+The **functional API** uses array tuples and is recommended for new projects:
+
+```typescript
+// Import the functional API
+import { add2D, magnitude2D, dot2D, normalize2D } from "@fimbul-works/vec/2d";
+import { add3D, cross3D } from "@fimbul-works/vec/3d";
+
+// Type: ArrayVector2D = [number, number]
+const position: ArrayVector2D = [100, 200];
+const velocity: ArrayVector2D = [5, 10];
+
+// Immutable operations return new arrays
+const newPosition = add2D(position, velocity); // [105, 210]
+const speed = magnitude2D(velocity); // 11.18...
+
+// 3D operations
+const v1: ArrayVector3D = [1, 2, 3];
+const v2: ArrayVector3D = [4, 5, 6];
+const sum = add3D(v1, v2); // [5, 7, 9]
+const cross = cross3D(v1, v2); // [-3, 6, -3]
+
+// Chain operations functionally
+const result = normalize2D(add2D(position, velocity));
+```
+
+**Benefits of the Functional API:**
+- ✅ Immutable - data never changes unexpectedly
+- ✅ Tree-shakeable - smaller bundles
+- ✅ Simple - just functions and arrays
+- ✅ Pattern-matching ready - works with destructuring
+
+### OOP API (Legacy)
+
+The **OOP API** uses mutable classes and is maintained for backward compatibility:
+
+```typescript
+import { Vec2, Vec3, Vec4 } from "@fimbul-works/vec";
+
+// Create and manipulate vectors
+const position = new Vec2(100, 200);
+const velocity = new Vec2(5, 10);
+
+position.add(velocity); // Mutates position
+
+// Method chaining
+const result = new Vec3(1, 0, 0)
+  .rotateY(Math.PI / 4)
+  .scale(2)
+  .normalize();
+
+// 3D graphics with homogeneous coordinates
+const point = new Vec4(x, y, z, 1);    // Point in 3D space
+const vector = new Vec4(dx, dy, dz, 0); // Direction in 3D space
+
+// Color manipulation with RGB accessors
+const color = new Vec3(0.8, 0.2, 0.4);
+color.r = 1.0; // Set red component
+```
+
+## 📖 API Documentation
+
+Complete API documentation generated by TypeDoc:
+
+### Functional API
+- **[2D Vector Functions](./docs/ArrayVector2D.md)** - Complete 2D functional API reference
+- **[3D Vector Functions](./docs/ArrayVector3D.md)** - Complete 3D functional API reference
+- **[4D Vector Functions](./docs/ArrayVector4D.md)** - Complete 4D functional API reference
+- **[Spherical Interpolation Functions](./docs/Slerp.md)** - Spherical Interpolation API reference
+
+### OOP API (Legacy)
+- **[Vec2 Class](./docs/Vec2.md)** - Complete Vec2 class documentation
+- **[Vec3 Class](./docs/Vec3.md)** - Complete Vec3 class documentation
+- **[Vec4 Class](./docs/Vec4.md)** - Complete Vec4 class documentation
+
+## 🎯 Common Operations
+
+### Functional API Examples
+
+```typescript
+import {
+  add2D, subtract2D, multiply2D, divide2D,
+  dot2D, cross2D,
+  magnitude2D, normalize2D, negate2D,
+  distance2D, distanceManhattan2D, distanceChebyshev2D,
+  lerp2D, clamp2D, limitMax2D, limitMin2D,
+  rotate2D, reflect2D, project2D,
+  angleBetween2D, angleX2D, angleY2D
+} from "@fimbul-works/vec/2d";
+
+// Vector arithmetic
+const v1: ArrayVector2D = [3, 4];
+const v2: ArrayVector2D = [1, 2];
+
+add2D(v1, v2);        // [4, 6]  - Addition
+subtract2D(v1, v2);   // [2, 2]  - Subtraction
+multiply2D(v1, v2);   // [3, 8]  - Component-wise multiplication
+divide2D(v1, v2);     // [3, 2]  - Component-wise division
+
+// Products
+dot2D(v1, v2);        // 11      - Dot product
+cross2D(v1, v2);      // 2       - 2D cross product (returns scalar)
+
+// Magnitude & normalization
+magnitude2D(v1);      // 5       - Vector length
+normalize2D(v1);     // [0.6, 0.8] - Unit vector
+negate2D(v1);        // [-3, -4] - Opposite direction
+
+// Distance metrics
+distance2D(v1, v2);           // 3.606  - Euclidean distance
+distanceManhattan2D(v1, v2);   // 4      - Manhattan distance
+distanceChebyshev2D(v1, v2);   // 2      - Chebyshev distance
+
+// Interpolation & clamping
+lerp2D(v1, v2, 0.5);  // [2, 3]  - Linear interpolation
+clamp2D(v1, 2, 8);     // Keeps magnitude between 2 and 8
+limitMax2D(v1, 3);     // Limits magnitude to maximum of 3
+limitMin2D(v1, 6);     // Ensures magnitude is at least 6
+
+// Rotation & reflection
+rotate2D(v1, Math.PI / 2);  // [-4, 3] - Rotate 90°
+reflect2D(v1, v2);          // Reflection
+
+// Angles
+angleBetween2D(v1, v2);  // Angle between vectors in radians
+angleX2D(v1);            // Angle with x-axis
+```
+
+### Homogeneous Coordinates (4D)
+
+```typescript
+// 3D point: w = 1
+const point: ArrayVector4D = [x, y, z, 1];
+
+// 3D direction: w = 0
+const direction: ArrayVector4D = [dx, dy, dz, 0];
+```
+
+## 🔄 Migration from OOP to Functional
+
+Migrating from the OOP API to the functional API is straightforward:
+
+| OOP (Vec2) | Functional (2D) |
+|-----------|-----------------|
+| `new Vec2(x, y)` | `[x, y]` as `ArrayVector2D` |
+| `Vec2.add(v1, v2)` | `add2D(v1, v2)` |
+| `v1.add(v2)` | `add2D(v1, v2)` |
+| `v.x` | `v[0]` |
+| `v.y` | `v[1]` |
+| `v.magnitude` | `magnitude2D(v)` |
+| `v.normalize()` | `normalize2D(v)` |
+
+**Key differences:**
+- Functional API is **immutable** - returns new arrays instead of mutating
+- Uses **array indexing** `[0], [1]` instead of properties `.x, .y`
+- Functions are **standalone** instead of class methods
+
+## 📦 Import Paths
+
+```typescript
+// Functional API (Recommended)
+import { add2D } from "@fimbul-works/vec/2d";
+import { add3D } from "@fimbul-works/vec/3d";
+import { add4D } from "@fimbul-works/vec/4d";
+
+// OOP API (Legacy)
+import { Vec2 } from "@fimbul-works/vec/vec2";
+import { Vec3 } from "@fimbul-works/vec/vec3";
+import { Vec4 } from "@fimbul-works/vec/vec4";
+
+// Types
+import type { ArrayVector2D } from "@fimbul-works/vec/2d";
+import type { ArrayVector3D } from "@fimbul-works/vec/3d";
+import type { ArrayVector4D } from "@fimbul-works/vec/4d";
+```
+
+## 📄 License
+
+MIT License - See [LICENSE](LICENSE) file for details.
+
+---
+
+Built with ⚡ by [FimbulWorks](https://github.com/fimbul-works)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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