@fimbul-works/vec 1.1.0 → 2.0.0

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

@@ -0,0 +1,13 @@
+/**
+ * Performs linear interpolation between two 4D vectors.
+ * @param {ArrayVector4D} xyzw1 - First vector as `[x, y, z, w]`
+ * @param {ArrayVector4D} xyzw2 - Second vector as `[x, y, z, w]`
+ * @param {number} t - Interpolation parameter
+ * @returns {ArrayVector4D} The interpolated vector
+ */
+export const lerp4D = (xyzw1, xyzw2, t) => [
+    xyzw1[0] + (xyzw2[0] - xyzw1[0]) * t,
+    xyzw1[1] + (xyzw2[1] - xyzw1[1]) * t,
+    xyzw1[2] + (xyzw2[2] - xyzw1[2]) * t,
+    xyzw1[3] + (xyzw2[3] - xyzw1[3]) * t,
+];

package/dist/esm/4d/limit-max-4d.d.ts

@@ -0,0 +1,9 @@
+import type { ArrayVector4D } from "./types.js";
+/**
+ * Limits the maximum magnitude of a 4D vector.
+ * @param {ArrayVector4D} xyzw - Vector as `[x, y, z, w]`
+ * @param {number} max - Maximum magnitude
+ * @param {number} [m] - Optional current magnitude (default: `magnitude4D(xyzw)`)
+ * @returns {ArrayVector4D} Vector with limited magnitude
+ */
+export declare const limitMax4D: (xyzw: ArrayVector4D, max: number, m?: number) => ArrayVector4D;

package/dist/esm/4d/limit-max-4d.js

@@ -0,0 +1,9 @@
+import { magnitude4D } from "./magnitude-4d.js";
+/**
+ * Limits the maximum magnitude of a 4D vector.
+ * @param {ArrayVector4D} xyzw - Vector as `[x, y, z, w]`
+ * @param {number} max - Maximum magnitude
+ * @param {number} [m] - Optional current magnitude (default: `magnitude4D(xyzw)`)
+ * @returns {ArrayVector4D} Vector with limited magnitude
+ */
+export const limitMax4D = (xyzw, max, m = magnitude4D(xyzw)) => m > max ? [(xyzw[0] / m) * max, (xyzw[1] / m) * max, (xyzw[2] / m) * max, (xyzw[3] / m) * max] : xyzw;

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

@@ -0,0 +1,9 @@
+import type { ArrayVector4D } from "./types.js";
+/**
+ * Limits the minimum magnitude of a 4D vector.
+ * @param {ArrayVector4D} xyzw - Vector as `[x, y, z, w]`
+ * @param {number} min - Minimum magnitude
+ * @param {number} [m] - Optional current magnitude (default: `magnitude4D(xyzw)`)
+ * @returns {ArrayVector4D} Vector with limited magnitude
+ */
+export declare const limitMin4D: (xyzw: ArrayVector4D, min: number, m?: number) => ArrayVector4D;

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

@@ -0,0 +1,9 @@
+import { magnitude4D } from "./magnitude-4d.js";
+/**
+ * Limits the minimum magnitude of a 4D vector.
+ * @param {ArrayVector4D} xyzw - Vector as `[x, y, z, w]`
+ * @param {number} min - Minimum magnitude
+ * @param {number} [m] - Optional current magnitude (default: `magnitude4D(xyzw)`)
+ * @returns {ArrayVector4D} Vector with limited magnitude
+ */
+export const limitMin4D = (xyzw, min, m = magnitude4D(xyzw)) => m < min ? [(xyzw[0] / m) * min, (xyzw[1] / m) * min, (xyzw[2] / m) * min, (xyzw[3] / m) * min] : xyzw;

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

