@fimbul-works/vec 1.0.3 → 2.0.0

package/dist/{vec4.d.ts → esm/vec2.d.ts}

@@ -1,72 +1,74 @@
 /**
- * Represents a 4D vector with various operations.
+ * Documentation for 2D Vector class.
+ * @module Vec2
  */
-export declare class Vec4 {
+/**
+ * Represents a 2D vector with various operations.
+ */
+export declare class Vec2 {
     #private;
     /**
-     * Creates a new Vec4 instance.
-     * @param x - The x-coordinate of the vector.
-     * @param y - The y-coordinate of the vector.
-     * @param z - The z-coordinate of the vector.
-     * @param w - The w-coordinate of the vector.
+     * Creates a new Vec2 instance.
+     * @param {number} x - The x-coordinate of the vector.
+     * @param {number} y - The y-coordinate of the vector.
      */
-    constructor(x?: number, y?: number, z?: number, w?: number);
+    constructor(x?: number, y?: number);
     /**
      * Adds two vectors.
      * @param v - The first vector.
      * @param w - The second vector.
-     * @returns A new Vec3 instance representing the sum.
+     * @returns A new Vec2 instance representing the sum.
      */
-    static add(v: Vec4, w: Vec4): Vec4;
+    static add(v: Vec2, w: Vec2): Vec2;
     /**
      * Subtracts one vector from another.
      * @param v - The vector to subtract from.
      * @param w - The vector to subtract.
      * @returns A new Vec2 instance representing the difference.
      */
-    static subtract(v: Vec4, w: Vec4): Vec4;
+    static subtract(v: Vec2, w: Vec2): Vec2;
     /**
      * Multiplies one vector with another.
      * @param v - The first vector.
      * @param w - The second vector.
-     * @returns A new Vec4 instance representing the multiplied value.
+     * @returns A new Vec2 instance representing the multiplied value.
      */
-    static multiply(v: Vec4, w: Vec4): Vec4;
+    static multiply(v: Vec2, w: Vec2): Vec2;
     /**
      * Divides one vector with another.
      * @param v - Divident.
      * @param w - Divisor.
-     * @returns A new Vec4 instance representing the divided value.
+     * @returns A new Vec2 instance representing the divided value.
      */
-    static divide(v: Vec4, w: Vec4): Vec4;
+    static divide(v: Vec2, w: Vec2): Vec2;
     /**
      * Calculates the angle between two vectors.
      * @param v - The first vector.
      * @param w - The second vector.
      * @returns The angle between the vectors in radians.
      */
-    static angleBetween(v: Vec4, w: Vec4): number;
+    static angleBetween(v: Vec2, w: Vec2): number;
     /**
      * Calculates the Euclidean distance between two vectors.
      * @param v - The first vector.
      * @param w - The second vector.
      * @returns The distance between the vectors.
      */
-    static distance(v: Vec4, w: Vec4): number;
+    static distance(v: Vec2, w: Vec2): number;
     /**
      * Calculates the Chebyshev distance between two vectors.
      * @param v - The first vector.
      * @param w - The second vector.
      * @returns The Chebyshev distance between the vectors.
      */
-    static distanceChebyshev(v: Vec4, w: Vec4): number;
+    static distanceChebyshev(v: Vec2, w: Vec2): number;
     /**
      * Calculates the Manhattan distance between two vectors.
      * @param v - The first vector.
      * @param w - The second vector.
      * @returns The Manhattan distance between the vectors.
      */
-    static distanceManhattan(v: Vec4, w: Vec4): number;
+    static distanceManhattan(v: Vec2, w: Vec2): number;
     /**
      * Calculates the Minkowski distance between two vectors.
      * @param v - The first vector.
@@ -74,69 +76,78 @@ export declare class Vec4 {
      * @param p - The order of the Minkowski distance.
      * @returns The Minkowski distance between the vectors.
      */
-    static distanceMinkowski(v: Vec4, w: Vec4, p: number): number;
+    static distanceMinkowski(v: Vec2, w: Vec2, p: number): number;
     /**
      * Calculates the squared Euclidean distance between two vectors.
      * @param v - The first vector.
      * @param w - The second vector.
      * @returns The squared distance between the vectors.
      */
-    static distanceSq(v: Vec4, w: Vec4): number;
+    static distanceSq(v: Vec2, w: Vec2): number;
     /**
      * Calculates the dot product of two vectors.
      * @param v - The first vector.
      * @param w - The second vector.
-     * @returns The dot product of the two vectors.
+     * @returns The dot product of the vectors.
+     */
+    static dot(v: Vec2, w: Vec2): number;
+    /**
+     * Calculates the cross product of two vectors.
+     * @param v - The first vector.
+     * @param w - The second vector.
+     * @returns The cross product scalar value.
      */
-    static dot(v: Vec4, w: Vec4): number;
+    static cross(v: Vec2, w: Vec2): number;
     /**
-     * Reflects a vector across a normal vector.
-     * The normal vector should be normalized (unit length).
+     * Reflects the vector across a normal vector.
      * @param v - The vector to reflect.
      * @param normal - The normal vector to reflect across (must be normalized).
-     * @returns A new Vec4 instance representing the reflected vector.
+     * @returns A new Vec2 instance representing the reflected vector.
+     */
+    static reflect(v: Vec2, normal: Vec2): Vec2;
+    /**
+     * Creates a Vec2 instance from polar coordinates.
+     * @param r - The radius.
+     * @param theta - The angle in radians.
+     * @returns A new Vec2 instance.
      */
-    static reflect(v: Vec4, normal: Vec4): Vec4;
+    static fromPolarCoords(r: number, theta: number): Vec2;
     /**
-     * Creates an immutable Vec4-like object.
+     * Creates an immutable Vec2-like object.
      * @param x - The x-coordinate of the vector.
      * @param y - The y-coordinate of the vector.
-     * @returns An immutable object with Vec4-like properties.
-     */
-    static immutable(x?: number, y?: number, z?: number, w?: number): {
-        readonly x: number;
-        readonly y: number;
-        readonly z: number;
-        readonly w: number;
-        readonly xyzw: readonly number[];
-        readonly magnitude: number;
-        readonly magnitudeSq: number;
-        readonly angleW: number;
-        readonly angleX: number;
-        readonly angleY: number;
-        readonly angleZ: number;
-        readonly isInfinite: boolean;
-        readonly isNaN: boolean;
-        readonly isZero: boolean;
-    };
+     * @returns An immutable object with Vec2-like properties.
+     */
+    static immutable(x?: number, y?: number): Readonly<{
+        angleX: number;
+        angleY: number;
+        isInfinite: boolean;
+        isNaN: boolean;
+        isZero: boolean;
+        magnitude: number;
+        magnitudeSq: number;
+        x: number;
+        xy: readonly number[];
+        y: number;
+    }>;
     /**
      * Checks if a vector has infinite components.
      * @param v - The vector to check.
      * @returns True if the vector has infinite components, false otherwise.
      */
-    static isInfinite(v: Vec4): boolean;
+    static isInfinite(v: Vec2): boolean;
     /**
      * Checks if a vector has NaN components.
      * @param v - The vector to check.
      * @returns True if the vector has NaN components, false otherwise.
      */
-    static isNaN(v: Vec4): boolean;
+    static isNaN(v: Vec2): boolean;
     /**
      * Checks if a vector is zero.
      * @param v - The vector to check.
      * @returns True if the vector is zero, false otherwise.
      */
-    static isZero(v: Vec4): boolean;
+    static isZero(v: Vec2): boolean;
     /**
      * Performs linear interpolation between two vectors.
      * @param v - The first vector.
@@ -144,46 +155,46 @@ export declare class Vec4 {
      * @param t - The interpolation parameter (0 to 1).
      * @returns A new Vec2 instance representing the interpolated vector.
      */
-    static lerp(v: Vec4, w: Vec4, t: number): Vec4;
+    static lerp(v: Vec2, w: Vec2, t: number): Vec2;
     /**
      * Negates a vector.
      * @param v - The vector to negate.
      * @returns A new Vec2 instance representing the negated vector.
      */
-    static negate(v: Vec4): Vec4;
+    static negate(v: Vec2): Vec2;
     /**
      * Normalizes a vector.
      * @param v - The vector to normalize.
      * @returns A new Vec2 instance representing the normalized vector.
      */
-    static normalize(v: Vec4): Vec4;
+    static normalize(v: Vec2): Vec2;
     /**
      * Projects one vector onto another.
      * @param v - The vector to project.
      * @param w - The vector to project onto.
      * @returns A new Vec2 instance representing the projected vector.
      */
-    static project(v: Vec4, w: Vec4): Vec4;
+    static project(v: Vec2, w: Vec2): Vec2;
     /**
      * Creates a random unit vector.
      * @param random - A function that returns a random number between 0 and 1.
-     * @returns A new Vec4 instance representing a random unit vector.
+     * @returns A new Vec2 instance representing a random unit vector.
      */
-    static random(random?: () => number): Vec4;
+    static random(random?: () => number): Vec2;
     /**
      * Checks if two vectors are equal.
      * @param v - The first vector.
      * @param w - The second vector.
      * @returns True if the vectors are equal, false otherwise.
      */
-    static satisfyEquality(v: Vec4, w: Vec4): boolean;
+    static satisfyEquality(v: Vec2, w: Vec2): boolean;
     /**
      * Checks if two vectors are opposite.
      * @param v - The first vector.
      * @param w - The second vector.
      * @returns True if the vectors are opposite, false otherwise.
      */
-    static satisfyOpposition(v: Vec4, w: Vec4): boolean;
+    static satisfyOpposition(v: Vec2, w: Vec2): boolean;
     /**
      * Compares a vector with another vector using an epsilon value for floating-point comparison.
      * @param v - The first vector.
@@ -191,50 +202,48 @@ export declare class Vec4 {
      * @param epsilon - The maximum difference between components to consider them equal.
      * @returns True if the vectors are equal within epsilon, false otherwise.
      */
-    static equals(v: Vec4, w: Vec4, epsilon?: number): boolean;
+    static equals(v: Vec2, w: Vec2, epsilon?: number): boolean;
     /**
      * Scales a vector by a scalar value.
      * @param v - The vector to scale.
      * @param c - The scalar value.
      * @returns A new Vec2 instance representing the scaled vector.
      */
-    static scale(v: Vec4, c: number): Vec4;
+    static scale(v: Vec2, c: number): Vec2;
     /**
      * Creates a zero vector.
-     * @returns A new Vec4 instance representing a zero vector.
+     * @returns A new Vec2 instance representing a zero vector.
      */
-    static zero(): Vec4;
+    static zero(): Vec2;
     /**
      * Creates a vector with all components set to 1.0.
-     * @returns A new Vec4 instance representing a vector with all components set to 1.0.
+     * @returns A new Vec2 instance representing a vector with all components set to 1.0.
      */
-    static one(): Vec4;
+    static one(): Vec2;
     /**
-     * Creates a Vec4 from an array.
-     * @returns A new Vec4 instance.
+     * Creates a Vec2 from an array.
+     * @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, number] | number[]): Vec4;
+    static fromArray(arr: [number, number] | number[]): Vec2;
     /**
-     * Creates a Vec4 from an object with x, y, z and w properties.
-     * @returns A new Vec4 instance.
+     * Creates a Vec2 from an object with x and y properties.
+     * @param {{ x: number; y: number }} obj - An object with x and y properties.
+     * @returns {Vec2} A new Vec2 instance.
      */
     static fromObject(obj: {
         x: number;
         y: number;
-        z: number;
-        w: number;
-    }): Vec4;
+    }): Vec2;
     /**
-     * Creates a Vec3 instance from a JSON-parsed object.
+     * Creates a Vec2 instance from a JSON-parsed object.
      * @param json - The JSON-parsed object containing x and y properties.
-     * @returns A new Vec4 instance.
+     * @returns A new Vec2 instance.
      */
     static fromJSON(json: {
         x: number;
         y: number;
-        z: number;
-        w: number;
-    }): Vec4;
+    }): Vec2;
     /**
      * Gets the x-component of the vector.
      * @returns The x-component.
@@ -251,168 +260,153 @@ export declare class Vec4 {
      */
     get y(): number;
     /**
-     * Sets the z-component of the vector.
-     * @param y - The new z-component.
+     * Sets the y-component of the vector.
+     * @param y - The new y-component.
      */
     set y(y: number);
