mathue 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,2189 @@
+export declare interface AdditiveGroup<T> {
+    add(other: T): T;
+    subtract(other: T): T;
+}
+
+export declare interface Clonable<T> {
+    clone(): T;
+}
+
+export declare interface Matrix<Order extends MatrixOrder> {
+    readonly order: Order;
+    readonly elements: Float32Array;
+}
+
+/**
+ * 3x3 matrix class. It looks column-major order. And post multiplied.
+ */
+export declare class Matrix3 implements Matrix<3>, AdditiveGroup<Matrix3>, PartialMultiplicativeGroup<Matrix3>, Scalable<Matrix3>, Clonable<Matrix3> {
+    /**
+     * @example
+     * ```ts
+     * const m = Matrix3.identity();
+     * console.log(m.order); // 3
+     * ```
+     */
+    readonly order = 3;
+    /**
+     * @example
+     * ```ts
+     * const m = Matrix3.identity();
+     * console.log(m.elements);
+     * // [ 1, 0, 0,
+     * //   0, 1, 0,
+     * //   0, 0, 1 ]
+     * ```
+     */
+    readonly elements: Float32Array;
+    private static _tmpMatrix?;
+    private static get tmpMatrix();
+    private static _tmpVector?;
+    private static get tmpVector();
+    /**
+     * Creates a new 3x3 matrix with the specified elements. \
+     * The internal data is stored in **column-major** order in a `Float32Array`.
+     *
+     * The parameters `e(column)(row)` correspond to this following matrix positions: \
+     * ```
+     * | e00 e10 e20 |
+     * | e01 e11 e21 |
+     * | e02 e12 e22 |
+     * ```
+     *
+     * The `elements` array stores each column sequentialy: \
+     * `[e00, e01, e02, e10, e11, e12, e20, e21, e22]`
+     *
+     * @param e00 element in column 0, row 0
+     * @param e01 element in column 0, row 1
+     * @param e02 element in column 0, row 2
+     * @param e10 element in column 1, row 0
+     * @param e11 element in column 1, row 1
+     * @param e12 element in column 1, row 2
+     * @param e20 element in column 2, row 0
+     * @param e21 element in column 2, row 1
+     * @param e22 element in column 2, row 2
+     *
+     * @example
+     * ```ts
+     * const m = new Matrix3(0, 1, 2, 3, 4, 5, 6, 7, 8);
+     * console.log(m.elements);
+     * // [ 0, 1, 2, 3, 4, 5, 6, 7, 8 ]
+     * ```
+     */
+    constructor(e00: number, e01: number, e02: number, e10: number, e11: number, e12: number, e20: number, e21: number, e22: number);
+    /**
+     * Creates a identity matrix instance
+     * @returns new identity matrix instance
+     * @group Factory Methods
+     *
+     * @example
+     * ```ts
+     * const m = Matrix3.identity();
+     * console.log(m.elements);
+     * // [ 1, 0, 0,
+     * //   0, 1, 0,
+     * //   0, 0, 1 ]
+     * ```
+     */
+    static identity(): Matrix3;
+    /**
+     * Creates a new zero matrix instance
+     * @returns new zero matrix instance
+     * @group Factory Methods
+     *
+     * @example
+     * ```ts
+     * const m = Matrix3.zero();
+     * console.log(m.elements);
+     * // [ 0, 0, 0,
+     * //   0, 0, 0,
+     * //   0, 0, 0 ]
+     * ```
+     */
+    static zero(): Matrix3;
+    /**
+     * Creates new instance has same elements (pure)
+     * @returns new cloned matrix instance
+     *
+     * @example
+     * ```ts
+     * const m = Matrix3.identity();
+     * const c = m.clone();
+     * console.log(c.elements);
+     * // [ 1, 0, 0,
+     * //   0, 1, 0,
+     * //   0, 0, 1 ]
+     * ```
+     */
+    clone(): Matrix3;
+    /**
+     * Sets all elements (mutates this)
+     * @param e00 element in column 0, row 0
+     * @param e01 element in column 0, row 1
+     * @param e02 element in column 0, row 2
+     * @param e10 element in column 1, row 0
+     * @param e11 element in column 1, row 1
+     * @param e12 element in column 1, row 2
+     * @param e20 element in column 2, row 0
+     * @param e21 element in column 2, row 1
+     * @param e22 element in column 2, row 2
+     * @returns this instance, for method chaining
+     *
+     * @example
+     * const m = Matrix3.zero();
+     * m.set(0, 1, 2, 3, 4, 5, 6, 7, 8);
+     * console.log(m.elements);
+     * // [ 0, 1, 2,
+     * //   3, 4, 5,
+     * //   6, 7, 8 ]
+     */
+    set(e00: number, e01: number, e02: number, e10: number, e11: number, e12: number, e20: number, e21: number, e22: number): Matrix3;
+    /**
+     * Copies all elements from other matrix (mutates this)
+     * @param other other matrix
+     * @returns this instance, for method chaining
+     *
+     * @example
+     * ```ts
+     * const m = Matrix3.zero();
+     * const i = Matrix3.identity();
+     * m.set(i);
+     * console.log(m.elements);
+     * // [ 1, 0, 0,
+     * //   0, 1, 0,
+     * //   0, 0, 1 ]
+     * ```
+     */
+    copy(other: Matrix3): void;
+    /**
+     * Sets identity matrix (mutates this)
+     * @returns this instance, for method chaining
+     *
+     * @example
+     * ```ts
+     * const m = Matrix4.zero();
+     * m.setIdentity();
+     * console.log(m.elements);
+     * // [ 1, 0, 0,
+     * //   0, 1, 0,
+     * //   0, 0, 1 ]
+     * ```
+     */
+    setIdentity(): Matrix3;
+    /**
+     * Adds by other matrix (mutates this)
+     * @param other other matrix
+     * @returns this instance, for method chaining
+     *
+     * @example
+     * ```ts
+     * const m1 = Matrix3.zero();
+     * const m2 = Matrix3.identity();
+     * m1.add(m2);
+     * console.log(m1.elements);
+     * // [ 1, 0, 0,
+     * //   0, 1, 0,
+     * //   0, 0, 1 ]
+     * ```
+     */
+    add(other: Matrix3): Matrix3;
+    /**
+     * Subtracts by other matrix (mutates this)
+     * @param other other matrix
+     * @returns this instance, for method chaining
+     *
+     * @example
+     * ```ts
+     * const m1 = Matrix3.zero();
+     * const m2 = Matrix3.identity();
+     * m1.subtract(m2);
+     * console.log(m1.lements);
+     * // [ -1,  0,  0,
+     * //    0, -1,  0,
+     * //    0,  0, -1 ]
+     * ```
+     */
+    subtract(other: Matrix3): Matrix3;
+    /**
+     * Multiplies all elements by scalar (mutates this)
+     * @param scalar
+     * @returns this instance, for method chaining
+     *
+     * @example
+     * ```ts
+     * const m = Matrix3.identity();
+     * m.multiplyScalar(2);
+     * console.log(m.elements);
+     * // [ 2, 0, 0,
+     * //   0, 2, 0,
+     * //   0, 0, 2 ]
+     * ```
+     */
+    multiplyScalar(scalar: number): Matrix3;
+    /**
+     * Divides all elements by scalar (mutates this)
+     * @param scalar
+     * @returns this instance, for method chaining
+     *
+     * @example
+     * ```ts
+     * const m = Matrix3.identity();
+     * m.divideScalar(2);
+     * console.log(m.elements);
+     * // [ 0.5,   0,   0,
+     * //     0, 0.5,   0,
+     * //     0,   0, 0.5 ]
+     * ```
+     */
+    divideScalar(scalar: number): Matrix3;
+    /**
+     * Multiplies this matrix by other matrix (mutates this)
+     * @param other other matrix
+     * @returns this instance, for method chaining
+     *
+     * @example
+     * ```ts
+     * const m1 = Matrix3.identity();
+     * const m2 = Matrix3.zero();
+     * m1.multiply(m2);
+     * console.log(m.elements);
+     * // [ 0, 0, 0,
+     * //   0, 0, 0,
+     * //   0, 0, 0 ]
+     * ```
+     */
+    multiply(other: Matrix3): Matrix3;
+    /**
+     * Calculates determinant of this matrix (pure)
+     * @returns determinant of this matrix
+     */
+    determinant(): number;
+    /**
+     * Sets inverse of this matrix to this instance (mutates this)
+     * @returns `this` instance for method chaining if this is invertible, `null` otherwise
+     */
+    invert(): Matrix3 | null;
+    /**
+     * Transposes this matrix (mutates this)
+     * @returns this instance, for method chaining
+     */
+    transpose(): Matrix3;
+    /**
+     * Divides by other matrix (mutates this)
+     * @param other other matrix
+     * @returns `this` instance for method chaining if other is invertible, `null` otherwise
+     */
+    divide(other: Matrix3): Matrix3 | null;
+    /** @ignore */
+    _applyVector(x: number, y: number, z: number): Vector3;
+}
+
+/**
+ * 4x4 matrix class. It looks column-major order. And post multiplied.
+ */
+export declare class Matrix4 implements Matrix<4>, AdditiveGroup<Matrix4>, PartialMultiplicativeGroup<Matrix4>, Scalable<Matrix4>, Clonable<Matrix4> {
+    /**
+     * @example
+     * ```ts
+     * const m = Matrix4.identity();
+     * console.log(m.order); // 4
+     * ```
+     */
+    readonly order = 4;
+    /**
+     * @example
+     * ```ts
+     * const m = Matrix4.identity();
+     * console.log(m.elements);
+     * // [ 1, 0, 0, 0,
+     * //   0, 1, 0, 0,
+     * //   0, 0, 1, 0,
+     * //   0, 0, 0, 1 ]
+     * ```
+     */
+    readonly elements: Float32Array;
+    private static _tmpMatrix?;
+    private static get tmpMatrix();
+    private static _tmpVector?;
+    private static get tmpVector();
+    /**
+     * Creates a new 4x4 matrix with the specified elements. \
+     * The internal data is stored in **column-major** order in a `Float32Array`.
+     *
+     * The parameters `e(column)(row)` correspond to the following matrix positions: \
+     * ```
+     * | e00 e10 e20 e30 |
+     * | e01 e11 e21 e31 |
+     * | e02 e12 e22 e32 |
+     * | e03 e13 e23 e33 |
+     * ```
+     *
+     * The `elements` array stores each column sequentialy: \
+     * `[e00, e01, e02, e03, e10, e11, e12, e13, e20, e21, e22, e23, e30, e31, e32, e33]`
+     *
+     * @param e00 element in column 0, row 0
+     * @param e01 element in column 0, row 1
+     * @param e02 element in column 0, row 2
+     * @param e03 element in column 0, row 3
+     * @param e10 element in column 1, row 0
+     * @param e11 element in column 1, row 1
+     * @param e12 element in column 1, row 2
+     * @param e13 element in column 1, row 3
+     * @param e20 element in column 2, row 0
+     * @param e21 element in column 2, row 1
+     * @param e22 element in column 2, row 2
+     * @param e23 element in column 2, row 3
+     * @param e30 element in column 3, row 0
+     * @param e31 element in column 3, row 1
+     * @param e32 element in column 3, row 2
+     * @param e33 element in column 3, row 3
+     *
+     * @example
+     * ```ts
+     * const m = new Matrix4(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
+     * console.log(m.elements);
+     * // [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 ]
+     * ```
+     */
+    constructor(e00: number, e01: number, e02: number, e03: number, e10: number, e11: number, e12: number, e13: number, e20: number, e21: number, e22: number, e23: number, e30: number, e31: number, e32: number, e33: number);
+    /**
+     * Creates a identity matrix instance
+     * @returns new identity matrix instance
+     * @group Factory Methods
+     *
+     * @example
+     * ```ts
+     * const m = Matrix4.identity();
+     * console.log(m.elements);
+     * // [ 1, 0, 0, 0,
+     * //   0, 1, 0, 0,
+     * //   0, 0, 1, 0,
+     * //   0, 0, 0, 1 ]
+     * ```
+     */
+    static identity(): Matrix4;
+    /**
+     * Creates a new zero matrix instance
+     * @returns new zero matrix instance
+     * @group Factory Methods
+     *
+     * @example
+     * ```ts
+     * const m = Matrix4.zero();
+     * console.log(m.elements);
+     * // [ 1, 0, 0, 0,
+     * //   0, 1, 0, 0,
+     * //   0, 0, 1, 0,
+     * //   0, 0, 0, 1 ]
+     * ```
+     */
+    static zero(): Matrix4;
+    /**
+     * Creates new instance has same elements (pure)
+     * @returns new cloned matrix instance
+     *
+     * @example
+     * ```ts
+     * const m = Matrix4.identity();
+     * const c = m.clone();
+     * console.log(c.elements);
+     * // [ 1, 0, 0, 0,
+     * //   0, 1, 0, 0,
+     * //   0, 0, 1, 0,
+     * //   0, 0, 0, 1 ]
+     * ```
+     */
+    clone(): Matrix4;
+    /**
+     * Sets all elements (mutates this)
+     * @param e00 element in column 0, row 0
+     * @param e01 element in column 0, row 1
+     * @param e02 element in column 0, row 2
+     * @param e03 element in column 0, row 3
+     * @param e10 element in column 1, row 0
+     * @param e11 element in column 1, row 1
+     * @param e12 element in column 1, row 2
+     * @param e13 element in column 1, row 3
+     * @param e20 element in column 2, row 0
+     * @param e21 element in column 2, row 1
+     * @param e22 element in column 2, row 2
+     * @param e23 element in column 2, row 3
+     * @param e30 element in column 3, row 0
+     * @param e31 element in column 3, row 1
+     * @param e32 element in column 3, row 2
+     * @param e33 element in column 3, row 3
+     * @returns this instance, for method chaining
+     *
+     * @example
+     * const m = Matrix4.zero();
+     * m.set(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1);
+     * console.log(m.elements);
+     * // [ 1, 0, 0, 0,
+     * //   0, 1, 0, 0,
+     * //   0, 0, 1, 0,
+     * //   0, 0, 0, 1 ]
+     */
+    set(e00: number, e01: number, e02: number, e03: number, e10: number, e11: number, e12: number, e13: number, e20: number, e21: number, e22: number, e23: number, e30: number, e31: number, e32: number, e33: number): Matrix4;
+    /**
+     * Copies all elements from other matrix (mutates this)
+     * @param other other matrix
+     * @returns this instance, for method chaining
+     *
+     * @example
+     * ```ts
+     * const m = Matrix4.zero();
+     * const i = Matrix4.identity();
+     * m.set(i);
+     * console.log(m.elements);
+     * // [ 1, 0, 0, 0,
+     * //   0, 1, 0, 0,
+     * //   0, 0, 1, 0,
+     * //   0, 0, 0, 1 ]
+     * ```
+     */
+    copy(other: Matrix4): void;
+    /**
+     * Sets identity matrix (mutates this)
+     * @returns this instance, for method chaining
+     *
+     * @example
+     * ```ts
+     * const m = Matrix4.zero();
+     * m.setIdentity();
+     * console.log(m.elements);
+     * // [ 1, 0, 0, 0,
+     * //   0, 1, 0, 0,
+     * //   0, 0, 1, 0,
+     * //   0, 0, 0, 1 ]
+     * ```
+     */
+    setIdentity(): Matrix4;
+    /**
+     * Sets rotation matrix from quaternion  (mutates this)
+     * @param quaternion
+     * @returns this instance, for method chaining
+     *
+     * @example
+     * ```ts
+     * const m = Matrix4.zero();
+     * const q = Quaternion.identity();
+     * m.setQuaternion(q);
+     * console.log(m.elements);
+     * // [ 0, 0, 0, 0,
+     * //   0, 0, 0, 0,
+     * //   0, 0, 0, 0,
+     * //   0, 0, 0, 0 ]
+     * ```
+     */
+    setQuaternion(quaternion: Quaternion): Matrix4;
+    /**
+     * Adds by other matrix (mutates this)
+     * @param other other matrix
+     * @returns this instance, for method chaining
+     *
+     * @example
+     * ```ts
+     * const m1 = Matrix4.zero();
+     * const m2 = Matrix4.identity();
+     * m1.add(m2);
+     * console.log(m1.elements);
+     * // [ 1, 0, 0, 0,
+     * //   0, 1, 0, 0,
+     * //   0, 0, 1, 0,
+     * //   0, 0, 0, 1 ]
+     * ```
+     */
+    add(other: Matrix4): Matrix4;
+    /**
+     * Subtracts by other matrix (mutates this)
+     * @param other other matrix
+     * @returns this instance, for method chaining
+     *
+     * @example
+     * ```ts
+     * const m1 = Matrix4.zero();
+     * const m2 = Matrix4.identity();
+     * m1.subtract(m2);
+     * console.log(m1.lements);
+     * // [ -1,  0,  0,  0,
+     * //    0, -1,  0,  0,
+     * //    0,  0, -1,  0,
+     * //    0,  0,  0, -1 ]
+     * ```
+     */
+    subtract(other: Matrix4): Matrix4;
+    /**
+     * Multiplies all elements by scalar (mutates this)
+     * @param scalar
+     * @returns this instance, for method chaining
+     *
+     * @example
+     * ```ts
+     * const m = Matrix4.identity();
+     * m.multiplyScalar(2);
+     * console.log(m.elements);
+     * // [ 2, 0, 0, 0,
+     * //   0, 2, 0, 0,
+     * //   0, 0, 2, 0,
+     * //   0, 0, 0, 2 ]
+     * ```
+     */
+    multiplyScalar(scalar: number): Matrix4;
+    /**
+     * Divides all elements by scalar (mutates this)
+     * @param scalar
+     * @returns this instance, for method chaining
+     *
+     * @example
+     * ```ts
+     * const m = Matrix4.identity();
+     * m.divideScalar(2);
+     * console.log(m.elements);
+     * // [ 0.5,   0,   0,   0,
+     * //     0, 0.5,   0,   0,
+     * //     0,   0, 0.5,   0,
+     * //     0,   0,   0, 0.5 ]
+     * ```
+     */
+    divideScalar(scalar: number): Matrix4;
+    /**
+     * Multiplies this matrix by other matrix (mutates this)
+     * @param other other matrix
+     * @returns this instance, for method chaining
+     *
+     * @example
+     * ```ts
+     * const m1 = Matrix4.identity();
+     * const m2 = Matrix4.zero();
+     * m1.multiply(m2);
+     * console.log(m.elements);
+     * // [ 0, 0, 0, 0,
+     * //   0, 0, 0, 0,
+     * //   0, 0, 0, 0,
+     * //   0, 0, 0, 0 ]
+     * ```
+     */
+    multiply(other: Matrix4): Matrix4;
+    /**
+     * Calculates determinant of this matrix (pure)
+     * @returns determinant of this matrix
+     */
+    determinant(): number;
+    /**
+     * Sets inverse of this matrix to this instance (mutates this)
+     * @returns `this` instance for method chaining if this is invertible, `null` otherwise
+     */
+    invert(): Matrix4 | null;
+    /**
+     * Transposes this matrix (mutates this)
+     * @returns this instance, for method chaining
+     */
+    transpose(): Matrix4;
+    /**
+     * Divides by other matrix (mutates this)
+     * @param other other matrix
+     * @returns `this` instance for method chaining if other is invertible, `null` otherwise
+     */
+    divide(other: Matrix4): Matrix4 | null;
+    /**
+     * Sets scale transformation matrix (mutates this)
+     * @param scale 3D scale vector
+     * @returns this instance, for method chaining
+     *
+     * @example
+     * ```ts
+     * const m = Matrix4.identity();
+     * const s = new Vector3(2, 3, 4);
+     * m.scale(s);
+     * console.log(m.elements);
+     * // [ 2, 0, 0, 0,
+     * //   0, 3, 0, 0,
+     * //   0, 0, 4, 0,
+     * //   0, 0, 0, 1 ]
+     * ```
+     */
+    scale(scale: Vector3): Matrix4;
+    /**
+     * Sets translation transformation matrix (mutates this)
+     * @param translation translation vector
+     * @returns this instance, for method chaining
+     *
+     * @example
+     * ```ts
+     * const m = Matrix4.identity();
+     * const t = new Vector3(2, 3, 4);
+     * m.translate(t);
+     * console.log(m.elements);
+     * // [ 1, 0, 0, 0,
+     * //   0, 1, 0, 0,
+     * //   0, 0, 1, 0,
+     * //   2, 3, 4, 1 ]
+     * ```
+     */
+    translate(translation: Vector3): Matrix4;
+    /**
+     * Sets view transformation matrix (mutates this)
+     * @param position camera position
+     * @param target camera target looking at
+     * @param up up vector of camera
+     * @returns this instance, for method chaining
+     *
+     * @example
+     * ```ts
+     * const m = Matrix4.identity();
+     * const p = new Vector3(0, -2, 0);
+     * const t = Vector3.zero();
+     * const u = new Vector3(0, 0, 1);
+     * m.lookAt(p, t, u);
+     * ```
+     */
+    lookAt(position: Vector3, target: Vector3, up: Vector3): Matrix4;
+    /**
+     * Sets projection matrix of perspective camera (mutates this)
+     * @param verticalFov vertical field of view in radians
+     * @param near near clipping plane distance
+     * @param far far clipping plane distance
+     * @param aspect aspect ratio (width / height)
+     * @returns this instance, for method chaining
+     *
+     * @example
+     * ```ts
+     * const m = Matrix4.identity();
+     * const fov = Math.PI / 4;
+     * const near = 0.01;
+     * const far = 4.0;
+     * const aspect = 300 / 150;
+     * m.perspective(fov, near, far, aspect);
+     * ```
+     */
+    perspective(verticalFov: number, near: number, far: number, aspect: number): Matrix4;
+    /** @ignore */
+    _applyVector(x: number, y: number, z: number, w: number): Vector4;
+}
+
+export declare type MatrixOrder = 3 | 4;
+
+/**
+ * Represents a multiplicative monoid.
+ *
+ * Types implementing this interface support:
+ * - Associativity: `(a * b) * c = a * (b * c)`
+ * - Closure: `a * b` produces another value of type `T`
+ */
+export declare interface MultiplicativeMonoid<T> {
+    multiply(other: T): T;
+}
+
+export declare interface Normalizable<T> {
+    length(): number;
+    normalize(): T;
+}
+
+/**
+ * Represents a partial multiplicative group where multiplication is defined for all elements, \
+ * but inverses exist only for certain elements (those that are invertible).
+ *
+ * ### Invertibility Conditions:
+ * | Type | Invertible when | Condition |
+ * |------|-----------------|-----------|
+ * | **Matrix** | `det(M) ≠ 0` | Non-singular (full rank) |
+ * | **Quaternion** | `\|q\| ≠ 0` (non-zero norm) | Non-zero quaternion |
+ */
+export declare interface PartialMultiplicativeGroup<T> extends MultiplicativeMonoid<T> {
+    invert(): T | null;
+    divide(other: T): T | null;
+}
+
+export declare class PolarCoordinate3 {
+    private _phi;
+    private _theta;
+    private _radius;
+    /**
+     * @param phi polar angle phi in range [0, π] in radians
+     * @param theta azimuthal angle theta in range [0, 2π] in radians
+     * @param radius radial distance from the origin, must be non-negative
+     */
+    constructor(phi: number, theta: number, radius: number);
+    /**
+     * Gets polar angle phi in range [0, π] in radians, measured from positive z-axis.
+     */
+    get phi(): number;
+    /**
+     * Sets polar angle phi in range [0, π] in radians, measured from positive z-axis.
+     * @param value polar angle in range [0, π]
+     */
+    set phi(value: number);
+    /**
+     * Gets azimuthal angle theta in range [0, 2π] in radians, measured from the positive x-axis.
+     */
+    get theta(): number;
+    /**
+     * Sets azimuthal angle theta in range [0, 2π] in radians, measured from the positive x-axis.
+     * @param value azimuthal angle in range [0, 2π]
+     */
+    set theta(value: number);
+    /**
+     * Gets radial distance from the origin, must be non-negative.
+     */
+    get radius(): number;
+    /**
+     * Sets radial distance from the origin, must be non-negative.
+     */
+    set radius(value: number);
+    /**
+     * Converts polar coordinate to Vector3 and stores result in `out` vector.
+     * @param out vector instance to receive result
+     * @returns {void}
+     */
+    toVector3(out: Vector3): void;
+    /**
+     * Converts to tangent vector pointing positive z-axis direction, and sotres result in `out` vector.
+     * @param out vector instance to receive result
+     * @returns {void}
+     */
+    toTangentZ(out: Vector3): void;
+}
+
+/**
+ * Represents a quaternion using Hamilton's notation: q = a + bi + cj + dk
+ */
+export declare class Quaternion implements AdditiveGroup<Quaternion>, PartialMultiplicativeGroup<Quaternion>, Scalable<Quaternion>, Clonable<Quaternion> {
+    private _a;
+    private _b;
+    private _c;
+    private _d;
+    private static temporary;
+    /**
+     * Constructor of quaternion: q = a + bi + cj + dk
+     * @param a the first real component
+     * @param b the i-coefficient
+     * @param c the j-coefficient
+     * @param d the k-coefficient
+     *
+     * @example
+     * ```ts
+     * const q = new Quaternion(1, 0, 0, 0);
+     * ```
+     */
+    constructor(a: number, b: number, c: number, d: number);
+    /**
+     * Gets the first real component of this quaternion
+     * @readonly
+     *
+     * @example
+     * ```ts
+     * const q = new Quaternion(1, 2, 3, 4);
+     * console.log(q.a); // 1
+     * ```
+     */
+    get a(): number;
+    /**
+     * Gets the i-coefficient of this quaternion
+     * @readonly
+     *
+     * @example
+     * ```ts
+     * const q = new Quaternion(1, 2, 3, 4);
+     * console.log(q.b); // 2
+     * ```
+     */
+    get b(): number;
+    /**
+     * Gets the j-coefficient of this quaternion
+     * @readonly
+     *
+     * @example
+     * ```ts
+     * const q = new Quaternion(1, 2, 3, 4);
+     * console.log(q.c); // 3
+     * ```
+     */
+    get c(): number;
+    /**
+     * Gets the k-coefficient of this quaternion
+     * @readonly
+     *
+     * @example
+     * ```ts
+     * const q = new Quaternion(1, 2, 3, 4);
+     * console.log(q.d); // 4
+     * ```
+     */
+    get d(): number;
+    /**
+     * @returns new identity quaternion instance
+     *
+     * @group Factory Methods
+     *
+     * @example
+     * ```ts
+     * const q = Quaternion.identity();
+     * console.log(q); // (1, 0, 0, 0)
+     * ```
+     */
+    static identity(): Quaternion;
+    /**
+     * @param axis the rotation axis
+     * @param angle the rotation angle in radians
+     * @returns new normalized quaternion instance from axis and radian
+     *
+     * @group Factory Methods
+     *
+     * @example
+     * ```ts
+     * const axis = new Vector3(0, 1, 0);
+     * const radian = Math.PI / 3;
+     * const q = Quaternion.identity(axis, radian);
+     * ```
+     */
+    static fromAxisAndAngle(axis: Vector3, angle: number): Quaternion;
+    /**
+     * @returns new cloned quaternion instance
+     *
+     * @example
+     * ```ts
+     * const q = Quaternion.identity();
+     * const c = q.clone();
+     * console.log(c); // (1, 0, 0, 0)
+     * ```
+     */
+    clone(): Quaternion;
+    /**
+     * Sets all components of this quaternion: q = a + bi + cj + dk (mutates this)
+     * @param a the first real component
+     * @param b the i-coefficient
+     * @param c the j-coefficient
+     * @param d the k-coefficient
+     * @returns this instance, for method chaining
+     *
+     * @example
+     * ```ts
+     * const q = Quaternion.identity();
+     * console.log(q); // (1, 0, 0, 0)
+     * q.set(0, 0, 0, 1);
+     * console.log(q); // (0, 0, 0, 1)
+     * ```
+     */
+    set(a: number, b: number, c: number, d: number): Quaternion;
+    /**
+     * Sets this quaternion to other quaternion (mutates this)
+     * @param other the other quaternion
+     * @returns this instance, for method chaining
+     *
+     * @example
+     * ```ts
+     * const q1 = new Quaternion(1, 2, 3, 4);
+     * const q2 = new Quaternion(5, 6, 7, 8);
+     * q1.copy(q2);
+     * console.log(q1); // (5, 6, 7, 8)
+     * console.log(q2); // (5, 6, 7, 8)
+     * ```
+     */
+    copy(other: Quaternion): Quaternion;
+    /**
+     * Sets this instance to identity quaternion (mutates this)
+     * @returns this instance, for method chaining
+     *
+     * @example
+     * ```ts
+     * const q = new Quaternion(1, 2, 3, 4);
+     * q.setIdentity();
+     * console.log(q); // (1, 0, 0, 0)
+     * ```
+     */
+    setIdentity(): void;
+    /**
+     * Sets this quaternion from axis and radian (mutates this)
+     * @param axis the rotation axis
+     * @param angle the rotation angle in radians
+     * @returns this instance, for method chaining
+     *
+     * @example
+     * ```ts
+     * const q = Quaternion.identity();
+     * const axis = new Vector3(0, 1, 0);
+     * const radian = Math.PI / 3;
+     * q.setAxisAndAngle(axis, radian);
+     * ```
+     */
+    setAxisAndAngle(axis: Vector3, angle: number): void;
+    /**
+     * Calculates squared norm of this quaternion (pure)
+     * @returns squared norm of this quaternion
+     *
+     * @example
+     * ```ts
+     * const q = new Quaternion(1, 2, 2, 4);
+     * console.log(q.squaredNorm()); // 25
+     * ```
+     */
+    squaredNorm(): number;
+    /**
+     * Calculates norm of this quaternion (pure)
+     * @returns norm of this quaternion
+     *
+     * @example
+     * ```ts
+     * const q = new Quaternion(1, 2, 2, 4);
+     * console.log(q.norm()); // 5
+     * ```
+     */
+    norm(): number;
+    /**
+     * Calculates conjugate of this quaternion (mutates this)
+     * @returns this instance, for method chaining
+     *
+     * @example
+     * ```ts
+     * const q = new Quaternion(1, 2, 3, 4);
+     * q.conjugate();
+     * console.log(q); // (1, -2, -3, -4)
+     * ```
+     */
+    conjugate(): Quaternion;
+    /**
+     * Adds other quaternion to this instance (mutates this)
+     * @param other other quaternion
+     * @returns this instance, for method chaining
+     *
+     * @example
+     * ```ts
+     * const q1 = new Quaternion(1, 2, 3, 4);
+     * const q2 = new Quaternion(5, 6, 7, 8);
+     * q1.add(q2);
+     * console.log(q1); // (6, 8, 10, 12)
+     * console.log(q2); // (5, 6, 7, 8)
+     * ```
+     */
+    add(other: Quaternion): Quaternion;
+    /**
+     * Subtracts other quaternion from this instance (mutates this)
+     * @param other other quaternion
+     * @returns this instance, for method chaining
+     *
+     * @example
+     * ```ts
+     * const q1 = new Quaternion(5, 6, 7, 8);
+     * const q2 = new Quaternion(1, 2, 3, 4);
+     * q1.subtract(q2);
+     * console.log(q1); // (4, 4, 4, 4)
+     * console.log(q2); // (1, 2, 3, 4)
+     * ```
+     */
+    subtract(other: Quaternion): Quaternion;
+    /**
+     * Multiplies this instance by other quaternion (mutates this)
+     * @param other other quaternion
+     * @returns this instance, for method chaining
+     *
+     * @example
+     * ```ts
+     * const q1 = new Quaternion(1, 2, 3, 4);
+     * const q2 = new Quaternion(5, 6, 7, 8);
+     * q1.multiply(q2);
+     * console.log(q1); // (-60, 12, 30, 24)
+     * console.log(q2); // (5, 6, 7, 8)
+     * ```
+     */
+    multiply(other: Quaternion): Quaternion;
+    /**
+     * Calculates inverse of this quaternion (mutates this)
+     * @returns this instance, for method chaining
+     *
+     * @example
+     * ```ts
+     * const q = new Quaternion(1, 2, 3, 4);
+     * q.inverse();
+     * console.log(q); // (0.0333, -0.0667, -0.1, -0.1333)
+     * ```
+     */
+    invert(): Quaternion | null;
+    /**
+     * Divides this instance by other quaternion (mutates this)
+     * @param other other quaternion
+     * @returns this instance, for method chaining
+     *
+     * @example
+     * ```ts
+     * const q1 = new Quaternion(1, 2, 3, 4);
+     * const q2 = new Quaternion(5, 6, 7, 8);
+     * q1.divide(q2);
+     * console.log(q1); // (0.1333, 0.0667, 0.1, 0.1333)
+     * console.log(q2); // (5, 6, 7, 8)
+     * ```
+     */
+    divide(other: Quaternion): Quaternion | null;
+    /**
+     * Multiplies this quaternion by a scalar (mutates this)
+     * @param scalar scalar value
+     * @returns this instance, for method chaining
+     *
+     * @example
+     * ```ts
+     * const q = new Quaternion(1, 2, 3, 4);
+     * q.multiplyScalar(2);
+     * console.log(q); // (2, 4, 6, 8)
+     * ```
+     */
+    multiplyScalar(scalar: number): Quaternion;
+    /**
+     * Divides this quaternion by a scalar (mutates this)
+     * @param scalar scalar value
+     * @returns this instance, for method chaining
+     *
+     * @example
+     * ```ts
+     * const q = new Quaternion(2, 4, 6, 8);
+     * q.divideScalar(2);
+     * console.log(q); // (1, 2, 3, 4)
+     * ```
+     */
+    divideScalar(scalar: number): Quaternion;
+    /**
+     * Rotates this quaternion around X axis by given radian (mutates this)
+     * @param radian the rotation angle in radians
+     * @returns this instance, for method chaining
+     *
+     * @example
+     * ```ts
+     * const q = Quaternion.identity();
+     * q.rotateX(Math.PI / 2);
+     * console.log(q); // (0.7071, 0.7071, 0, 0)
+     * ```
+     */
+    rotateX(radian: number): Quaternion;
+    /**
+     * Rotates this quaternion around Y axis by given radian (mutates this)
+     * @param radian the rotation angle in radians
+     * @returns this instance, for method chaining
+     *
+     * @example
+     * ```ts
+     * const q = Quaternion.identity();
+     * q.rotateY(Math.PI / 2);
+     * console.log(q); // (0.7071, 0, 0.7071, 0)
+     * ```
+     */
+    rotateY(radian: number): Quaternion;
+    /**
+     * Rotates this quaternion around Z axis by given radian (mutates this)
+     * @param radian the rotation angle in radians
+     * @returns this instance, for method chaining
+     *
+     * @example
+     * ```ts
+     * const q = Quaternion.identity();
+     * q.rotateZ(Math.PI / 2);
+     * console.log(q); // (0.7071, 0, 0, 0.7071)
+     * ```
+     */
+    rotateZ(radian: number): Quaternion;
+}
+
+/**
+ * Creates a generator that yields numbers in a specified range
+ * @param stop exclusive bound (sequence stops before reaching this)
+ * @param options optional range configuration
+ * @returns generator yielding numbers from `start` to `stop` (exclusive)
+ *
+ * @example
+ * ```ts
+ * for (const i of range(5)) {
+ *   console.log(i);
+ * }
+ * // 0, 1, 2, 3, 4
+ *
+ * for (const i of range(10, { start: 2, step: 2 })) {
+ *   console.log(i);
+ * }
+ * // 2, 4, 6, 8
+ *
+ * for (const i of range(0, { start: 10, step: -3 })) {
+ *   console.log(n);
+ * }
+ * // 10, 7, 4, 1
+ * ```
+ */
+export declare function range(stop: number, options?: RangeOptions): Generator<number, void, unknown>;
+
+/**
+ * Options of range function
+ */
+export declare type RangeOptions = {
+    /** inclusive bound (default `0`) */
+    start?: number;
+    /** step size (default `1`, must be non-zero) */
+    step?: number;
+};
+
+export declare interface Scalable<T> {
+    multiplyScalar(scalar: number): T;
+    divideScalar(scalar: number): T;
+}
+
+/**
+ * Computes the sum of all values in an iterable of numbers
+ * @param values iterable containing numbers to sum
+ * @returns sum of all values (0 if empty)
+ *
+ * @example
+ * ```ts
+ * sum([1, 2, 3]); // 6 (1+2+3)
+ * ```
+ */
+export declare function sum(values: Iterable<number>): number;
+
+/**
+ * Computes the sum of mapped values from an iterable, where `null` values contribute `0`.
+ * @param values iterable of input values
+ * @param callback mapping function `(value: T) => number | null`
+ * @returns sum of non-null mapped values (0 if empty or all null)
+ *
+ * @example
+ * ```ts
+ * sumMap([1, 2, 3], x => x * x); // 14 (1+4+9)
+ *
+ * const objects = [{x: 1}, {x: 2}, {x: 3}];
+ * sumMap(objects, obj => obj.x ?? null); // 6 (1+2+3)
+ * ```
+ */
+export declare function sumMap<T>(values: Iterable<T>, callback: (value: T) => number | null): number;
+
+/**
+ * @example
+ * ```ts
+ * type NumberTuple2 = TupleOf<number, 2>; // [number, number]
+ * ```
+ */
+export declare type TupleOf<Ele, Len extends number, Tup extends Ele[] = []> = Tup['length'] extends Len ? Tup : TupleOf<Ele, Len, [...Tup, Ele]>;
+
+export declare interface Vector<D extends VectorDimension> {
+    readonly dimension: D;
+    readonly elements: TupleOf<number, D>;
+}
+
+export declare class Vector1 implements Vector<1>, AdditiveGroup<Vector1>, Scalable<Vector1>, Normalizable<Vector1>, Clonable<Vector1> {
+    /**
+     * @example
+     * ```ts
+     * const v = new Vector1(2);
+     * console.log(v.dimension); // 1
+     * ```
+     */
+    readonly dimension = 1;
+    /**
+     * @example
+     * ```ts
+     * const v = new Vector1(2);
+     * console.log(v.elements); // [1]
+     * ```
+     */
+    readonly elements: [number];
+    private static _tmpMatrix3?;
+    private static get tmpMatrix3();
+    private static _tmpMatrix4?;
+    private static get tmpMatrix4();
+    /**
+     * @example
+     * ```ts
+     * const v = new Vector1(2);
+     * ```
+     */
+    constructor(x: number);
+    /**
+     * @example
+     * ```ts
+     * const v = new Vector1(2);
+     * console.log(v.x); // 2
+     * ```
+     */
+    get x(): number;
+    /**
+     * @example
+     * ```ts
+     * const v = new Vector1(2);
+     * v.x = 3;
+     * console.log(v.x); // 3
+     * ```
+     */
+    set x(x: number);
+    /**
+     * Creates a zero vector instance
+     * @returns new zero vector instance
+     * @group Factory Methods
+     *
+     * @example
+     * ```ts
+     * const v = Vector1.zero();
+     * console.log(v.x); // 0
+     * ```
+     */
+    static zero(): Vector1;
+    /**
+     * Creates a all ones vector instance
+     * @returns new one vector instance
+     * @group Factory Methods
+     *
+     * @example
+     * ```ts
+     * const v = Vector1.one();
+     * console.log(v.x); // 1
+     * ```
+     */
+    static one(): Vector1;
+    /**
+     * Creates new instance has same element (pure)
+     * @returns new cloned vector instance
+     *
+     * @example
+     * ```ts
+     * const v = new Vector1(2);
+     * const c = v.clone();
+     * console.log(c.x); // 2
+     * ```
+     */
+    clone(): Vector1;
+    /**
+     * Determines if this vector is the zero vector
+     * @returns `true` if this vector is exactly zero, `false` otherwise
+     *
+     * @example
+     * ```ts
+     * const zero = Vector1.zero();
+     * const one = Vector1.one();
+     * console.log(zero.isZero()); // true
+     * console.log(one.isZero()); // false
+     * ```
+     */
+    isZero(): boolean;
+    /**
+     * Sets element value (mutates this)
+     * @param x element value
+     * @returns this instance, for method chaining
+     *
+     * @example
+     * ```ts
+     * const v = new Vector1(2);
+     * v.set(3);
+     * console.log(v.x); // 3
+     * ```
+     */
+    set(x: number): Vector1;
+    /**
+     * Copies element value from other vector (mutates this)
+     * @param other other vector
+     * @returns this instance, for method chaining
+     *
+     * @example
+     * ```ts
+     * const v1 = new Vector1(1);
+     * const v2 = new Vector1(2);
+     * v1.copy(v2);
+     * console.log(v1.x); // 2
+     * console.log(v2.x); // 2
+     * ```
+     */
+    copy(other: Vector1): Vector1;
+    /**
+     * Adds by other vector (mutates this)
+     * @param other other vector
+     * @returns this instance, for method chaining
+     *
+     * @example
+     * ```ts
+     * const v1 = new Vector1(2);
+     * const v2 = new Vector1(3);
+     * v1.add(v2);
+     * console.log(v1.x); // 5
+     * console.log(v2.x); // 3
+     * ```
+     */
+    add(other: Vector1): Vector1;
+    /**
+     * Subtracts by other vector (mutates this)
+     * @param other other vector
+     * @returns this instance, for method chaining
+     *
+     * @example
+     * ```ts
+     * const v1 = new Vector1(2);
+     * const v2 = new Vector1(3);
+     * v1.subtract(v2);
+     * console.log(v1.x); // -1
+     * console.log(v2.x); // 3
+     * ```
+     */
+    subtract(other: Vector1): Vector1;
+    /**
+     * Multiplies element by scalar (mutates this)
+     * @param scalar
+     * @returns this instance, for method chaining
+     *
+     * @example
+     * ```ts
+     * const v = new Vector1(2);
+     * v.multiplyScalar(3);
+     * console.log(v.x); // 6
+     * ```
+     */
+    multiplyScalar(scalar: number): Vector1;
+    /**
+     * Divides element by scalar (mutates this)
+     * @param scalar
+     * @returns this instance, for method chaining
+     *
+     * @example
+     * ```ts
+     * const v = new Vector1(6);
+     * v.divideScalar(2);
+     * console.log(v.x); // 3
+     * ```
+     */
+    divideScalar(scalar: number): Vector1;
+    /**
+     * Calculates the length of this vector
+     * @returns the length of this vector (always non-negative)
+     *
+     * @example
+     * ```ts
+     * const v = new Vector1(2);
+     * console.log(v.length()); // 2
+     * ```
+     */
+    length(): number;
+    /**
+     * Normalizes this vector to length 1
+     * @returns this instance, for method chaining
+     *
+     * @example
+     * ```ts
+     * const v = new Vector1(-2);
+     * v.normalize();
+     * console.log(v.x); // -1
+     * ```
+     */
+    normalize(): Vector1;
+    /**
+     * Applies matrix to this vector (mutates this)
+     * @param matrix
+     * @returns this instance, for method chaining
+     */
+    applyMatrix3(matrix: Matrix3): Vector1;
+    /**
+     * Applies matrix to this vector (mutates this)
+     * @param matrix
+     * @returns this instance, for method chaining
+     */
+    applyMatrix4(matrix: Matrix4): Vector1;
+    /**
+     * Applies quaternion to this vector (mutates this)
+     * @param quaternion
+     * @returns this instance, for method chaining
+     */
+    applyQuaternion(quaternion: Quaternion): Vector1;
+}
+
+export declare class Vector2 implements Vector<2>, AdditiveGroup<Vector2>, Scalable<Vector2>, Normalizable<Vector2>, Clonable<Vector2> {
+    /**
+     * @example
+     * ```ts
+     * const v = new Vector2(3, 4);
+     * console.log(v.dimension); // 2
+     * ```
+     */
+    readonly dimension = 2;
+    /**
+     * @example
+     * ```ts
+     * const v = new Vector2(3, 4);
+     * console.log(v.elements); // [3, 4]
+     * ```
+     */
+    readonly elements: [number, number];
+    private static _tmpMatrix3?;
+    private static get tmpMatrix3();
+    private static _tmpMatrix4?;
+    private static get tmpMatrix4();
+    /**
+     * @example
+     * ```ts
+     * const v = new Vector2(3, 4);
+     * ```
+     */
+    constructor(x: number, y: number);
+    /**
+     * @example
+     * ```ts
+     * const v = new Vector2(3, 4);
+     * console.log(v.x); // 3
+     * ```
+     */
+    get x(): number;
+    /**
+     * @example
+     * ```ts
+     * const v = new Vector2(3, 4);
+     * v.x = 5;
+     * console.log(v.x); // 5
+     * ```
+     */
+    set x(x: number);
+    /**
+     * @example
+     * ```ts
+     * const v = new Vector2(3, 4);
+     * console.log(v.y); // 4
+     * ```
+     */
+    get y(): number;
+    /**
+     * @example
+     * ```ts
+     * const v = new Vector2(3, 4);
+     * v.y = 5;
+     * console.log(v.y); // 5
+     * ```
+     */
+    set y(y: number);
+    /**
+     * Creates a zero vector instance
+     * @returns new zero vector instance
+     * @group Factory Methods
+     *
+     * @example
+     * ```ts
+     * const v = Vector2.zero();
+     * console.log(v); // (0, 0)
+     * ```
+     */
+    static zero(): Vector2;
+    /**
+     * Creates all ones vector instance
+     * @returns new all ones vector instance
+     * @group Factory Methods
+     *
+     * @example
+     * ```ts
+     * const v = Vector2.one();
+     * console.log(v); // (1, 1)
+     * ```
+     */
+    static one(): Vector2;
+    /**
+     * Creates new instance has same elements (pure)
+     * @returns new cloned vector instance
+     *
+     * @example
+     * ```ts
+     * const v = new Vector2(3, 4);
+     * const c = v.clone();
+     * console.log(c); // (3, 4)
+     * ```
+     */
+    clone(): Vector2;
+    /**
+     * Determines if this vector is the zero vector (all components are zero)
+     * @returns `true` if this vector is exactly zero, `false` otherwise
+     *
+     * @example
+     * ```ts
+     * const zero = Vector2.zero();
+     * const ones = Vector2.one();
+     * console.log(zero.isZero()); // true
+     * console.log(ones.isZero()); // false
+     */
+    isZero(): boolean;
+    /**
+     * Sets all elements (mutates this)
+     * @param x
+     * @param y
+     * @returns this instance, for method chaining
+     *
+     * @example
+     * ```ts
+     * const v = new Vector2(3, 4);
+     * v.set(5, 6);
+     * console.log(v); // (5, 6)
+     * ```
+     */
+    set(x: number, y: number): Vector2;
+    /**
+     * Copies all elements from other vector (mutates this)
+     * @returns this instance, for method chaining
+     *
+     * @example
+     * ```ts
+     * const v1 = new Vector2(3, 4);
+     * const v2 = new Vector2(5, 6);
+     * v1.copy(v2);
+     * console.log(v1); // (5, 6)
+     * console.log(v2); // (5, 6)
+     * ```
+     */
+    copy(other: Vector2): Vector2;
+    /**
+     * Adds by other vector (mutates this)
+     * @param other other vector
+     * @returns this instance, for method chaining
+     *
+     * @example
+     * ```ts
+     * const v1 = new Vector2(3, 4);
+     * const v2 = new Vector2(5, 6);
+     * v1.add(v2);
+     * console.log(v1); // (8, 10)
+     * console.log(v2); // (5, 6)
+     * ```
+     */
+    add(other: Vector2): Vector2;
+    /**
+     * Subtracts by other vector (mutates this)
+     * @param other other vector
+     * @returns this instance, for method chaining
+     *
+     * @example
+     * ```ts
+     * const v1 = new Vector2(3, 4);
+     * const v2 = new Vector2(5, 6);
+     * v1.subtract(v2);
+     * console.log(v1); // (-2, -2)
+     * console.log(v2); // (5, 6)
+     * ```
+     */
+    subtract(other: Vector2): Vector2;
+    /**
+     * Multiplies all elements by scalar (mutates this)
+     * @param scalar
+     * @returns this instance, for method chaining
+     *
+     * @example
+     * ```ts
+     * const v = new Vector2(3, 4);
+     * v.multiplyScalar(2);
+     * console.log(v); // (6, 8)
+     * ```
+     */
+    multiplyScalar(scalar: number): Vector2;
+    /**
+     * Divides all elements by scalar (mutates this)
+     * @param scalar
+     * @returns this instance, for method chaining
+     *
+     * @example
+     * ```ts
+     * const v = new Vector2(3, 4);
+     * v.divideScalar(2);
+     * console.log(v); // (1.5, 2)
+     * ```
+     */
+    divideScalar(scalar: number): Vector2;
+    /**
+     * Calculates the length of this vector (pure)
+     * @returns the length of this vector (always non-negative)
+     *
+     * @example
+     * ```ts
+     * const v = new Vector2(3, 4);
+     * console.log(v.length()); // 5
+     * ```
+     */
+    length(): number;
+    /**
+     * Normalizes this vector to length 1 (mutates this)
+     * @returns this instance, for method chaining
+     *
+     * @example
+     * ```ts
+     * const v = new Vector2(3, 4);
+     * v.normalize();
+     * console.log(v); // (0.6, 0.8)
+     * ```
+     */
+    normalize(): Vector2;
+    /**
+     * Rotates vector by given angle in radians (mutates this)
+     * @param radian angle in radians, measured counter-clockwise from the positive x-axis
+     * @returns this instance, for method chaining
+     *
+     * @example
+     * ```ts
+     * const v = new Vector2(1, 1);
+     * v.rotate(Math.PI / 2);
+     * console.log(v); // (-1, 1)
+     * ```
+     */
+    rotate(radian: number): Vector2;
+    /**
+     * Applies matrix to this vector (mutates this)
+     * @param matrix
+     * @returns this instance, for method chaining
+     */
+    applyMatrix3(matrix: Matrix3): Vector2;
+    /**
+     * Applies matrix to this vector (mutates this)
+     * @param matrix
+     * @returns this instance, for method chaining
+     */
+    applyMatrix4(matrix: Matrix4): Vector2;
+    /**
+     * Applies quaternion to this vector (mutates this)
+     * @param quaternion
+     * @returns this instance, for method chaining
+     */
+    applyQuaternion(quaternion: Quaternion): Vector2;
+}
+
+export declare class Vector3 implements Vector<3>, AdditiveGroup<Vector3>, Scalable<Vector3>, Normalizable<Vector3>, Clonable<Vector3> {
+    /**
+     * @example
+     * ```ts
+     * const v = new Vector3(4, 5, 6);
+     * console.log(v.dimension); // 3
+     * ```
+     */
+    readonly dimension = 3;
+    /**
+     * @example
+     * ```ts
+     * const v = new Vector3(4, 5, 6);
+     * console.log(v.elements); // [4, 5, 6]
+     * ```
+     */
+    readonly elements: [number, number, number];
+    private static _tmpMatrix3?;
+    private static get tmpMatrix3();
+    private static _tmpMatrix4?;
+    private static get tmpMatrix4();
+    /**
+     * @example
+     * ```ts
+     * const v = new Vector3(4, 5, 6);
+     * ```
+     */
+    constructor(x: number, y: number, z: number);
+    /**
+     * @example
+     * ```ts
+     * const v = new Vector3(4, 5, 6);
+     * console.log(v.x); // 4
+     * ```
+     */
+    get x(): number;
+    /**
+     * @example
+     * ```ts
+     * const v = new Vector3(4, 5, 6);
+     * v.x = 7;
+     * console.log(v.x); // 7
+     * ```
+     */
+    set x(x: number);
+    /**
+     * @example
+     * ```ts
+     * const v = new Vector3(4, 5, 6);
+     * console.log(v.y); // 5
+     * ```
+     */
+    get y(): number;
+    /**
+     * @example
+     * ```ts
+     * const v = new Vector3(4, 5, 6);
+     * v.y = 7;
+     * console.log(v.y); // 7
+     * ```
+     */
+    set y(y: number);
+    /**
+     * @example
+     * ```ts
+     * const v = new Vector3(4, 5, 6);
+     * console.log(v.z); // 6
+     * ```
+     */
+    get z(): number;
+    /**
+     * @example
+     * ```ts
+     * const v = new Vector3(4, 5, 6);
+     * v.z = 7;
+     * console.log(v.z); // 7
+     * ```
+     */
+    set z(z: number);
+    /**
+     * Creates a zero vector instance
+     * @returns new zero vector instance
+     * @group Factory Methods
+     *
+     * @example
+     * ```ts
+     * const v = Vector3.zero();
+     * console.log(v); // (0, 0, 0)
+     * ```
+     */
+    static zero(): Vector3;
+    /**
+     * Creates all ones vector instance
+     * @returns new all ones vector instance
+     * @group Factory Methods
+     *
+     * @example
+     * ```ts
+     * const v = Vector3.one();
+     * console.log(v); // (1, 1, 1)
+     * ```
+     *
+     */
+    static one(): Vector3;
+    /**
+     * Creates new instance has same elements (pure)
+     * @returns new cloned vector instance
+     *
+     * @example
+     * ```ts
+     * const v = new Vector3(4, 5, 6);
+     * const c = v.clone();
+     * console.log(c); // (4, 5, 6)
+     * ```
+     */
+    clone(): Vector3;
+    /**
+     * Determines if this vector is the zero vector (all components are zero)
+     * @returns `true` if this vector is exactly zero, `false` otherwise
+     *
+     * @example
+     * ```ts
+     * const zero = Vector3.zero();
+     * const ones = Vector3.one();
+     * console.log(zero.isZero()); // true
+     * console.log(ones.isZero()); // false
+     * ```
+     */
+    isZero(): boolean;
+    /**
+     * Sets all elements (mutates this)
+     * @param x
+     * @param y
+     * @param z
+     * @returns this instance, for method chaining
+     *
+     * @example
+     * ```ts
+     * const v = new Vector3(4, 5, 6);
+     * v.set(7, 8, 9);
+     * console.log(v); // (7, 8, 9)
+     * ```
+     */
+    set(x: number, y: number, z: number): Vector3;
+    /**
+     * Copies all elements from other vector (mutates this)
+     * @returns this instance, for method chaining
+     *
+     * @example
+     * ```ts
+     * const v1 = new Vector3(4, 5, 6);
+     * const v2 = new Vector3(7, 8, 9);
+     * v1.copy(v2);
+     * console.log(v1); // (7, 8, 9)
+     * console.log(v2); // (7, 8, 9)
+     * ```
+     */
+    copy(other: Vector3): Vector3;
+    /**
+     * Adds by other vector (mutates this)
+     * @param other other vector
+     * @returns this instance, for method chaining
+     *
+     * @example
+     * ```ts
+     * const v1 = new Vector3(4, 5, 6);
+     * const v2 = new Vector3(7, 8, 9);
+     * v1.add(v2);
+     * console.log(v1); // (11, 13, 15)
+     * console.log(v2); // (7, 8, 9)
+     * ```
+     */
+    add(other: Vector3): Vector3;
+    /**
+     * Subtracts by other vector (mutates this)
+     * @param other other vector
+     * @returns this instance, for method chaining
+     *
+     * @example
+     * ```ts
+     * const v1 = new Vector3(4, 5, 6);
+     * const v2 = new Vector3(7, 8, 9);
+     * v1.subtract(v2);
+     * console.log(v1); // (-3, -3, -3)
+     * console.log(v2); // (7, 8, 9)
+     * ```
+     */
+    subtract(other: Vector3): Vector3;
+    /**
+     * Multiplies all elements by scalar (mutates this)
+     * @param scalar
+     * @returns this instance, for method chaining
+     *
+     * @example
+     * ```ts
+     * const v = new Vector3(4, 5, 6);
+     * v.multiplyScalar(2);
+     * console.log(v); // (8, 10, 12)
+     * ```
+     */
+    multiplyScalar(scalar: number): Vector3;
+    /**
+     * Divides all elements by scalar (mutates this)
+     * @param scalar
+     * @returns this instance, for method chaining
+     *
+     * @example
+     * ```ts
+     * const v = new Vector3(4, 5, 6);
+     * v.divideScalar(2);
+     * console.log(v); // (2, 2.5, 3)
+     * ```
+     */
+    divideScalar(scalar: number): Vector3;
+    /**
+     * Calculates the length of this vector (pure)
+     * @returns the length of this vector (always non-negative)
+     *
+     * @example
+     * ```ts
+     * const v = new Vector3(2, 3, 6);
+     * console.log(v.length()); // 7
+     * ```
+     */
+    length(): number;
+    /**
+     * Normalizes this vector to length 1 (mutates this)
+     * @returns this instance, for method chaining
+     *
+     * @example
+     * ```ts
+     * const v = new Vector3(2, 3, 6);
+     * v.normalize();
+     * console.log(v); // (2/7, 3/7, 6/7)
+     * ```
+     */
+    normalize(): Vector3;
+    /**
+     * Calculates the cross product of this and other (mutates this)
+     * @param other other vector
+     * @returns this instance, for method chaining
+     *
+     * @example
+     * ```ts
+     * const v1 = new Vector3(1, 0, 0);
+     * const v2 = Vector3.zero();
+     * v1.cross(v2);
+     * console.log(v1); // (0, 0, 1);
+     *
+     * const v3 = new Vector3(1, 0, 0);
+     * const v4 = Vector3.zero();
+     * const out = Vector3.zero();
+     * v3.cross(v4, out);
+     * console.log(v3); // (1, 0, 0)
+     * console.log(out); // (0, 0, 1)
+     * ```
+     */
+    cross(other: Vector3): Vector3;
+    /**
+     * Calculates the cross product of this and other (mutates out)
+     * @param other other vector
+     * @param out vector instance to receive cross
+     * @returns
+     */
+    crossTo(other: Vector3, out: Vector3): Vector3;
+    /**
+     * Applies matrix to this vector (mutates this)
+     * @param matrix
+     * @returns this instance, for method chaining
+     */
+    applyMatrix3(matrix: Matrix3): Vector3;
+    /**
+     * Applies matrix to this vector (mutates this)
+     * @param matrix
+     * @returns this instance, for method chaining
+     */
+    applyMatrix4(matrix: Matrix4): Vector3;
+    /**
+     * Applies quaternion to this vector (mutates this)
+     * @param quaternion
+     * @returns this instance, for method chaining
+     */
+    applyQuaternion(quaternion: Quaternion): Vector3;
+}
+
+export declare class Vector4 implements Vector<4>, AdditiveGroup<Vector4>, Scalable<Vector4>, Normalizable<Vector4>, Clonable<Vector4> {
+    /**
+     * @example
+     * ```ts
+     * const v = new Vector4(0, 1, 2, 3);
+     * console.log(v.dimension); // 4
+     * ```
+     */
+    readonly dimension = 4;
+    /**
+     * @example
+     * ```ts
+     * const v = new Vector4(0, 1, 2, 3);
+     * console.log(v.elements); // [0, 1, 2, 3]
+     * ```
+     */
+    readonly elements: [number, number, number, number];
+    private static _tmpMatrix4?;
+    private static get tmpMatrix4();
+    /**
+     * @example
+     * ```ts
+     * const v = new Vector4(0, 1, 2, 3);
+     * ```
+     */
+    constructor(x: number, y: number, z: number, w: number);
+    /**
+     * @example
+     * ```ts
+     * const v = new Vector4(0, 1, 2, 3);
+     * console.log(v.x); // 0
+     * ```
+     */
+    get x(): number;
+    /**
+     * @example
+     * ```ts
+     * const v = new Vector4(0, 1, 2, 3);
+     * v.x = 5;
+     * console.log(v.x); // 5
+     * ```
+     */
+    set x(x: number);
+    /**
+     * @example
+     * ```ts
+     * const v = new Vector4(0, 1, 2, 3);
+     * console.log(v.y); // 1
+     * ```
+     */
+    get y(): number;
+    /**
+     * @example
+     * ```ts
+     * const v = new Vector4(0, 1, 2, 3);
+     * v.y = 5;
+     * console.log(v.y); // 5
+     * ```
+     */
+    set y(y: number);
+    /**
+     * @example
+     * ```ts
+     * const v = new Vector4(0, 1, 2, 3);
+     * console.log(v.z); // 2
+     * ```
+     */
+    get z(): number;
+    /**
+     * @example
+     * ```ts
+     * const v = new Vector4(0, 1, 2, 3);
+     * v.z = 5;
+     * console.log(v.z); // 5
+     * ```
+     */
+    set z(z: number);
+    /**
+     * @example
+     * ```ts
+     * const v = new Vector4(0, 1, 2, 3);
+     * console.log(v.w); // 3
+     * ```
+     */
+    get w(): number;
+    /**
+     * @example
+     * ```ts
+     * const v = new Vector4(0, 1, 2, 3);
+     * v.w = 5;
+     * console.log(v.w); // 5
+     * ```
+     */
+    set w(w: number);
+    /**
+     * Creates a zero vector instance
+     * @returns new zero vector instance
+     * @group Factory Methods
+     *
+     * @example
+     * ```ts
+     * const v = Vector4.zero();
+     * console.log(v); // (0, 0, 0, 0)
+     * ```
+     */
+    static zero(): Vector4;
+    /**
+     * Creates all ones vector instance
+     * @returns new all ones vector instance
+     * @group Factory Methods
+     *
+     * @example
+     * ```ts
+     * const v = Vector4.one();
+     * console.log(v); // (1, 1, 1, 1)
+     * ```
+     */
+    static one(): Vector4;
+    /**
+     * Creates new instance has same elements (pure)
+     * @returns new cloned vector instance
+     *
+     * @example
+     * ```ts
+     * const v = new Vector4(0, 1, 2, 3);
+     * const c = v.clone();
+     * console.log(c); // (0, 1, 2, 3);
+     * ```
+     */
+    clone(): Vector4;
+    /**
+     * Determines if this vector is the zero vector (all components are zero)
+     * @returns `true` if this vector is exactly zero, `false` otherwise
+     *
+     * @example
+     * ```ts
+     * const zero = Vector4.zero();
+     * const ones = Vector4.one();
+     * console.log(zero.isZero()); // true
+     * console.log(ones.isZero()); // false
+     * ```
+     */
+    isZero(): boolean;
+    /**
+     * Sets all elements (mutates this)
+     * @param x
+     * @param y
+     * @param z
+     * @param w
+     * @returns this instance, for method chaining
+     *
+     * @example
+     * ```ts
+     * const v = new Vector4(0, 1, 2, 3);
+     * v.set(5, 6, 7, 8);
+     * console.log(v); // (5, 6, 7, 8)
+     * ```
+     */
+    set(x: number, y: number, z: number, w: number): void;
+    /**
+     * Copies all elements from other vector (mutates this)
+     * @returns this instance, for method chaining
+     *
+     * @example
+     * ```ts
+     * const v1 = new Vector4(0, 1, 2, 3);
+     * const v2 = new Vector4(5, 6, 7, 8);
+     * v1.copy(v2);
+     * console.log(v1); // (5, 6, 7, 8)
+     * console.log(v2); // (5, 6, 7, 8)
+     * ```
+     */
+    copy(other: Vector4): void;
+    /**
+     * Adds by other vector (mutates this)
+     * @param other other vector
+     * @returns this instance, for method chaining
+     *
+     * @example
+     * ```ts
+     * const v1 = new Vector4(0, 1, 2, 3);
+     * const v2 = new Vector4(5, 6, 7, 8);
+     * v1.add(v2);
+     * console.log(v1); // (5, 7, 9, 11)
+     * console.log(v2); // (5, 6, 7, 8)
+     * ```
+     */
+    add(other: Vector4): Vector4;
+    /**
+     * Subtracts by other vector (mutates this)
+     * @param other other vector
+     * @returns this instance, for method chaining
+     *
+     * @example
+     * ```ts
+     * const v1 = new Vector4(0, 1, 2, 3);
+     * const v2 = new Vector4(5, 6, 7, 8);
+     * v1.subtract(v2);
+     * console.log(v1); // (-5, -5, -5, -5)
+     * console.log(v2); // (5, 6, 7, 8)
+     * ```
+     */
+    subtract(other: Vector4): Vector4;
+    /**
+     * Multiplies all elements by scalar (mutates this)
+     * @param scalar
+     * @returns this instance, for method chaining
+     *
+     * @example
+     * ```ts
+     * const v = new Vector4(0, 1, 2, 3);
+     * v.multiplyScalar(2);
+     * console.log(v); // (0, 2, 4, 6)
+     * ```
+     */
+    multiplyScalar(scalar: number): Vector4;
+    /**
+     * Divides all elements by scalar (mutates this)
+     * @param scalar
+     * @returns this instance, for method chaining
+     *
+     * @example
+     * ```ts
+     * const v = new Vector4(0, 1, 2, 3);
+     * v.divideScalar(2);
+     * console.log(v); // (0, 0.5, 1, 1.5)
+     * ```
+     */
+    divideScalar(scalar: number): Vector4;
+    /**
+     * Calculates the length of this vector (pure)
+     * @returns the length of this vector (always non-negative)
+     *
+     * @example
+     * ```ts
+     * const v = new Vector4(1, 2, 2, 4);
+     * console.log(v.length()); // 5
+     * ```
+     */
+    length(): number;
+    /**
+     * Normalizes this vector to length 1 (mutates this)
+     * @returns this instance, for method chaining
+     *
+     * @example
+     * ```ts
+     * const v = new Vector4(1, 2, 2, 4);
+     * v.normalize();
+     * console.log(v); // (1/5, 2/5, 2/5, 4/5)
+     * ```
+     */
+    normalize(): Vector4;
+    /**
+     * Applies matrix to this vector (mutates this)
+     * @param matrix
+     * @returns this instance, for method chaining
+     */
+    applyMatrix4(matrix: Matrix4): Vector4;
+    /**
+     * Applies quaternion to this vector (mutates this)
+     * @param quaternion
+     * @returns this instance, for method chaining
+     */
+    applyQuaternion(quaternion: Quaternion): Vector4;
+}
+
+export declare type VectorDimension = 1 | 2 | 3 | 4;
+
+export { }