@@ -0,0 +1,10 @@
+import type { ArrayVector4D } from "./types.js";
+/**
+ * Makes a 4D vector point towards another vector.
+ * @param {ArrayVector4D} xyzw1 - First vector as `[x, y, z, w]`
+ * @param {ArrayVector4D} xyzw2 - Second vector as `[x, y, z, w]` (target to look at)
+ * @param {number} [m1] - Optional current magnitude of the first vector (default: `magnitude4D(xyzw1)`)
+ * @param {number} [m2] - Optional current magnitude of the second vector (default: `magnitude4D(xyzw2)`)
+ * @returns {number} Vector pointing at the target with the magnitude of xyzw1
+ */
+export declare const lookAt4D: (xyzw1: ArrayVector4D, xyzw2: ArrayVector4D, m1?: number, m2?: number) => ArrayVector4D;

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

@@ -0,0 +1,10 @@
+import { magnitude4D } from "./magnitude-4d.js";
+/**
+ * Makes a 4D vector point towards another vector.
+ * @param {ArrayVector4D} xyzw1 - First vector as `[x, y, z, w]`
+ * @param {ArrayVector4D} xyzw2 - Second vector as `[x, y, z, w]` (target to look at)
+ * @param {number} [m1] - Optional current magnitude of the first vector (default: `magnitude4D(xyzw1)`)
+ * @param {number} [m2] - Optional current magnitude of the second vector (default: `magnitude4D(xyzw2)`)
+ * @returns {number} Vector pointing at the target with the magnitude of xyzw1
+ */
+export const lookAt4D = (xyzw1, xyzw2, m1 = magnitude4D(xyzw1), m2 = magnitude4D(xyzw2)) => [(xyzw2[0] / m2) * m1, (xyzw2[1] / m2) * m1, (xyzw2[2] / m2) * m1, (xyzw2[3] / m2) * m1];

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

@@ -0,0 +1,7 @@
+import type { ArrayVector4D } from "./types.js";
+/**
+ * Calculates the magnitude (length) of a 4D vector.
+ * @param {ArrayVector4D} xyzw - Vector as `[x, y, z, w]`
+ * @returns {number} The magnitude
+ */
+export declare const magnitude4D: (xyzw: ArrayVector4D) => number;

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

@@ -0,0 +1,6 @@
+/**
+ * Calculates the magnitude (length) of a 4D vector.
+ * @param {ArrayVector4D} xyzw - Vector as `[x, y, z, w]`
+ * @returns {number} The magnitude
+ */
+export const magnitude4D = (xyzw) => Math.sqrt(xyzw[0] ** 2 + xyzw[1] ** 2 + xyzw[2] ** 2 + xyzw[3] ** 2);

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

@@ -0,0 +1,8 @@
+import type { ArrayVector4D } from "./types.js";
+/**
+ * Calculates the squared magnitude of a 4D vector.
+ * Faster than magnitude for comparisons.
+ * @param {ArrayVector4D} xyzw - Vector as `[x, y, z, w]`
+ * @returns {number} The squared magnitude
+ */
+export declare const magnitudeSq4D: (xyzw: ArrayVector4D) => number;

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

@@ -0,0 +1,7 @@
+/**
+ * Calculates the squared magnitude of a 4D vector.
+ * Faster than magnitude for comparisons.
+ * @param {ArrayVector4D} xyzw - Vector as `[x, y, z, w]`
+ * @returns {number} The squared magnitude
+ */
+export const magnitudeSq4D = (xyzw) => xyzw[0] ** 2 + xyzw[1] ** 2 + xyzw[2] ** 2 + xyzw[3] ** 2;

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

@@ -0,0 +1,8 @@
+import type { ArrayVector4D } from "./types.js";
+/**
+ * Multiplies two 4D vectors component-wise.
+ * @param {ArrayVector4D} xyzw1 - First vector as `[x, y, z, w]`
+ * @param {ArrayVector4D} xyzw2 - Second vector as `[x, y, z, w]`
+ * @returns {ArrayVector4D} The multiplied vector
+ */
+export declare const multiply4D: (xyzw1: ArrayVector4D, xyzw2: ArrayVector4D) => ArrayVector4D;

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