-    /**
-     * Gets the z-component of the vector.
-     * @returns The z-component.
-     */
-    get z(): number;
-    /**
-     * Sets the z-component of the vector.
-     * @param z - The new z-component.
-     */
-    set z(z: number);
-    /**
-     * Gets the w-component of the vector.
-     * @returns The w-component.
-     */
-    get w(): number;
-    /**
-     * Sets the w-component of the vector.
-     * @param w - The new w-component.
-     */
-    set w(w: number);
     /**
      * Gets a copy of the vector's components as an array.
-     * @returns An array containing the x, y, z and w components of the vector.
+     * @returns An array containing the x and y components of the vector.
      */
-    get xyzw(): [number, number, number, number];
+    get xy(): [number, number];
     /**
      * Sets both components of the vector at once.
-     * @param xyzw - An array containing the new x, y and z components.
+     * @param xy - An array containing the new x and y components.
      */
-    set xyzw(xyzw: [number, number, number, number] | number[]);
+    set xy(xy: [number, number] | number[]);
     /**
      * Gets the angle between the vector and the positive x-axis in radians.
      * @returns The angle in radians, always in the range [0, 2π).
      */
     get angleX(): number;
+    /**
+     * Sets the angle between the vector and the positive x-axis, maintaining the vector's magnitude.
+     * @param phi - The new angle in radians.
+     */
+    set angleX(phi: number);
     /**
      * Gets the angle between the vector and the positive y-axis in radians.
      * @returns The angle in radians, always in the range [0, 2π).
      */
     get angleY(): number;
     /**
-     * Gets the angle between the vector and the positive z-axis in radians.
-     * @returns The angle in radians, always in the range [0, 2π).
+     * Sets the angle between the vector and the positive y-axis, maintaining the vector's magnitude.
+     * @param phi - The new angle in radians.
      */