@@ -0,0 +1,12 @@
+/**
+ * Multiplies two 4D vectors component-wise.
+ * @param {ArrayVector4D} xyzw1 - First vector as `[x, y, z, w]`
+ * @param {ArrayVector4D} xyzw2 - Second vector as `[x, y, z, w]`
+ * @returns {ArrayVector4D} The multiplied vector
+ */
+export const multiply4D = (xyzw1, xyzw2) => [
+    xyzw1[0] * xyzw2[0],
+    xyzw1[1] * xyzw2[1],
+    xyzw1[2] * xyzw2[2],
+    xyzw1[3] * xyzw2[3],
+];

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

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

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

@@ -0,0 +1,6 @@
+/**
+ * Negates a 4D vector.
+ * @param {ArrayVector4D} xyzw - Vector as `[x, y, z, w]`
+ * @returns {ArrayVector4D} The negated vector
+ */
+export const negate4D = (xyzw) => [-xyzw[0], -xyzw[1], -xyzw[2], -xyzw[3]];

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

@@ -0,0 +1,8 @@
+import type { ArrayVector4D } from "./types.js";
+/**
+ * Normalizes a 4D vector to unit length.
+ * @param {ArrayVector4D} xyzw - Vector as `[x, y, z, w]`
+ * @param {number} [m] - Optional current magnitude (default: `magnitude4D(xyzw)`)
+ * @returns {ArrayVector4D} The normalized vector
+ */
+export declare const normalize4D: (xyzw: ArrayVector4D, m?: number) => ArrayVector4D;

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

@@ -0,0 +1,13 @@
+import { magnitude4D } from "./magnitude-4d.js";
+/**
+ * Normalizes a 4D vector to unit length.
+ * @param {ArrayVector4D} xyzw - Vector as `[x, y, z, w]`
+ * @param {number} [m] - Optional current magnitude (default: `magnitude4D(xyzw)`)
+ * @returns {ArrayVector4D} The normalized vector
+ */
+export const normalize4D = (xyzw, m = magnitude4D(xyzw)) => [
+    xyzw[0] / m,
+    xyzw[1] / m,
+    xyzw[2] / m,
+    xyzw[3] / m,
+];

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

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

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

@@ -0,0 +1,5 @@
+/**
+ * Creates a 4D vector with all components set to 1.
+ * @returns {ArrayVector4D} A vector `[1, 1, 1, 1]`
+ */
+export const one4D = () => [1, 1, 1, 1];

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

@@ -0,0 +1,10 @@
+import type { ArrayVector4D } from "./types.js";
+/**
+ * Projects one 4D vector onto another.
+ * @param {ArrayVector4D} xyzw1 - First vector as `[x, y, z, w]`
+ * @param {ArrayVector4D} xyzw2 - Second vector as `[x, y, z, w]` to project onto
+ * @param {number} [m1] - Optional current magnitude (default: `magnitude4D(xyzw1)`)
+ * @param {number} [m2] - Optional current magnitude (default: `magnitude4D(xyzw2)`)
+ * @returns {ArrayVector4D} The projected vector
+ */
+export declare const project4D: (xyzw1: ArrayVector4D, xyzw2: ArrayVector4D, m1?: number, m2?: number) => ArrayVector4D;

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

@@ -0,0 +1,14 @@
+import { dot4D } from "./dot-4d.js";
+import { magnitude4D } from "./magnitude-4d.js";
+/**
+ * Projects one 4D vector onto another.
+ * @param {ArrayVector4D} xyzw1 - First vector as `[x, y, z, w]`
+ * @param {ArrayVector4D} xyzw2 - Second vector as `[x, y, z, w]` to project onto
+ * @param {number} [m1] - Optional current magnitude (default: `magnitude4D(xyzw1)`)
+ * @param {number} [m2] - Optional current magnitude (default: `magnitude4D(xyzw2)`)
+ * @returns {ArrayVector4D} The projected vector
+ */
+export const project4D = (xyzw1, xyzw2, m1 = magnitude4D(xyzw1), m2 = magnitude4D(xyzw2)) => {
+    const f = m1 * Math.cos(Math.acos(dot4D(xyzw1, xyzw2) / (m1 * m2)));
+    return [(xyzw2[0] / m2) * f, (xyzw2[1] / m2) * f, (xyzw2[2] / m2) * f, (xyzw2[3] / m2) * f];
+};

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

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

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