-    get angleZ(): number;
+    set angleY(phi: number);
     /**
-     * Gets the angle between the vector and the positive w-axis in radians.
-     * @returns The angle in radians, always in the range [0, 2π).
+     * Gets the magnitude (length) of the vector.
+     * @returns The magnitude of the vector.
      */
-    get angleW(): number;
+    get magnitude(): number;
     /**
      * Sets the magnitude (length) of the vector, maintaining its direction.
      * @param m - The new magnitude.
      */
-    get magnitude(): number;
+    set magnitude(m: number);
     /**
      * Gets the squared magnitude of the vector.
      * This is faster to compute than the actual magnitude and is useful for comparisons.
      * @returns The squared magnitude of the vector.
      */
     get magnitudeSq(): number;
-    /**
-     * Sets the magnitude (length) of the vector, maintaining its direction.
-     * @param m - The new magnitude.
-     */
-    set magnitude(m: number);
     /**
      * Adds another vector to this vector.
      * @param v - The vector to add.
-     * @returns This Vec4 instance for method chaining.
+     * @returns This Vec2 instance for method chaining.
      */
-    add(v: Vec4): this;
+    add(v: Vec2): this;
     /**
      * Subtracts another vector from this vector.
      * @param v - The vector to subtract.
-     * @returns This Vec4 instance for method chaining.
+     * @returns This Vec2 instance for method chaining.
      */