@@ -0,0 +1,17 @@
+const { sqrt, log, sin, cos, PI } = Math;
+/**
+ * Creates a random unit 4D vector.
+ * @param {() => number} random - A function that returns a random number between 0 and 1 (default: `Math.random`)
+ * @returns {ArrayVector4D} A random unit vector
+ */
+export const random4D = (random = Math.random) => {
+    // 1. Generate four numbers from a Normal Distribution (Box-Muller transform)
+    const x = sqrt(-2 * log(random())) * cos(2 * PI * random());
+    const y = sqrt(-2 * log(random())) * sin(2 * PI * random());
+    const z = sqrt(-2 * log(random())) * cos(2 * PI * random());
+    const w = sqrt(-2 * log(random())) * sin(2 * PI * random());
+    // 2. Calculate the current length
+    const length = sqrt(x * x + y * y + z * z + w * w);
+    // 3. Divide by length to make it a unit vector
+    return [x / length, y / length, z / length, w / length];
+};

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

@@ -0,0 +1,9 @@
+import type { ArrayVector4D } from "./types.js";
+/**
+ * Reflects a 4D vector across a normal vector.
+ * The normal vector should be normalized (unit length).
+ * @param {ArrayVector4D} xyzw - Vector as `[x, y, z, w]`
+ * @param {ArrayVector4D} normal - Normal vector (must be normalized)
+ * @returns {ArrayVector4D} The reflected vector
+ */
+export declare const reflect4D: (xyzw: ArrayVector4D, normal: ArrayVector4D) => ArrayVector4D;

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

@@ -0,0 +1,17 @@
+import { dot4D } from "./dot-4d.js";
+/**
+ * Reflects a 4D vector across a normal vector.
+ * The normal vector should be normalized (unit length).
+ * @param {ArrayVector4D} xyzw - Vector as `[x, y, z, w]`
+ * @param {ArrayVector4D} normal - Normal vector (must be normalized)
+ * @returns {ArrayVector4D} The reflected vector
+ */
+export const reflect4D = (xyzw, normal) => {
+    const dot = dot4D(xyzw, normal);
+    return [
+        xyzw[0] - 2 * dot * normal[0],
+        xyzw[1] - 2 * dot * normal[1],
+        xyzw[2] - 2 * dot * normal[2],
+        xyzw[3] - 2 * dot * normal[3],
+    ];
+};

package/dist/esm/4d/set-magnitude-4d.d.ts

@@ -0,0 +1,9 @@
+import type { ArrayVector4D } from "./types.js";
+/**
+ * Sets the magnitude of a 4D vector while maintaining its direction.
+ * @param {ArrayVector4D} xyzw - Vector as `[x, y, z, w]`
+ * @param {number} newMag - The new magnitude
+ * @param {number} [m] - Optional current magnitude (default: `magnitude4D(xyzw)`)
+ * @returns {ArrayVector4D} Vector with the new magnitude
+ */
+export declare const setMagnitude4D: (xyzw: ArrayVector4D, newMag: number, m?: number) => ArrayVector4D;

package/dist/esm/4d/set-magnitude-4d.js

@@ -0,0 +1,14 @@
+import { magnitude4D } from "./magnitude-4d.js";
+/**
+ * Sets the magnitude of a 4D vector while maintaining its direction.
+ * @param {ArrayVector4D} xyzw - Vector as `[x, y, z, w]`
+ * @param {number} newMag - The new magnitude
+ * @param {number} [m] - Optional current magnitude (default: `magnitude4D(xyzw)`)
+ * @returns {ArrayVector4D} Vector with the new magnitude
+ */
+export const setMagnitude4D = (xyzw, newMag, m = magnitude4D(xyzw)) => [
+    (xyzw[0] / m) * newMag,
+    (xyzw[1] / m) * newMag,
+    (xyzw[2] / m) * newMag,
+    (xyzw[3] / m) * newMag,
+];

package/dist/esm/4d/subtract-4d.d.ts

@@ -0,0 +1,8 @@
+import type { ArrayVector4D } from "./types.js";
+/**
+ * Subtracts two 4D vectors.
+ * @param {ArrayVector4D} xyzw1 - First vector as `[x, y, z, w]`
+ * @param {ArrayVector4D} xyzw2 - Second vector as `[x, y, z, w]`
+ * @returns {ArrayVector4D} The difference of the vectors
+ */
+export declare const subtract4D: (xyzw1: ArrayVector4D, xyzw2: ArrayVector4D) => ArrayVector4D;

package/dist/esm/4d/subtract-4d.js

@@ -0,0 +1,12 @@
+/**
+ * Subtracts two 4D vectors.
+ * @param {ArrayVector4D} xyzw1 - First vector as `[x, y, z, w]`
+ * @param {ArrayVector4D} xyzw2 - Second vector as `[x, y, z, w]`
+ * @returns {ArrayVector4D} The difference of the vectors
+ */
+export const subtract4D = (xyzw1, xyzw2) => [
+    xyzw1[0] - xyzw2[0],
+    xyzw1[1] - xyzw2[1],
+    xyzw1[2] - xyzw2[2],
+    xyzw1[3] - xyzw2[3],
+];

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

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

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

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

package/dist/esm/4d/zero-4d.d.ts

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

package/dist/esm/4d/zero-4d.js

@@ -0,0 +1,5 @@
+/**
+ * Creates a zero 4D vector.
+ * @returns {ArrayVector4D} A zero vector `[0, 0, 0, 0]`
+ */
+export const zero4D = () => [0, 0, 0, 0];

package/dist/esm/index.d.ts

@@ -1,3 +1,7 @@
+export * from "./2d/index.js";
+export * from "./3d/index.js";
+export * from "./4d/index.js";
+export * from "./slerp.js";
 export * from "./vec2.js";
 export * from "./vec3.js";
 export * from "./vec4.js";

package/dist/esm/index.js

@@ -1,3 +1,7 @@
+export * from "./2d/index.js";
+export * from "./3d/index.js";
+export * from "./4d/index.js";
+export * from "./slerp.js";
 export * from "./vec2.js";
 export * from "./vec3.js";
 export * from "./vec4.js";

package/dist/esm/slerp.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Documentation for spherical linear interpolation functions.
+ * @module Slerp
+ */
+/**
+ * Spherical linear interpolation for angles (in radians).
+ * Handles wrapping around 2π correctly.
+ * @param {number} from - Start angle in radians
+ * @param {number} to - End angle in radians
+ * @param {number} t - Interpolation factor (0-1)
+ * @returns {number} Interpolated angle
+ */
+export declare const slerp: (from: number, to: number, t: number) => number;
+/**
+ * Spherical linear interpolation for angles (in degrees).
+ * @param {number} from - Start angle in degrees
+ * @param {number} to - End angle in degrees
+ * @param {number} t - Interpolation factor (0-1)
+ * @returns {number} Interpolated angle
+ */
+export declare const slerpDegrees: (from: number, to: number, t: number) => number;

package/dist/esm/slerp.js