-    subtract(v: Vec4): this;
+    subtract(v: Vec2): this;
     /**
      * Multiplies this vector with another vector.
      * @param v - The vector to multiply with.
-     * @returns This Vec4 instance for method chaining.
+     * @returns This Vec2 instance for method chaining.
      */
-    multiply(v: Vec4): this;
+    multiply(v: Vec2): this;
     /**
      * Divides this vector with another vector.
      * @param v - The vector to divide with.
-     * @returns This Vec4 instance for method chaining.
+     * @returns This Vec2 instance for method chaining.
      */
-    divide(v: Vec4): this;
+    divide(v: Vec2): this;
     /**
      * Calculates the angle between this vector and another vector.
      * @param v - The other vector.
      * @returns The angle between the vectors in radians.
      */
-    angleBetween(v: Vec4): number;
+    angleBetween(v: Vec2): number;
     /**
      * Clamps the magnitude of this vector between a minimum and maximum value.
      * @param min - The minimum magnitude.
      * @param max - The maximum magnitude.
-     * @returns This Vec4 instance for method chaining.
+     * @returns This Vec2 instance for method chaining.
      */
     clamp(min: number, max: number): this;
     /**
      * Creates a copy of this vector.
-     * @returns A new Vec4 instance with the same components.
+     * @returns A new Vec2 instance with the same components.
      */
-    clone(): Vec4;
+    clone(): Vec2;
     /**
      * Copies the components of another vector to this vector.
      * @param v - The vector to copy from.
      * @returns This Vec2 instance for method chaining.
      */
-    copy(v: Vec4): this;
+    copy(v: Vec2): this;
     /**
      * Calculates the distance between this vector and another vector.
      * @param v - The other vector.
      * @returns The distance between the vectors.
      */
-    distance(v: Vec4): number;
+    distance(v: Vec2): number;
     /**
      * Calculates the Chebyshev distance between this vector and another vector.
-     * @param v - The first vector.
+     * @param v - The other vector.
      * @returns The Chebyshev distance between the vectors.
      */
-    distanceChebyshev(v: Vec4): number;
+    distanceChebyshev(v: Vec2): number;
     /**
      * Calculates the Manhattan distance between this vector and another vector.
      * @param v - The other vector.
      * @returns The Manhattan distance between the vectors.
      */
-    distanceManhattan(v: Vec4): number;
+    distanceManhattan(v: Vec2): number;
     /**
-     * Calculates the Minkowski distance between  thisvector and another vector.
+     * Calculates the Minkowski distance between this vector and another vector.
      * @param v - The other vector.
      * @param p - The order of the Minkowski distance.
      * @returns The Minkowski distance between the vectors.
      */
-    distanceMinkowski(v: Vec4, p: number): number;
+    distanceMinkowski(v: Vec2, p: number): number;
     /**
      * Calculates the squared distance between this vector and another vector.
      * @param v - The other vector.
      * @returns The squared distance between the vectors.
      */
-    distanceSq(v: Vec4): number;
+    distanceSq(v: Vec2): number;
     /**
      * Calculates the dot product of this vector with another vector.
      * @param v - The other vector.
      * @returns The dot product of the vectors.
      */
-    dot(v: Vec4): number;
+    dot(v: Vec2): number;
+    /**
+     * Calculates the cross product of this vector with another vector.
+     * @param v - The other vector.
+     * @returns The cross product of the vectors.
+     */
+    cross(v: Vec2): number;
     /**
      * Reflects this vector across a normal vector.
-     * The normal vector should be normalized (unit length).
      * @param normal - The normal vector to reflect across (must be normalized).
-     * @returns This Vec4 instance for method chaining.
+     * @returns A new Vec2 instance representing the reflected vector.
      */