@@ -0,0 +1,23 @@
+/**
+ * Documentation for spherical linear interpolation functions.
+ * @module Slerp
+ */
+const PI2 = 2 * Math.PI;
+const PI3 = 3 * Math.PI;
+/**
+ * Spherical linear interpolation for angles (in radians).
+ * Handles wrapping around 2π correctly.
+ * @param {number} from - Start angle in radians
+ * @param {number} to - End angle in radians
+ * @param {number} t - Interpolation factor (0-1)
+ * @returns {number} Interpolated angle
+ */
+export const slerp = (from, to, t) => from + (((((to - from) % PI2) + PI3) % PI2) - Math.PI) * t;
+/**
+ * Spherical linear interpolation for angles (in degrees).
+ * @param {number} from - Start angle in degrees
+ * @param {number} to - End angle in degrees
+ * @param {number} t - Interpolation factor (0-1)
+ * @returns {number} Interpolated angle
+ */
+export const slerpDegrees = (from, to, t) => from + (((((to - from) % 360) + 540) % 360) - 180) * t;

package/dist/esm/vec2.d.ts

@@ -1,3 +1,7 @@
+/**
+ * Documentation for 2D Vector class.
+ * @module Vec2
+ */
 /**
  * Represents a 2D vector with various operations.
  */
@@ -5,8 +9,8 @@ export declare class Vec2 {
     #private;
     /**
      * Creates a new Vec2 instance.
-     * @param x - The x-coordinate of the vector.
-     * @param y - The y-coordinate of the vector.
+     * @param {number} x - The x-coordinate of the vector.
+     * @param {number} y - The y-coordinate of the vector.
      */
     constructor(x?: number, y?: number);
     /**
@@ -218,12 +222,14 @@ export declare class Vec2 {
     static one(): Vec2;
     /**
      * Creates a Vec2 from an array.
-     * @returns A new Vec2 instance.
+     * @param {[number, number] | number[]} arr - An array containing the x and y coordinates.
+     * @returns {Vec2} A new Vec2 instance.
      */
     static fromArray(arr: [number, number] | number[]): Vec2;
     /**
      * Creates a Vec2 from an object with x and y properties.
-     * @returns A new Vec2 instance.
+     * @param {{ x: number; y: number }} obj - An object with x and y properties.
+     * @returns {Vec2} A new Vec2 instance.
      */
     static fromObject(obj: {
         x: number;

package/dist/esm/vec2.js

@@ -1,3 +1,7 @@
+/**
+ * Documentation for 2D Vector class.
+ * @module Vec2
+ */
 const { PI, sin, cos, atan2, sqrt, abs } = Math;
 const PI2 = PI * 2;
 /**
@@ -10,8 +14,9 @@ export class Vec2 {
     /**
      * Computes and updates the magnitude of the vector.
      * @private
-     * @param x - The x-component of the vector.
-     * @param y - The y-component of the vector.
+     * @param {number} x - The x-component of the vector.
+     * @param {number} y - The y-component of the vector.
+     * @returns {void}
      */
     #computeMagnitude(x = this.#xy[0], y = this.#xy[1]) {
         if (x !== this.#prevXY[0] || y !== this.#prevXY[1]) {
@@ -22,8 +27,8 @@ export class Vec2 {
     }
     /**
      * Creates a new Vec2 instance.
-     * @param x - The x-coordinate of the vector.
-     * @param y - The y-coordinate of the vector.
+     * @param {number} x - The x-coordinate of the vector.
+     * @param {number} y - The y-coordinate of the vector.
      */
     constructor(x = 0, y = x) {
         this.#xy[0] = x;
@@ -358,14 +363,16 @@ export class Vec2 {
     }
     /**
      * Creates a Vec2 from an array.
-     * @returns A new Vec2 instance.
+     * @param {[number, number] | number[]} arr - An array containing the x and y coordinates.
+     * @returns {Vec2} A new Vec2 instance.
      */
     static fromArray(arr) {
         return new Vec2(arr[0] ?? 0, arr[1] ?? 0);
     }
     /**
      * Creates a Vec2 from an object with x and y properties.
-     * @returns A new Vec2 instance.
+     * @param {{ x: number; y: number }} obj - An object with x and y properties.
+     * @returns {Vec2} A new Vec2 instance.
      */
     static fromObject(obj) {
         return new Vec2(obj.x, obj.y);