-    reflect(normal: Vec4): this;
+    reflect(normal: Vec2): Vec2;
     /**
      * Checks if this vector has infinite components.
      * @returns True if the vector has infinite components, false otherwise.
@@ -437,86 +431,100 @@ export declare class Vec4 {
     /**
      * Limits the minimum magnitude of this vector.
      * @param min - The minimum magnitude.
-     * @returns This Vec4 instance for method chaining.
+     * @returns This Vec2 instance for method chaining.
      */
     limitMin(min: number): this;
     /**
      * Sets this vector to point towards another vector.
      * @param v - The vector to look at.
-     * @returns This Vec4 instance for method chaining.
+     * @returns This Vec2 instance for method chaining.
      */
-    lookAt(v: Vec4): this;
+    lookAt(v: Vec2): this;
     /**
      * Negates this vector.
-     * @returns This Vec4 instance for method chaining.
+     * @returns This Vec2 instance for method chaining.
      */
     negate(): this;
     /**
      * Normalizes this vector.
-     * @returns This Ve4 instance for method chaining.
+     * @returns This Vec2 instance for method chaining.
      */
     normalize(): this;
     /**
      * Projects this vector onto another vector.
      * @param v - The vector to project onto.
-     * @returns This Vec4 instance for method chaining.
+     * @returns This Vec2 instance for method chaining.
      */
-    project(v: Vec4): this;
+    project(v: Vec2): this;
     /**
      * Sets this vector to a random direction with the same magnitude.
      * @param random - A function that returns a random number between 0 and 1.
-     * @returns This Vec4 instance for method chaining.
+     * @returns This Vec2 instance for method chaining.
      */
     random(random?: () => number): this;
+    /**
+     * Rotates this vector around the Z-axis.
+     * @param phi - The angle of rotation in radians.
+     * @returns This Vec2 instance for method chaining.
+     */
+    rotateZ(phi: number): this;
     /**
      * Checks if this vector is equal to another vector.
      * @param v - The other vector.
      * @returns True if the vectors are equal, false otherwise.
      */
-    satisfyEquality(v: Vec4): boolean;
+    satisfyEquality(v: Vec2): boolean;
     /**
      * Checks if this vector is opposite to another vector.
      * @param v - The other vector.
      * @returns True if the vectors are opposite, false otherwise.
      */
-    satisfyOpposition(v: Vec4): boolean;
+    satisfyOpposition(v: Vec2): boolean;
     /**
      * Compares this vector with another vector using an epsilon value for floating-point comparison.
      * @param v - The vector to compare with.
      * @param epsilon - The maximum difference between components to consider them equal.
      * @returns True if the vectors are equal within epsilon, false otherwise.
      */
-    equals(v: Vec4, epsilon?: number): boolean;
+    equals(v: Vec2, epsilon?: number): boolean;
     /**
      * Scales this vector by a scalar value.
      * @param c - The scalar value.
-     * @returns This Vec4 instance for method chaining.
+     * @returns This Vec2 instance for method chaining.
      */
     scale(c: number): this;
+    /**
+     * Rotates this vector 90 degrees to the left.
+     * @returns This Vec2 instance for method chaining.
+     */
+    turnLeft(): this;
+    /**
+     * Rotates this vector 90 degrees to the right.
+     * @returns This Vec2 instance for method chaining.
+     */
+    turnRight(): this;
     /**
      * Sets this vector to zero.
-     * @returns This Vec4 instance for method chaining.
+     * @returns This Vec2 instance for method chaining.
      */
     zero(): this;
     /**
-     * Makes the Vec4 instance iterable.
-     * @yields The x, y, z and w components of the vector.
+     * Makes the Vec2 instance iterable.
+     * @yields The x and y components of the vector.
      */
     [Symbol.iterator](): IterableIterator<number>;
     /**
      * Returns a string representation of the vector.
-     * @returns A string in the format "Vec4(x, y, z, w)".
+     * @returns A string in the format "Vec2(x, y)".
      */
     toString(): string;
     /**
      * Converts the vector to a plain object.
-     * @returns An object with x, y, z and w properties.
+     * @returns An object with x and y properties.
      */
     toObject(): {
         x: number;
         y: number;
-        z: number;
-        w: number;
     };
     /**
      * Serializes the vector to a JSON-friendly format.