glmaths 0.0.2 → 0.0.4

package/dist/esm/glmaths.d.ts

@@ -19,7 +19,7 @@ declare class Mat2x3 extends Float32Array {
     /**
      * Inverts a mat2x3
      *
-     * @param {Mat2x3} out the receiving matrix, defaults to this
+     * @param {Mat2x3} out the receiving matrix, defaults to new mat2x3()
      * @returns {Mat2x3} out or null if the matrix is not invertible
      */
     invert(out?: Mat2x3): Mat2x3 | null;
@@ -33,7 +33,7 @@ declare class Mat2x3 extends Float32Array {
      * Rotates a mat2x3 by the given angle
      *
      * @param {Number} rad the angle to rotate the matrix by
-     * @param {Mat2x3} out the receiving matrix, defaults to this
+     * @param {Mat2x3} out the receiving matrix, defaults to new mat2x3()
      * @returns {Mat2x3} out
      */
     rotate(rad: number, out?: Mat2x3): Mat2x3;
@@ -41,7 +41,7 @@ declare class Mat2x3 extends Float32Array {
      * Scales a mat2x3 by the dimensions in the given Vec2
      *
      * @param {Vec2} v the Vec2 to scale the matrix by
-     * @param {Mat2x3} out the receiving matrix, defaults to this
+     * @param {Mat2x3} out the receiving matrix, defaults to new mat2x3()
      * @returns {Mat2x3} out
      */
     scale(v: Vec2, out?: Mat2x3): Mat2x3;
@@ -49,7 +49,7 @@ declare class Mat2x3 extends Float32Array {
      * Translates a mat2x3 by the dimensions in the given Vec2
      *
      * @param {Vec2} v the Vec2 to translate the matrix by
-     * @param {Mat2x3} out the receiving matrix, defaults to this
+     * @param {Mat2x3} out the receiving matrix, defaults to new mat2x3()
      * @returns {Mat2x3} out
      */
     translate(v: Vec2, out?: Mat2x3): Mat2x3;
@@ -57,7 +57,7 @@ declare class Mat2x3 extends Float32Array {
      * Creates a Mat2x3 from a given angle
      *
      * @param {Number} rad the angle to rotate the matrix by
-     * @param {Mat2x3} out the receiving matrix, defaults to new Mat2x3()
+     * @param {Mat2x3} out the receiving matrix, defaults to mat2x3()
      * @returns {Mat2x3} out
      */
     static fromRotation(rad: number, out?: Mat2x3): Mat2x3;
@@ -65,7 +65,7 @@ declare class Mat2x3 extends Float32Array {
      * Creates a Mat2x3 from a scaling vector
      *
      * @param {Vec2} v scaling vector
-     * @param {Mat2x3} out the receiving matrix, defaults to new Mat2x3()
+     * @param {Mat2x3} out the receiving matrix, defaults to mat2x3()
      * @returns {Mat2x3} out
      */
     static fromScaling(v: Vec2, out?: Mat2x3): Mat2x3;
@@ -73,7 +73,7 @@ declare class Mat2x3 extends Float32Array {
      * Creates a Mat2x3 from a translation vector
      *
      * @param {Vec2} v translation vector
-     * @param {Mat2x3} out the receiving matrix, defaults to new Mat2x3()
+     * @param {Mat2x3} out the receiving matrix, defaults to mat2x3()
      * @returns {Mat2x3} out
      */
     static fromTranslation(v: Vec2, out?: Mat2x3): Mat2x3;
@@ -93,7 +93,7 @@ declare class Mat2x3 extends Float32Array {
      * Adds two Mat2x3's
      *
      * @param {Mat2x3} b the second operand
-     * @param {Mat2x3} out the receiving matrix, defaults to this
+     * @param {Mat2x3} out the receiving matrix, defaults to new mat2x3()
      * @returns {Mat2x3} out
      */
     plus(b: Mat2x3, out?: Mat2x3): Mat2x3;
@@ -101,7 +101,7 @@ declare class Mat2x3 extends Float32Array {
      * Subtracts matrix b from a mat2x3
      *
      * @param {Mat2x3} b the second operand
-     * @param {Mat2x3} out the receiving matrix, defaults to this
+     * @param {Mat2x3} out the receiving matrix, defaults to new mat2x3()
      * @returns {Mat2x3} out
      */
     minus(b: Mat2x3, out?: Mat2x3): Mat2x3;
@@ -109,7 +109,7 @@ declare class Mat2x3 extends Float32Array {
      * Multiplies a mat2x3 by another Mat2x3
      *
      * @param {Mat2x3} b the second operand
-     * @param {Mat2x3} out the receiving matrix, defaults to this
+     * @param {Mat2x3} out the receiving matrix, defaults to new mat2x3()
      * @returns {Mat2x3} out
      */
     multiply(b: Vec2): Vec2;
@@ -132,7 +132,7 @@ declare class Mat2x3 extends Float32Array {
      * Multiplies each element of a mat2x3 by a scalar value
      *
      * @param {Number} b amount to scale the matrix's elements by
-     * @param {Mat2x3} out the receiving matrix, defaults to this
+     * @param {Mat2x3} out the receiving matrix, defaults to new mat2x3()
      * @returns {Mat2x3} out
      */
     scaleScalar(b: number, out?: Mat2x3): Mat2x3;
@@ -156,8 +156,9 @@ interface Mat2x3 {
     multiplyScalar: (b: number, out?: Mat2x3) => Mat2x3;
     str: () => string;
 }
-declare const mat2x3: ((a?: number, b?: number, c?: number, d?: number, tx?: number, ty?: number) => Mat2x3) & typeof Mat2x3;
-declare const mat2d: ((a?: number, b?: number, c?: number, d?: number, tx?: number, ty?: number) => Mat2x3) & typeof Mat2x3;
+declare const createMat2x3: (...args: (number | Float32Array)[]) => Mat2x3;
+declare const mat2x3: typeof createMat2x3 & typeof Mat2x3;
+declare const mat2d: ((...args: (number | Float32Array)[]) => Mat2x3) & typeof Mat2x3;
 
 /**
  * 3x3 Matrix in column-major order
@@ -190,21 +191,21 @@ declare class Mat3 extends Float32Array {
     /**
      * Transposes a mat3
      *
-     * @param {Mat3} out the receiving matrix, defaults to this
+     * @param {Mat3} out the receiving matrix, defaults to new mat3()
      * @returns {Mat3} out
      */
     transpose(out?: Mat3): Mat3;
     /**
      * Inverts a mat3
      *
-     * @param {Mat3} out the receiving matrix, defaults to this
+     * @param {Mat3} out the receiving matrix, defaults to new mat3()
      * @returns {Mat3|null} out, or null if not invertible
      */
     invert(out?: Mat3): Mat3 | null;
     /**
      * Calculates the adjugate of a mat3
      *
-     * @param {Mat3} out the receiving matrix, defaults to this
+     * @param {Mat3} out the receiving matrix, defaults to new mat3()
      * @returns {Mat3} out
      */
     adjoint(out?: Mat3): Mat3;
@@ -218,7 +219,7 @@ declare class Mat3 extends Float32Array {
      * Multiplies two mat3's
      *
      * @param {Mat3} b the second operand
-     * @param {Mat3} out the receiving matrix, defaults to this
+     * @param {Mat3} out the receiving matrix, defaults to new mat3()
      * @returns {Mat3} out
      */
     multiply(b: Vec2): Vec2;
@@ -228,7 +229,7 @@ declare class Mat3 extends Float32Array {
      * Translates a mat3 by the given vector
      *
      * @param {Vec2} v vector to translate by
-     * @param {Mat3} out the receiving matrix, defaults to this
+     * @param {Mat3} out the receiving matrix, defaults to new mat3()
      * @returns {Mat3} out
      */
     translate(v: Vec2, out?: Mat3): Mat3;
@@ -236,7 +237,7 @@ declare class Mat3 extends Float32Array {
      * Rotates a mat3 by the given angle
      *
      * @param {Number} rad the angle to rotate the matrix by
-     * @param {Mat3} out the receiving matrix, defaults to this
+     * @param {Mat3} out the receiving matrix, defaults to new mat3()
      * @returns {Mat3} out
      */
     rotate(rad: number, out?: Mat3): Mat3;
@@ -244,7 +245,7 @@ declare class Mat3 extends Float32Array {
      * Scales a mat3 by the given vector
      *
      * @param {Vec2} v the vector to scale by
-     * @param {Mat3} out the receiving matrix, defaults to this
+     * @param {Mat3} out the receiving matrix, defaults to new mat3()
      * @returns {Mat3} out
      */
     scale(v: Vec2, out?: Mat3): Mat3;
@@ -252,7 +253,7 @@ declare class Mat3 extends Float32Array {
      * Creates a matrix from a translation vector
      *
      * @param {Vec2} v translation vector
-     * @param {Mat3} out the receiving matrix, defaults to new Mat3()
+     * @param {Mat3} out the receiving matrix, defaults to mat3()
      * @returns {Mat3} out
      */
     static fromTranslation(v: Vec2, out?: Mat3): Mat3;
@@ -260,7 +261,7 @@ declare class Mat3 extends Float32Array {
      * Creates a matrix from a given angle
      *
      * @param {Number} rad the angle to rotate the matrix by
-     * @param {Mat3} out the receiving matrix, defaults to new Mat3()
+     * @param {Mat3} out the receiving matrix, defaults to mat3()
      * @returns {Mat3} out
      */
     static fromRotation(rad: number, out?: Mat3): Mat3;
@@ -268,7 +269,7 @@ declare class Mat3 extends Float32Array {
      * Creates a matrix from a scaling vector
      *
      * @param {Vec2} v scaling vector
-     * @param {Mat3} out the receiving matrix, defaults to new Mat3()
+     * @param {Mat3} out the receiving matrix, defaults to mat3()
      * @returns {Mat3} out
      */
     static fromScaling(v: Vec2, out?: Mat3): Mat3;
@@ -276,7 +277,7 @@ declare class Mat3 extends Float32Array {
      * Creates a mat3 from a Mat2x3
      *
      * @param {Mat2x3} a the Mat2x3 to convert
-     * @param {Mat3} out the receiving matrix, defaults to new Mat3()
+     * @param {Mat3} out the receiving matrix, defaults to mat3()
      * @returns {Mat3} out
      */
     static fromMat2x3(a: Mat2x3, out?: Mat3): Mat3;
@@ -285,7 +286,7 @@ declare class Mat3 extends Float32Array {
      * Calculates a mat3 from the given quaternion
      *
      * @param {Quat} q quaternion to create matrix from
-     * @param {Mat3} out the receiving matrix, defaults to new Mat3()
+     * @param {Mat3} out the receiving matrix, defaults to mat3()
      * @returns {Mat3} out
      */
     static fromQuat(q: Quat, out?: Mat3): Mat3;
@@ -293,7 +294,7 @@ declare class Mat3 extends Float32Array {
      * Calculates a mat3 normal matrix (transpose inverse) from a mat4
      *
      * @param {Mat4} a the source mat4 to derive the normal matrix from
-     * @param {Mat3} out the receiving matrix, defaults to new Mat3()
+     * @param {Mat3} out the receiving matrix, defaults to mat3()
      * @returns {Mat3|null} out, or null if not invertible
      */
     static normalFromMat4(a: Mat4, out?: Mat3): Mat3 | null;
@@ -301,7 +302,7 @@ declare class Mat3 extends Float32Array {
      * Copies the upper-left 3x3 values of a mat4 into a mat3
      *
      * @param {Mat4} a the source mat4
-     * @param {Mat3} out the receiving matrix, defaults to new Mat3()
+     * @param {Mat3} out the receiving matrix, defaults to mat3()
      * @returns {Mat3} out
      */
     static fromMat4(a: Mat4, out?: Mat3): Mat3;
@@ -311,7 +312,7 @@ declare class Mat3 extends Float32Array {
      *
      * @param {Number} width width of the projection
      * @param {Number} height height of the projection
-     * @param {Mat3} out the receiving matrix, defaults to new Mat3()
+     * @param {Mat3} out the receiving matrix, defaults to mat3()
      * @returns {Mat3} out
      */
     static projection(width: number, height: number, out?: Mat3): Mat3;
@@ -325,7 +326,7 @@ declare class Mat3 extends Float32Array {
      * Adds two mat3's
      *
      * @param {Mat3} b the second operand
-     * @param {Mat3} out the receiving matrix, defaults to this
+     * @param {Mat3} out the receiving matrix, defaults to new mat3()
      * @returns {Mat3} out
      */
     plus(b: Mat3, out?: Mat3): Mat3;
@@ -333,7 +334,7 @@ declare class Mat3 extends Float32Array {
      * Subtracts matrix b from this
      *
      * @param {Mat3} b the second operand
-     * @param {Mat3} out the receiving matrix, defaults to this
+     * @param {Mat3} out the receiving matrix, defaults to new mat3()
      * @returns {Mat3} out
      */
     minus(b: Mat3, out?: Mat3): Mat3;
@@ -341,7 +342,7 @@ declare class Mat3 extends Float32Array {
      * Multiplies each element of a mat3 by a scalar number
      *
      * @param {Number} b amount to scale the matrix's elements by
-     * @param {Mat3} out the receiving matrix, defaults to this
+     * @param {Mat3} out the receiving matrix, defaults to new mat3()
      * @returns {Mat3} out
      */
     scaleScalar(b: number, out?: Mat3): Mat3;
@@ -350,7 +351,7 @@ declare class Mat3 extends Float32Array {
      *
      * @param {Mat3} b the second operand
      * @param {Number} scale the amount to scale b's elements by before adding
-     * @param {Mat3} out the receiving matrix, defaults to this
+     * @param {Mat3} out the receiving matrix, defaults to new mat3()
      * @returns {Mat3} out
      */
     multiplyScalarAndAdd(b: Mat3, scale: number, out?: Mat3): Mat3;
@@ -391,7 +392,8 @@ interface Mat3 {
     str: () => string;
     multiplyScalar: (b: number, out?: Mat3) => Mat3;
 }
-declare const mat3: ((...args: (number | Float32Array)[]) => Mat3) & typeof Mat3;
+declare const createMat3: (...args: (number | Float32Array)[]) => Mat3;
+declare const mat3: typeof createMat3 & typeof Mat3;
 declare const mat3x3: ((...args: (number | Float32Array)[]) => Mat3) & typeof Mat3;
 
 /**
@@ -415,7 +417,7 @@ declare class Quat extends Float32Array {
      * Calculates the Hamilton product of two quaternions
      *
      * @param {Quat} b the second operand
-     * @param {Quat} out the receiving quaternion, defaults to this
+     * @param {Quat} out the receiving quaternion, defaults to new quat()
      * @returns {Quat} out
      */
     multiply(b: Quat | number, out?: Quat): Quat;
@@ -433,7 +435,7 @@ declare class Quat extends Float32Array {
      *
      * @param {Vec3} axis the axis around which to rotate
      * @param {Number} rad the angle in radians
-     * @param {Quat} out the receiving quaternion, defaults to this
+     * @param {Quat} out the receiving quaternion, defaults to new quat()
      * @returns {Quat} out
      */
     setAxisAngle(axis: Vec3, rad: number, out?: Quat): Quat;
@@ -470,7 +472,7 @@ declare class Quat extends Float32Array {
      * Rotates a quaternion by the given angle about the X axis
      *
      * @param {Number} rad angle in radians to rotate
-     * @param {Quat} out the receiving quaternion, defaults to this
+     * @param {Quat} out the receiving quaternion, defaults to new quat()
      * @returns {Quat} out
      */
     rotateX(rad: number, out?: Quat): Quat;
@@ -478,7 +480,7 @@ declare class Quat extends Float32Array {
      * Rotates a quaternion by the given angle about the Y axis
      *
      * @param {Number} rad angle in radians to rotate
-     * @param {Quat} out the receiving quaternion, defaults to this
+     * @param {Quat} out the receiving quaternion, defaults to new quat()
      * @returns {Quat} out
      */
     rotateY(rad: number, out?: Quat): Quat;
@@ -486,7 +488,7 @@ declare class Quat extends Float32Array {
      * Rotates a quaternion by the given angle about the Z axis
      *
      * @param {Number} rad angle in radians to rotate
-     * @param {Quat} out the receiving quaternion, defaults to this
+     * @param {Quat} out the receiving quaternion, defaults to new quat()
      * @returns {Quat} out
      */
     rotateZ(rad: number, out?: Quat): Quat;
@@ -507,7 +509,7 @@ declare class Quat extends Float32Array {
     /**
      * Calculates the exponential of the unit quaternion
      *
-     * @param {Quat} out the receiving quaternion, defaults to this
+     * @param {Quat} out the receiving quaternion, defaults to new quat()
      * @returns {Quat} out
      */
     exp(out?: Quat): Quat;
@@ -522,7 +524,7 @@ declare class Quat extends Float32Array {
     /**
      * Calculates the natural logarithm of the unit quaternion
      *
-     * @param {Quat} out the receiving quaternion, defaults to this
+     * @param {Quat} out the receiving quaternion, defaults to new quat()
      * @returns {Quat} out
      */
     ln(out?: Quat): Quat;
@@ -548,7 +550,7 @@ declare class Quat extends Float32Array {
      *
      * @param {Quat} b the second operand
      * @param {Number} t interpolation amount, in the range [0-1], between the two inputs
-     * @param {Quat} out the receiving quaternion, defaults to this
+     * @param {Quat} out the receiving quaternion, defaults to new quat()
      * @returns {Quat} out
      */
     slerp(b: Quat, t: number, out?: Quat): Quat;
@@ -570,7 +572,7 @@ declare class Quat extends Float32Array {
     /**
      * Calculates the inverse of a quaternion
      *
-     * @param {Quat} out the receiving quaternion, defaults to this
+     * @param {Quat} out the receiving quaternion, defaults to new quat()
      * @returns {Quat} out
      */
     invert(out?: Quat): Quat;
@@ -585,7 +587,7 @@ declare class Quat extends Float32Array {
     /**
      * Calculates the conjugate of a quaternion
      *
-     * @param {Quat} out the receiving quaternion, defaults to this
+     * @param {Quat} out the receiving quaternion, defaults to new quat()
      * @returns {Quat} out
      */
     conjugate(out?: Quat): Quat;
@@ -675,7 +677,15 @@ declare class Quat extends Float32Array {
     /**
      * Normalizes a quaternion
      *
-     * @param {Quat} out the receiving vector, defaults to this
+     * @param {Quat} q the quaternion to normalize
+     * @param {Quat} out the receiving vector, defaults to new quat()
+     * @returns {Quat} out
+     */
+    static normalize(q: Quat, out?: Quat): Quat;
+    /**
+     * Normalizes a quaternion
+     *
+     * @param {Quat} out the receiving vector, defaults to new quat()
      * @returns {Quat} out
      */
     normalize(out?: Quat): Quat;
@@ -735,8 +745,10 @@ interface Quat {
     scale: (b: Quat | number, out?: Quat) => Quat;
     times: (b: Quat | number, out?: Quat) => Quat;
     str: () => string;
+    normalized: (out?: Quat) => Quat;
 }
-declare const quat: ((x?: number, y?: number, z?: number, w?: number) => Quat) & typeof Quat;
+declare const createQuat: (x?: number, y?: number, z?: number, w?: number) => Quat;
+declare const quat: typeof createQuat & typeof Quat;
 
 /**
  * 4x4 Matrix in column-major order
@@ -776,21 +788,21 @@ declare class Mat4 extends Float32Array {
     /**
      * Transposes a mat4
      *
-     * @param {Mat4} out the receiving matrix, defaults to this
+     * @param {Mat4} out the receiving matrix, defaults to new mat4()
      * @returns {Mat4} out
      */
     transpose(out?: Mat4): Mat4;
     /**
      * Inverts a mat4
      *
-     * @param {Mat4} out the receiving matrix, defaults to this
+     * @param {Mat4} out the receiving matrix, defaults to new mat4()
      * @returns {Mat4} out
      */
     invert(out?: Mat4): Mat4 | null;
     /**
      * Calculates the adjugate of a mat4
      *
-     * @param {Mat4} out the receiving matrix, defaults to this
+     * @param {Mat4} out the receiving matrix, defaults to new mat4()
      * @returns {Mat4} out
      */
     adjoint(out?: Mat4): Mat4;
@@ -804,7 +816,7 @@ declare class Mat4 extends Float32Array {
      * Multiplies with another matrix, or transforms a vector
      *
      * @param {Vec2 | Vec3 | Vec4 | Mat4} b the second operand
-     * @param {Mat4} out the receiving matrix, defaults to this
+     * @param {Mat4} out the receiving matrix, defaults to new mat4()
      * @returns {Mat4} out
      */
     multiply(b: Vec2): Vec2;
@@ -815,7 +827,7 @@ declare class Mat4 extends Float32Array {
      * Translates a mat4 by the given Vec3
      *
      * @param {Vec3} v vector to translate by
-     * @param {Mat4} out the receiving matrix, defaults to this
+     * @param {Mat4} out the receiving matrix, defaults to new mat4()
      * @returns {Mat4} out
      */
     translate(v: Vec3, out?: Mat4): Mat4;
@@ -823,7 +835,7 @@ declare class Mat4 extends Float32Array {
      * Scales a mat4 by the dimensions in the given Vec3 not using vectorization
      *
      * @param {Vec3} v the Vec3 to scale the matrix by
-     * @param {Mat4} out the receiving matrix, defaults to this
+     * @param {Mat4} out the receiving matrix, defaults to new mat4()
      * @returns {Mat4} out
      */
     scale(v: Vec3, out?: Mat4): Mat4;
@@ -832,7 +844,7 @@ declare class Mat4 extends Float32Array {
      *
      * @param {Number} rad the angle to rotate the matrix by
      * @param {Vec3} axis the axis to rotate around
-     * @param {Mat4} out the receiving matrix, defaults to this
+     * @param {Mat4} out the receiving matrix, defaults to new mat4()
      * @returns {Mat4} out
      */
     rotate(rad: number, axis: Vec3, out?: Mat4): Mat4 | null;
@@ -840,7 +852,7 @@ declare class Mat4 extends Float32Array {
      * Rotates a mat4 by the given angle around the X axis
      *
      * @param {Number} rad the angle to rotate the matrix by
-     * @param {Mat4} out the receiving matrix, defaults to this
+     * @param {Mat4} out the receiving matrix, defaults to new mat4()
      * @returns {Mat4} out
      */
     rotateX(rad: number, out?: Mat4): Mat4;
@@ -848,7 +860,7 @@ declare class Mat4 extends Float32Array {
      * Rotates a mat4 by the given angle around the Y axis
      *
      * @param {Number} rad the angle to rotate the matrix by
-     * @param {Mat4} out the receiving matrix, defaults to this
+     * @param {Mat4} out the receiving matrix, defaults to new mat4()
      * @returns {Mat4} out
      */
     rotateY(rad: number, out?: Mat4): Mat4;
@@ -856,7 +868,7 @@ declare class Mat4 extends Float32Array {
      * Rotates a mat4 by the given angle around the Z axis
      *
      * @param {Number} rad the angle to rotate the matrix by
-     * @param {Mat4} out the receiving matrix, defaults to this
+     * @param {Mat4} out the receiving matrix, defaults to new mat4()
      * @returns {Mat4} out
      */
     rotateZ(rad: number, out?: Mat4): Mat4;
@@ -897,7 +909,7 @@ declare class Mat4 extends Float32Array {
      * Creates a matrix from a vector translation
      *
      * @param {Vec3} v translation vector
-     * @param {Mat4} out the receiving matrix, defaults to new Mat4()
+     * @param {Mat4} out the receiving matrix, defaults to mat4()
      * @returns {Mat4} out
      */
     static fromTranslation(v: Vec3, out?: Mat4): Mat4;
@@ -905,7 +917,7 @@ declare class Mat4 extends Float32Array {
      * Creates a matrix from a vector scaling
      *
      * @param {Vec3} v scaling vector
-     * @param {Mat4} out the receiving matrix, defaults to new Mat4()
+     * @param {Mat4} out the receiving matrix, defaults to mat4()
      * @returns {Mat4} out
      */
     static fromScaling(v: Vec3, out?: Mat4): Mat4;
@@ -914,7 +926,7 @@ declare class Mat4 extends Float32Array {
      *
      * @param {Number} rad the angle to rotate the matrix by
      * @param {Vec3} axis the axis to rotate around
-     * @param {Mat4} out the receiving matrix, defaults to new Mat4()
+     * @param {Mat4} out the receiving matrix, defaults to mat4()
      * @returns {Mat4} out
      */
     static fromRotation(rad: number, axis: Vec3, out?: Mat4): Mat4 | null;
@@ -922,7 +934,7 @@ declare class Mat4 extends Float32Array {
      * Creates a matrix from the given angle around the X axis
      *
      * @param {Number} rad the angle to rotate the matrix by
-     * @param {Mat4} out the receiving matrix, defaults to new Mat4()
+     * @param {Mat4} out the receiving matrix, defaults to mat4()
      * @returns {Mat4} out
      */
     static fromXRotation(rad: number, out?: Mat4): Mat4;
@@ -930,7 +942,7 @@ declare class Mat4 extends Float32Array {
      * Creates a matrix from the given angle around the Y axis
      *
      * @param {Number} rad the angle to rotate the matrix by
-     * @param {Mat4} out the receiving matrix, defaults to new Mat4()
+     * @param {Mat4} out the receiving matrix, defaults to mat4()
      * @returns {Mat4} out
      */
     static fromYRotation(rad: number, out?: Mat4): Mat4;
@@ -938,7 +950,7 @@ declare class Mat4 extends Float32Array {
      * Creates a matrix from the given angle around the Z axis
      *
      * @param {Number} rad the angle to rotate the matrix by
-     * @param {Mat4} out the receiving matrix, defaults to new Mat4()
+     * @param {Mat4} out the receiving matrix, defaults to mat4()
      * @returns {Mat4} out
      */
     static fromZRotation(rad: number, out?: Mat4): Mat4;
@@ -947,7 +959,7 @@ declare class Mat4 extends Float32Array {
      *
      * @param {Quat} q rotation quaternion
      * @param {Vec3} v translation vector
-     * @param {Mat4} out the receiving matrix, defaults to new Mat4()
+     * @param {Mat4} out the receiving matrix, defaults to mat4()
      * @returns {Mat4} out
      */
     static fromRotationTranslation(q: Quat, v: Vec3, out?: Mat4): Mat4;
@@ -957,7 +969,7 @@ declare class Mat4 extends Float32Array {
      * @param {Quat} q rotation quaternion
      * @param {Vec3} v translation vector
      * @param {Vec3} s scaling vector
-     * @param {Mat4} out the receiving matrix, defaults to new Mat4()
+     * @param {Mat4} out the receiving matrix, defaults to mat4()
      * @returns {Mat4} out
      */
     static fromRotationTranslationScale(q: Quat, v: Vec3, s: Vec3, out?: Mat4): Mat4;
@@ -968,7 +980,7 @@ declare class Mat4 extends Float32Array {
      * @param {Vec3} v translation vector
      * @param {Vec3} s scaling vector
      * @param {Vec3} o the origin vector
-     * @param {Mat4} out the receiving matrix, defaults to new Mat4()
+     * @param {Mat4} out the receiving matrix, defaults to mat4()
      * @returns {Mat4} out
      */
     static fromRotationTranslationScaleOrigin(q: Quat, v: Vec3, s: Vec3, o: Vec3, out?: Mat4): Mat4;
@@ -976,7 +988,7 @@ declare class Mat4 extends Float32Array {
      * Calculates a 4x4 matrix from the given quaternion
      *
      * @param {Quat} q quaternion to create matrix from
-     * @param {Mat4} out the receiving matrix, defaults to new Mat4()
+     * @param {Mat4} out the receiving matrix, defaults to mat4()
      * @returns {Mat4} out
      */
     static fromQuat(q: Quat, out?: Mat4): Mat4;
@@ -989,7 +1001,7 @@ declare class Mat4 extends Float32Array {
      * @param {Number} top top bound of the frustum
      * @param {Number} near near bound of the frustum
      * @param {Number} far far bound of the frustum
-     * @param {Mat4} out the receiving matrix, defaults to new Mat4()
+     * @param {Mat4} out the receiving matrix, defaults to mat4()
      * @returns {Mat4} out
      */
     static frustum(left: number, right: number, bottom: number, top: number, near: number, far: number, out?: Mat4): Mat4;
@@ -1002,7 +1014,7 @@ declare class Mat4 extends Float32Array {
      * @param {Number} aspect aspect ratio, typically viewport width / height
      * @param {Number} near near bound of the frustum
      * @param {Number | null} far far bound of the frustum, can be null or Infinity
-     * @param {Mat4} out the receiving matrix, defaults to new Mat4()
+     * @param {Mat4} out the receiving matrix, defaults to mat4()
      * @returns {Mat4} out
      */
     static perspectiveNO(fovy: number, aspect: number, near: number, far: number | null, out?: Mat4): Mat4;
@@ -1016,7 +1028,7 @@ declare class Mat4 extends Float32Array {
      * @param {Number} aspect aspect ratio, typically viewport width / height
      * @param {Number} near near bound of the frustum
      * @param {Number | null} far far bound of the frustum, can be null or Infinity
-     * @param {Mat4} out the receiving matrix, defaults to new Mat4()
+     * @param {Mat4} out the receiving matrix, defaults to mat4()
      * @returns {Mat4} out
      */
     static perspectiveZO(fovy: number, aspect: number, near: number, far: number | null, out?: Mat4): Mat4;
@@ -1026,7 +1038,7 @@ declare class Mat4 extends Float32Array {
      * @param {Object} fov object containing upDegrees, downDegrees, leftDegrees, rightDegrees
      * @param {Number} near near bound of the frustum
      * @param {Number} far far bound of the frustum
-     * @param {Mat4} out the receiving matrix, defaults to new Mat4()
+     * @param {Mat4} out the receiving matrix, defaults to mat4()
      * @returns {Mat4} out
      */
     static perspectiveFromFieldOfView(fov: {
@@ -1046,7 +1058,7 @@ declare class Mat4 extends Float32Array {
      * @param {Number} top top bound of the frustum
      * @param {Number} near near bound of the frustum
      * @param {Number} far far bound of the frustum
-     * @param {Mat4} out the receiving matrix, defaults to new Mat4()
+     * @param {Mat4} out the receiving matrix, defaults to mat4()
      * @returns {Mat4} out
      */
     static orthoNO(left: number, right: number, bottom: number, top: number, near: number, far: number, out?: Mat4): Mat4;
@@ -1062,7 +1074,7 @@ declare class Mat4 extends Float32Array {
      * @param {Number} top top bound of the frustum
      * @param {Number} near near bound of the frustum
      * @param {Number} far far bound of the frustum
-     * @param {Mat4} out the receiving matrix, defaults to new Mat4()
+     * @param {Mat4} out the receiving matrix, defaults to mat4()
      * @returns {Mat4} out
      */
     static orthoZO(left: number, right: number, bottom: number, top: number, near: number, far: number, out?: Mat4): Mat4;
@@ -1073,7 +1085,7 @@ declare class Mat4 extends Float32Array {
      * @param {Vec3} eye position of the viewer
      * @param {Vec3} center point the viewer is looking at
      * @param {Vec3} up vector pointing up
-     * @param {Mat4} out the receiving matrix, defaults to new Mat4()
+     * @param {Mat4} out the receiving matrix, defaults to mat4()
      * @returns {Mat4} out
      */
     static lookAt(eye: Vec3, center: Vec3, up: Vec3, out?: Mat4): Mat4;
@@ -1083,7 +1095,7 @@ declare class Mat4 extends Float32Array {
      * @param {Vec3} eye position of the viewer
      * @param {Vec3} target point the viewer is looking at
      * @param {Vec3} up vector pointing up
-     * @param {Mat4} out the receiving matrix, defaults to new Mat4()
+     * @param {Mat4} out the receiving matrix, defaults to mat4()
      * @returns {Mat4} out
      */
     static targetTo(eye: Vec3, target: Vec3, up: Vec3, out?: Mat4): Mat4;
@@ -1132,7 +1144,7 @@ declare class Mat4 extends Float32Array {
      * Adds two mat4's
      *
      * @param {Mat4} b the second operand
-     * @param {Mat4} out the receiving matrix, defaults to this
+     * @param {Mat4} out the receiving matrix, defaults to new mat4()
      * @returns {Mat4} out
      */
     plus(b: Mat4, out?: Mat4): Mat4;
@@ -1140,7 +1152,7 @@ declare class Mat4 extends Float32Array {
      * Subtracts matrix b from a mat4
      *
      * @param {Mat4} b the second operand
-     * @param {Mat4} out the receiving matrix, defaults to this
+     * @param {Mat4} out the receiving matrix, defaults to new mat4()
      * @returns {Mat4} out
      */
     minus(b: Mat4, out?: Mat4): Mat4;
@@ -1148,7 +1160,7 @@ declare class Mat4 extends Float32Array {
      * Multiplies each element of a mat4 by a scalar number
      *
      * @param {Number} b amount to scale the matrix's elements by
-     * @param {Mat4} out the receiving matrix, defaults to this
+     * @param {Mat4} out the receiving matrix, defaults to new mat4()
      * @returns {Mat4} out
      */
     scaleScalar(b: number, out?: Mat4): Mat4;
@@ -1157,7 +1169,7 @@ declare class Mat4 extends Float32Array {
      *
      * @param {Mat4} b the second operand
      * @param {Number} scale the amount to scale b's elements by before adding
-     * @param {Mat4} out the receiving matrix, defaults to this
+     * @param {Mat4} out the receiving matrix, defaults to new mat4()
      * @returns {Mat4} out
      */
     multiplyScalarAndAdd(b: Mat4, scale: number, out?: Mat4): Mat4;
@@ -1201,7 +1213,8 @@ interface Mat4 {
     str: () => string;
     multiplyScalar: (b: number, out?: Mat4) => Mat4;
 }
-declare const mat4: ((...args: (number | Float32Array)[]) => Mat4) & typeof Mat4;
+declare const createMat4: (...args: (number | Float32Array)[]) => Mat4;
+declare const mat4: typeof createMat4 & typeof Mat4;
 declare const mat4x4: ((...args: (number | Float32Array)[]) => Mat4) & typeof Mat4;
 
 /**
@@ -1216,7 +1229,7 @@ declare class Vec4 extends Float32Array {
     static get One(): Vec4;
     static get ONE(): Vec4;
     /**
-     * Creates a new Vec4
+     * Creates a vec4
      *
      * @param {Number} x X component, defaults to 0
      * @param {Number} y Y component, defaults to 0
@@ -1236,7 +1249,7 @@ declare class Vec4 extends Float32Array {
      * Adds two vec4's
      *
      * @param {Vec4 | Number} b the second operand
-     * @param {Vec4} out the receiving vector, defaults to this
+     * @param {Vec4} out the receiving vector, defaults to new vec4()
      * @returns {Vec4} out
      */
     plus(b: Vec4 | number, out?: Vec4): Vec4;
@@ -1244,7 +1257,7 @@ declare class Vec4 extends Float32Array {
      * Subtracts two vec4's
      *
      * @param {Vec4 | Number} b the second operand
-     * @param {Vec4} out the receiving vector, defaults to this
+     * @param {Vec4} out the receiving vector, defaults to new vec4()
      * @returns {Vec4} out
      */
     minus(b: Vec4 | number, out?: Vec4): Vec4;
@@ -1252,7 +1265,7 @@ declare class Vec4 extends Float32Array {
      * Multiplies two vec4's
      *
      * @param {Vec4 | Number} b the second operand
-     * @param {Vec4} out the receiving vector, defaults to this
+     * @param {Vec4} out the receiving vector, defaults to new vec4()
      * @returns {Vec4} out
      */
     mult(b: Vec4 | number, out?: Vec4): Vec4;
@@ -1260,7 +1273,7 @@ declare class Vec4 extends Float32Array {
      * Divides two vec4's
      *
      * @param {Vec4 | Number} b the second operand
-     * @param {Vec4} out the receiving vector, defaults to this
+     * @param {Vec4} out the receiving vector, defaults to new vec4()
      * @returns {Vec4} out
      */
     div(b: Vec4 | number, out?: Vec4): Vec4;
@@ -1268,7 +1281,7 @@ declare class Vec4 extends Float32Array {
     /**
      * Negates the components of a vec4
      *
-     * @param {Vec4} out the receiving vector, defaults to this
+     * @param {Vec4} out the receiving vector, defaults to new vec4()
      * @returns {Vec4} out
      */
     negate(out?: Vec4): Vec4;
@@ -1276,7 +1289,15 @@ declare class Vec4 extends Float32Array {
     /**
      * Normalizes a vec4
      *
-     * @param {Vec4} out the receiving vector, defaults to this
+     * @param {Vec4} v vector to normalize
+     * @param {Vec4} out the receiving vector, defaults to new vec4()
+     * @returns {Vec4} out
+     */
+    static normalize(v: Vec4, out?: Vec4): Vec4;
+    /**
+     * Normalizes a vec4
+     *
+     * @param {Vec4} out the receiving vector, defaults to new vec4()
      * @returns {Vec4} out
      */
     normalize(out?: Vec4): Vec4;
@@ -1309,35 +1330,35 @@ declare class Vec4 extends Float32Array {
     /**
      * Math.floor the components of a vec4
      *
-     * @param {Vec4} out the receiving vector, defaults to this
+     * @param {Vec4} out the receiving vector, defaults to new vec4()
      * @returns {Vec4} out
      */
     floor(out?: Vec4): Vec4;
     /**
      * Math.round the components of a vec4
      *
-     * @param {Vec4} out the receiving vector, defaults to this
+     * @param {Vec4} out the receiving vector, defaults to new vec4()
      * @returns {Vec4} out
      */
     round(out?: Vec4): Vec4;
     /**
      * Math.ceil the components of a vec4
      *
-     * @param {Vec4} out the receiving vector, defaults to this
+     * @param {Vec4} out the receiving vector, defaults to new vec4()
      * @returns {Vec4} out
      */
     ceil(out?: Vec4): Vec4;
     /**
      * Returns the inverse of the components of a vec4
      *
-     * @param {Vec4} out the receiving vector, defaults to this
+     * @param {Vec4} out the receiving vector, defaults to new vec4()
      * @returns {Vec4} out
      */
     inverse(out?: Vec4): Vec4;
     /**
-     * Creates a new vec4 initialized with values from a vector
+     * Creates a vec4 initialized with values from a vector
      *
-     * @returns {Vec4} a new vec4
+     * @returns {Vec4} a vec4
      */
     clone(): Vec4;
     /**
@@ -1350,7 +1371,7 @@ declare class Vec4 extends Float32Array {
      * Generates a random vector with the given scale
      *
      * @param {Number} scale length of the resulting vector, defaults to 1.0
-     * @param {Vec4} out the receiving vector, defaults to new Vec4()
+     * @param {Vec4} out the receiving vector, defaults to new vec4()
      * @returns {Vec4} out
      */
     static random(scale?: number, out?: Vec4): Vec4;
@@ -1368,7 +1389,7 @@ declare class Vec4 extends Float32Array {
      * @param {Vec4} u the first operand
      * @param {Vec4} v the second operand
      * @param {Vec4} w the third operand
-     * @param {Vec4} out the receiving vector, defaults to new Vec4()
+     * @param {Vec4} out the receiving vector, defaults to new vec4()
      * @returns {Vec4} out
      */
     static cross(u: Vec4, v: Vec4, w: Vec4, out?: Vec4): Vec4;
@@ -1396,7 +1417,7 @@ declare class Vec4 extends Float32Array {
      * @param {Vec4} a the first operand
      * @param {Vec4} b the second operand
      * @param {Number} t interpolation amount, in the range [0-1], between the two inputs
-     * @param {Vec4} out the receiving vector, defaults to new Vec4()
+     * @param {Vec4} out the receiving vector, defaults to new vec4()
      * @returns {Vec4} out
      */
     static lerp(a: Vec4, b: Vec4, t: number, out?: Vec4): Vec4;
@@ -1405,7 +1426,7 @@ declare class Vec4 extends Float32Array {
      *
      * @param {Vec4} a the first operand
      * @param {Vec4} b the second operand
-     * @param {Vec4} out the receiving vector, defaults to new Vec4()
+     * @param {Vec4} out the receiving vector, defaults to new vec4()
      * @returns {Vec4} out
      */
     static max(a: Vec4, b: Vec4, out?: Vec4): Vec4;
@@ -1414,7 +1435,7 @@ declare class Vec4 extends Float32Array {
      *
      * @param {Vec4} a the first operand
      * @param {Vec4} b the second operand
-     * @param {Vec4} out the receiving vector, defaults to new Vec4()
+     * @param {Vec4} out the receiving vector, defaults to new vec4()
      * @returns {Vec4} out
      */
     static min(a: Vec4, b: Vec4, out?: Vec4): Vec4;
@@ -1561,6 +1582,7 @@ interface Vec4 {
     sqrLen: () => number;
     str: () => string;
     transformMat4x4: (m: Mat4, out?: Vec4) => Vec4;
+    normalized: (out?: Vec4) => Vec4;
     x0: Vec2;
     x1: Vec2;
     xx: Vec2;
@@ -4592,7 +4614,7 @@ declare class Vec3 extends Float32Array {
     static get unitZ(): Vec3;
     static get UnitZ(): Vec3;
     /**
-     * Creates a new Vec3
+     * Creates new vec3
      *
      * @param {Number} x X component, defaults to 0
      * @param {Number} y Y component, defaults to 0
@@ -4609,7 +4631,7 @@ declare class Vec3 extends Float32Array {
      * Adds two vec3's
      *
      * @param {Number | Vec3} b the second operand
-     * @param {Vec3} out the receiving vector, defaults to this
+     * @param {Vec3} out the receiving vector, defaults to new vec3()
      * @returns {Vec3} out
      */
     plus(b: number | Vec3, out?: Vec3): Vec3;
@@ -4617,7 +4639,7 @@ declare class Vec3 extends Float32Array {
      * Subtracts two vec3's
      *
      * @param {Number | Vec3} b the second operand
-     * @param {Vec3} out the receiving vector, defaults to this
+     * @param {Vec3} out the receiving vector, defaults to new vec3()
      * @returns {Vec3} out
      */
     minus(b: number | Vec3, out?: Vec3): Vec3;
@@ -4625,7 +4647,7 @@ declare class Vec3 extends Float32Array {
      * Multiplies two vec3's
      *
      * @param {Number | Vec3} b the second operand
-     * @param {Vec3} out the receiving vector, defaults to this
+     * @param {Vec3} out the receiving vector, defaults to new vec3()
      * @returns {Vec3} out
      */
     mult(b: number | Vec3, out?: Vec3): Vec3;
@@ -4633,31 +4655,31 @@ declare class Vec3 extends Float32Array {
      * Divides two vec3's
      *
      * @param {Number | Vec3} b the second operand
-     * @param {Vec3} out the receiving vector, defaults to this
+     * @param {Vec3} out the receiving vector, defaults to new vec3()
      * @returns {Vec3} out
      */
     div(b: number | Vec3, out?: Vec3): Vec3;
     invDiv(b: number | Vec3, out?: Vec3): Vec3;
     /**
-     * Negates the components of a vec3
+     * Negates the components of this vec3
      *
-     * @param {Vec3} out the receiving vector, defaults to this
+     * @param {Vec3} out the receiving vector, defaults to new vec3()
      * @returns {Vec3} out
      */
     negate(out?: Vec3): Vec3;
     unaryPlus(out?: Vec3): Vec3;
     /**
-     * Normalizes a vec3
+     * Normalizes vec3
      *
      * @param {Vec3} v the vector to normalize
-     * @param {Vec3} out the receiving vector, defaults to a new Vec3
+     * @param {Vec3} out the receiving vector, defaults to new vec3
      * @returns {Vec3} out
      */
     static normalize(v: Vec3, out?: Vec3): Vec3;
     /**
-     * Normalizes a vec3
+     * Normalizes this vec3
      *
-     * @param {Vec3} out the receiving vector, defaults to this
+     * @param {Vec3} out the receiving vector, defaults to new vec3()
      * @returns {Vec3} out
      */
     normalize(out?: Vec3): Vec3;
@@ -4676,73 +4698,73 @@ declare class Vec3 extends Float32Array {
      */
     exactEquals(b: Vec3): boolean;
     /**
-     * Calculates the squared length of a vec3
+     * Calculates the squared length of vec3
      *
      * @returns {Number} squared length of a vector
      */
     squaredLength(): number;
     /**
-     * Calculates the length of a vec3
+     * Calculates the length of vec3
      *
      * @returns {Number} length of a vector
      */
     len(): number;
     /**
-     * Returns a new vec3 with each component floored
+     * Returns vec3 with each component floored
      *
      * @param {Vec3} v the vector to floor
      * @returns {Vec3} a new floored vector
      */
     static floor(v: Vec3, out?: Vec3): Vec3;
     /**
-     * Returns a new vec3 with each component rounded
+     * Returns vec3 with each component rounded
      *
      * @param {Vec3} v the vector to round
      * @returns {Vec3} a new rounded vector
      */
     static round(v: Vec3, out?: Vec3): Vec3;
     /**
-     * Returns a new vec3 with each component ceiled
+     * Returns vec3 with each component ceiled
      *
      * @param {Vec3} v the vector to ceil
      * @returns {Vec3} a new ceiled vector
      */
     static ceil(v: Vec3, out?: Vec3): Vec3;
     /**
-     * Floors each component of a vec3
+     * Floors each component of vec3
      *
      * @returns {Vec3} this
      */
     floor(out?: Vec3): Vec3;
     /**
-     * Rounds each component of a vec3
+     * Rounds each component of vec3
      *
      * @returns {Vec3} this
      */
     round(out?: Vec3): Vec3;
     /**
-     * Ceils each component of a vec3
+     * Ceils each component of vec3
      *
      * @returns {Vec3} this
      */
     ceil(out?: Vec3): Vec3;
     /**
-     * Returns the inverse of a vec3
+     * Returns the inverse of vec3
      *
      * @param {Vec3} v the source vector
      * @returns {Vec3} a new inverted vector
      */
     static inverse(v: Vec3, out?: Vec3): Vec3;
     /**
-     * Inverts a vec3 component-wise
+     * Inverts vec3 component-wise
      *
      * @returns {Vec3} this
      */
     inverse(out?: Vec3): Vec3;
     /**
-     * Creates a new vec3 initialized with values from a vector
+     * Creates vec3 initialized with values from a vector
      *
-     * @returns {Vec3} a new Vec3
+     * @returns {Vec3} vec3
      */
     clone(): Vec3;
     /**
@@ -4779,7 +4801,7 @@ declare class Vec3 extends Float32Array {
      *
      * @param {Vec3} a the first operand
      * @param {Vec3} b the second operand
-     * @param {Vec3} out the receiving vector, defaults to a new Vec3
+     * @param {Vec3} out the receiving vector, defaults to new vec3
      * @returns {Vec3} out
      */
     static cross(a: Vec3, b: Vec3, out?: Vec3): Vec3;
@@ -4807,7 +4829,7 @@ declare class Vec3 extends Float32Array {
      * @param {Vec3} a the first operand
      * @param {Vec3} b the second operand
      * @param {Number} t interpolation amount, in the range [0-1], between the two inputs
-     * @param {Vec3} out the receiving vector, defaults to a new Vec3
+     * @param {Vec3} out the receiving vector, defaults to new vec3
      * @returns {Vec3} out
      */
     static lerp(a: Vec3, b: Vec3, t: number, out?: Vec3): Vec3;
@@ -4817,7 +4839,7 @@ declare class Vec3 extends Float32Array {
      * @param {Vec3} a the first operand
      * @param {Vec3} b the second operand
      * @param {Number} t interpolation amount, in the range [0-1], between the two inputs
-     * @param {Vec3} out the receiving vector, defaults to a new Vec3
+     * @param {Vec3} out the receiving vector, defaults to new vec3
      * @returns {Vec3} out
      */
     static slerp(a: Vec3, b: Vec3, t: number, out?: Vec3): Vec3;
@@ -4868,40 +4890,40 @@ declare class Vec3 extends Float32Array {
      */
     static smoothstep(edge0: Vec3 | number, edge1: Vec3 | number, v: Vec3, out?: Vec3): Vec3;
     /**
-     * Rotates a vec3 around the X axis
+     * Rotates vec3 around the X axis
      *
      * @param {Vec3} v the vector to rotate
      * @param {Number} rad the angle of rotation in radians
-     * @param {Vec3} origin the origin of the rotation, defaults to vec3(0)
+     * @param {Vec3} origin the origin of the rotation, defaults to vec3(0, 0, 0)
      * @returns {Vec3} a new rotated vector
      */
     static rotateX(v: Vec3, rad: number, origin?: Vec3, out?: Vec3): Vec3;
     /**
-     * Rotates a vec3 around the X axis
+     * Rotates vec3 around the X axis
      *
      * @param {Number} rad the angle of rotation in radians
-     * @param {Vec3} origin the origin of the rotation, defaults to vec3(0)
+     * @param {Vec3} origin the origin of the rotation, defaults to vec3(0, 0, 0)
      * @returns {Vec3} a rotated vector
      */
     rotateX(rad: number, origin?: Vec3, out?: Vec3): Vec3;
     /**
-     * Rotates a vec3 around the Y axis
+     * Rotates vec3 around the Y axis
      *
      * @param {Vec3} v the vector to rotate
      * @param {Number} rad the angle of rotation in radians
-     * @param {Vec3} origin the origin of the rotation, defaults to vec3(0)
+     * @param {Vec3} origin the origin of the rotation, defaults to vec3(0, 0, 0)
      * @returns {Vec3} a rotated vector
      */
     static rotateY(v: Vec3, rad: number, origin?: Vec3, out?: Vec3): Vec3;
     /**
-     * Rotates a vec3 around the Y axis
+     * Rotates vec3 around the Y axis
      *
      * @param {Number} rad the angle of rotation in radians
-     * @param {Vec3} origin the origin of the rotation, defaults to vec3(0)
+     * @param {Vec3} origin the origin of the rotation, defaults to vec3(0, 0, 0)
      */
     rotateY(rad: number, origin?: Vec3, out?: Vec3): Vec3;
     /**
-     * Rotates a vec3 around the Z axis
+     * Rotates vec3 around the Z axis
      *
      * @param {Vec3} v the vector to rotate
      * @param {Number} rad the angle of rotation in radians
@@ -4910,10 +4932,10 @@ declare class Vec3 extends Float32Array {
      */
     static rotateZ(v: Vec3, rad: number, origin?: Vec3, out?: Vec3): Vec3;
     /**
-     * Rotates a vec3 around the Z axis
+     * Rotates vec3 around the Z axis
      *
      * @param {Number} rad the angle of rotation in radians
-     * @param {Vec3} origin the origin of the rotation, defaults to vec3(0)
+     * @param {Vec3} origin the origin of the rotation, defaults to vec3(0, 0, 0)
      */
     rotateZ(rad: number, origin?: Vec3, out?: Vec3): Vec3;
     /**
@@ -4944,7 +4966,7 @@ declare class Vec3 extends Float32Array {
      * @param {Vec3} a the first operand
      * @param {Vec3} b the second operand
      * @param {Number} scale the amount to scale b by before adding
-     * @param {Vec3} out the receiving vector, defaults to a new Vec3
+     * @param {Vec3} out the receiving vector, defaults to new vec3
      * @returns {Vec3} out
      */
     static scaleAndAdd(a: Vec3, b: Vec3, scale: number, out?: Vec3): Vec3;
@@ -4953,7 +4975,7 @@ declare class Vec3 extends Float32Array {
      *
      * @param {Vec3} I the incident vector
      * @param {Vec3} N the surface normal
-     * @param {Vec3} out the receiving vector, defaults to a new Vec3
+     * @param {Vec3} out the receiving vector, defaults to new vec3
      * @returns {Vec3} out
      */
     static reflect(I: Vec3, N: Vec3, out?: Vec3): Vec3;
@@ -4963,7 +4985,7 @@ declare class Vec3 extends Float32Array {
      * @param {Vec3} I the incident vector
      * @param {Vec3} N the surface normal
      * @param {Number} eta the ratio of indices of refraction
-     * @param {Vec3} out the receiving vector, defaults to a new Vec3
+     * @param {Vec3} out the receiving vector, defaults to new vec3
      * @returns {Vec3} out
      */
     static refract(I: Vec3, N: Vec3, eta: number, out?: Vec3): Vec3;
@@ -4973,7 +4995,7 @@ declare class Vec3 extends Float32Array {
      * @param {Vec3} N the vector to orient
      * @param {Vec3} I the incident vector
      * @param {Vec3} Nref the reference vector
-     * @param {Vec3} out the receiving vector, defaults to a new Vec3
+     * @param {Vec3} out the receiving vector, defaults to new vec3
      * @returns {Vec3} out
      */
     static faceforward(N: Vec3, I: Vec3, Nref: Vec3, out?: Vec3): Vec3;
@@ -4983,7 +5005,7 @@ declare class Vec3 extends Float32Array {
      * @param {Vec3} p1 the first vertex
      * @param {Vec3} p2 the second vertex
      * @param {Vec3} p3 the third vertex
-     * @param {Vec3} out the receiving vector, defaults to a new Vec3
+     * @param {Vec3} out the receiving vector, defaults to new vec3
      * @returns {Vec3} out
      */
     static triangleNormal(p1: Vec3, p2: Vec3, p3: Vec3, out?: Vec3): Vec3;
@@ -4992,7 +5014,7 @@ declare class Vec3 extends Float32Array {
      *
      * @param {Vec3} a the vector to project
      * @param {Vec3} b the vector to project onto
-     * @param {Vec3} out the receiving vector, defaults to a new Vec3
+     * @param {Vec3} out the receiving vector, defaults to new vec3
      * @returns {Vec3} out
      */
     static project(a: Vec3, b: Vec3, out?: Vec3): Vec3;
@@ -5010,14 +5032,14 @@ declare class Vec3 extends Float32Array {
      *
      * @param {Vec3} b the second operand
      * @param {Number} scale the amount to scale b by before adding
-     * @param {Vec3} out the receiving vector, defaults to this
+     * @param {Vec3} out the receiving vector, defaults to new vec3()
      * @returns {Vec3} out
      */
     scaleAndAdd(b: Vec3, scale: number, out?: Vec3): Vec3;
     /**
-     * Returns a vec3 with each component set to its absolute value
+     * Returns vec3 with each component set to its absolute value
      *
-     * @param {Vec3} out the receiving vector, defaults to this
+     * @param {Vec3} out the receiving vector, defaults to new vec3()
      * @returns {Vec3} out
      */
     abs(out?: Vec3): Vec3;
@@ -5026,7 +5048,7 @@ declare class Vec3 extends Float32Array {
      *
      * @param {Vec3 | number} min the lower bound (per-component or scalar)
      * @param {Vec3 | number} max the upper bound (per-component or scalar)
-     * @param {Vec3} out the receiving vector, defaults to this
+     * @param {Vec3} out the receiving vector, defaults to new vec3()
      * @returns {Vec3} out
      */
     clamp(min: Vec3 | number, max: Vec3 | number, out?: Vec3): Vec3;
@@ -5035,7 +5057,7 @@ declare class Vec3 extends Float32Array {
      *
      * @param {Vec3} b the second operand
      * @param {Vec3 | number} t interpolation amount (per-component or scalar)
-     * @param {Vec3} out the receiving vector, defaults to this
+     * @param {Vec3} out the receiving vector, defaults to new vec3()
      * @returns {Vec3} out
      */
     mix(b: Vec3, t: Vec3 | number, out?: Vec3): Vec3;
@@ -5043,7 +5065,7 @@ declare class Vec3 extends Float32Array {
      * Generates a step function by comparing this vector to edge.
      *
      * @param {Vec3 | number} edge the edge value (per-component or scalar)
-     * @param {Vec3} out the receiving vector, defaults to this
+     * @param {Vec3} out the receiving vector, defaults to new vec3()
      * @returns {Vec3} out
      */
     step(edge: Vec3 | number, out?: Vec3): Vec3;
@@ -5052,28 +5074,28 @@ declare class Vec3 extends Float32Array {
      *
      * @param {Vec3 | number} edge0 the lower edge (per-component or scalar)
      * @param {Vec3 | number} edge1 the upper edge (per-component or scalar)
-     * @param {Vec3} out the receiving vector, defaults to this
+     * @param {Vec3} out the receiving vector, defaults to new vec3()
      * @returns {Vec3} out
      */
     smoothstep(edge0: Vec3 | number, edge1: Vec3 | number, out?: Vec3): Vec3;
     /**
      * Returns the fractional part of each component.
      *
-     * @param {Vec3} out the receiving vector, defaults to this
+     * @param {Vec3} out the receiving vector, defaults to new vec3()
      * @returns {Vec3} out
      */
     fract(out?: Vec3): Vec3;
     /**
      * Returns the sign of each component (-1, 0, or 1).
      *
-     * @param {Vec3} out the receiving vector, defaults to this
+     * @param {Vec3} out the receiving vector, defaults to new vec3()
      * @returns {Vec3} out
      */
     sign(out?: Vec3): Vec3;
     /**
      * Clamps each component to [0, 1].
      *
-     * @param {Vec3} out the receiving vector, defaults to this
+     * @param {Vec3} out the receiving vector, defaults to new vec3()
      * @returns {Vec3} out
      */
     saturate(out?: Vec3): Vec3;
@@ -5081,7 +5103,7 @@ declare class Vec3 extends Float32Array {
      * Transforms this vec3 with a Mat3
      *
      * @param {Mat3} m the 3x3 matrix to transform with
-     * @param {Vec3} out the receiving vector, defaults to this
+     * @param {Vec3} out the receiving vector, defaults to new vec3()
      * @returns {Vec3} out
      */
     transformMat3(m: Mat3, out?: Vec3): Vec3;
@@ -5089,7 +5111,7 @@ declare class Vec3 extends Float32Array {
      * Transforms this vec3 with a Mat4 (as a point, w=1)
      *
      * @param {Mat4} m the 4x4 matrix to transform with
-     * @param {Vec3} out the receiving vector, defaults to this
+     * @param {Vec3} out the receiving vector, defaults to new vec3()
      * @returns {Vec3} out
      */
     transformMat4(m: Mat4, out?: Vec3): Vec3;
@@ -5097,7 +5119,7 @@ declare class Vec3 extends Float32Array {
      * Transforms this vec3 with a quaternion
      *
      * @param {Quat} q the quaternion to transform with
-     * @param {Vec3} out the receiving vector, defaults to this
+     * @param {Vec3} out the receiving vector, defaults to new vec3()
      * @returns {Vec3} out
      */
     transformQuat(q: Quat, out?: Vec3): Vec3;
@@ -5117,6 +5139,7 @@ interface Vec3 {
     str: () => string;
     transformMat3x3: (m: Mat3, out?: Vec3) => Vec3;
     transformMat4x4: (m: Mat4, out?: Vec3) => Vec3;
+    normalized: (out?: Vec3) => Vec3;
     x0: Vec2;
     x1: Vec2;
     xx: Vec2;
@@ -8155,21 +8178,21 @@ declare class Mat2 extends Float32Array {
     /**
      * Transposes a mat2
      *
-     * @param {Mat2} out the receiving matrix, defaults to this
+     * @param {Mat2} out the receiving matrix, defaults to new mat2()
      * @returns {Mat2} out
      */
     transpose(out?: Mat2): Mat2;
     /**
      * Inverts a mat2
      *
-     * @param {Mat2} out the receiving matrix, defaults to this
+     * @param {Mat2} out the receiving matrix, defaults to new mat2()
      * @returns {Mat2} out or null if the matrix is not invertible
      */
     invert(out?: Mat2): Mat2 | null;
     /**
      * Calculates the adjugate of a mat2
      *
-     * @param {Mat2} out the receiving matrix, defaults to this
+     * @param {Mat2} out the receiving matrix, defaults to new mat2()
      * @returns {Mat2} out
      */
     adjoint(out?: Mat2): Mat2;
@@ -8183,7 +8206,7 @@ declare class Mat2 extends Float32Array {
      * Rotates a mat2 by the given angle
      *
      * @param {Number} rad the angle to rotate the matrix by
-     * @param {Mat2} out the receiving matrix, defaults to this
+     * @param {Mat2} out the receiving matrix, defaults to new mat2()
      * @returns {Mat2} out
      */
     rotate(rad: number, out?: Mat2): Mat2;
@@ -8191,7 +8214,7 @@ declare class Mat2 extends Float32Array {
      * Scales a mat2 by the dimensions in the given Vec2
      *
      * @param {Vec2} v the Vec2 to scale the matrix by
-     * @param {Mat2} out the receiving matrix, defaults to this
+     * @param {Mat2} out the receiving matrix, defaults to new mat2()
      * @returns {Mat2} out
      */
     scale(v: Vec2, out?: Mat2): Mat2;
@@ -8199,7 +8222,7 @@ declare class Mat2 extends Float32Array {
      * Creates a Mat2 from a given angle
      *
      * @param {Number} rad the angle to rotate the matrix by
-     * @param {Mat2} out the receiving matrix, defaults to new Mat2()
+     * @param {Mat2} out the receiving matrix, defaults to mat2()
      * @returns {Mat2} out
      */
     static fromRotation(rad: number, out?: Mat2): Mat2;
@@ -8207,7 +8230,7 @@ declare class Mat2 extends Float32Array {
      * Creates a Mat2 from a scaling vector
      *
      * @param {Vec2} v scaling vector
-     * @param {Mat2} out the receiving matrix, defaults to new Mat2()
+     * @param {Mat2} out the receiving matrix, defaults to mat2()
      * @returns {Mat2} out
      */
     static fromScaling(v: Vec2, out?: Mat2): Mat2;
@@ -8233,7 +8256,7 @@ declare class Mat2 extends Float32Array {
      * Adds two Mat2's
      *
      * @param {Mat2} b the second operand
-     * @param {Mat2} out the receiving matrix, defaults to this
+     * @param {Mat2} out the receiving matrix, defaults to new mat2()
      * @returns {Mat2} out
      */
     plus(b: Mat2, out?: Mat2): Mat2;
@@ -8241,7 +8264,7 @@ declare class Mat2 extends Float32Array {
      * Subtracts matrix b from a mat2
      *
      * @param {Mat2} b the second operand
-     * @param {Mat2} out the receiving matrix, defaults to this
+     * @param {Mat2} out the receiving matrix, defaults to new mat2()
      * @returns {Mat2} out
      */
     minus(b: Mat2, out?: Mat2): Mat2;
@@ -8249,7 +8272,7 @@ declare class Mat2 extends Float32Array {
      * Multiplies a mat2 by another Mat2
      *
      * @param {Mat2} b the second operand
-     * @param {Mat2} out the receiving matrix, defaults to this
+     * @param {Mat2} out the receiving matrix, defaults to new mat2()
      * @returns {Mat2} out
      */
     multiply(b: Vec2): Vec2;
@@ -8272,7 +8295,7 @@ declare class Mat2 extends Float32Array {
      * Multiplies each element of a mat2 by a scalar value
      *
      * @param {Number} b amount to scale the matrix's elements by
-     * @param {Mat2} out the receiving matrix, defaults to this
+     * @param {Mat2} out the receiving matrix, defaults to new mat2()
      * @returns {Mat2} out
      */
     scaleScalar(b: number, out?: Mat2): Mat2;
@@ -8320,7 +8343,7 @@ declare class Vec2 extends Float32Array {
      * Adds two vec2's
      *
      * @param {Vec2 | Number} b the second operand
-     * @param {Vec2} out the receiving vector, defaults to this
+     * @param {Vec2} out the receiving vector, defaults to new vec2()
      * @returns {Vec2} out
      */
     plus(b: Vec2 | number, out?: Vec2): Vec2;
@@ -8328,7 +8351,7 @@ declare class Vec2 extends Float32Array {
      * Subtracts vector b from a vector
      *
      * @param {Vec2 | Number} b the second operand
-     * @param {Vec2} out the receiving vector, defaults to this
+     * @param {Vec2} out the receiving vector, defaults to new vec2()
      * @returns {Vec2} out
      */
     minus(b: Vec2 | number, out?: Vec2): Vec2;
@@ -8336,7 +8359,7 @@ declare class Vec2 extends Float32Array {
      * Multiplies two vec2's component-wise
      *
      * @param {Vec2 | Number} b the second operand
-     * @param {Vec2} out the receiving vector, defaults to this
+     * @param {Vec2} out the receiving vector, defaults to new vec2()
      * @returns {Vec2} out
      */
     mult(b: Vec2 | number, out?: Vec2): Vec2;
@@ -8344,7 +8367,7 @@ declare class Vec2 extends Float32Array {
      * Divides two vec2's component-wise
      *
      * @param {Vec2 | Number} b the second operand
-     * @param {Vec2} out the receiving vector, defaults to this
+     * @param {Vec2} out the receiving vector, defaults to new vec2()
      * @returns {Vec2} out
      */
     div(b: Vec2 | number, out?: Vec2): Vec2;
@@ -8352,7 +8375,7 @@ declare class Vec2 extends Float32Array {
      * Divides this vector by argument
      *
      * @param {Vec2 | Number} a the first operand
-     * @param {Vec2} out the receiving vector, defaults to this
+     * @param {Vec2} out the receiving vector, defaults to new vec2()
      * @returns {Vec2} out
      */
     invDiv(a: Vec2 | number, out?: Vec2): Vec2;
@@ -8360,21 +8383,29 @@ declare class Vec2 extends Float32Array {
      * Remainder of this divided by argument
      *
      * @param {Vec2 | Number} a the first operand
-     * @param {Vec2} out the receiving vector, defaults to this
+     * @param {Vec2} out the receiving vector, defaults to new vec2()
      * @returns {Vec2} out
      */
     rem(b: Vec2 | number, out?: Vec2): Vec2;
     /**
      * Negates the components of a vec2
      *
-     * @param {Vec2} out the receiving vector, defaults to this
+     * @param {Vec2} out the receiving vector, defaults to new vec2()
      * @returns {Vec2} out
      */
     negate(out?: Vec2): Vec2;
     unaryPlus(out?: Vec2): Vec2;
     /**
-     * Normalize a vector to unit length. Modifies in-place.
+     * Normalize a vector to unit length.
      *
+     * @param {Vec2} out the receiving vector, defaults to new vec2()
+     * @returns {Vec2} this
+     */
+    static normalize(v: Vec2, out?: Vec2): Vec2;
+    /**
+     * Normalize a vector to unit length.
+     *
+     * @param {Vec2} out the receiving vector, defaults to new vec2()
      * @returns {Vec2} this
      */
     normalize(out?: Vec2): Vec2;
@@ -8407,28 +8438,28 @@ declare class Vec2 extends Float32Array {
     /**
      * Math.floor the components of a vec2
      *
-     * @param {Vec2} out the receiving vector, defaults to this
+     * @param {Vec2} out the receiving vector, defaults to new vec2()
      * @returns {Vec2} out
      */
     floor(out?: Vec2): Vec2;
     /**
      * Math.round the components of a vec2
      *
-     * @param {Vec2} out the receiving vector, defaults to this
+     * @param {Vec2} out the receiving vector, defaults to new vec2()
      * @returns {Vec2} out
      */
     round(out?: Vec2): Vec2;
     /**
      * Math.ceil the components of a vec2
      *
-     * @param {Vec2} out the receiving vector, defaults to this
+     * @param {Vec2} out the receiving vector, defaults to new vec2()
      * @returns {Vec2} out
      */
     ceil(out?: Vec2): Vec2;
     /**
      * Returns the inverse of the components (1/x, 1/y)
      *
-     * @param {Vec2} out the receiving vector, defaults to this
+     * @param {Vec2} out the receiving vector, defaults to new vec2()
      * @returns {Vec2} out
      */
     inverse(out?: Vec2): Vec2;
@@ -8442,8 +8473,8 @@ declare class Vec2 extends Float32Array {
      * Rotates a vec2 around an origin point
      *
      * @param {Number} rad the angle of rotation in radians
-     * @param {Vec2} origin the origin of the rotation, defaults to ZERO
-     * @param {Vec2} out the receiving vector, defaults to this
+     * @param {Vec2} origin the origin of the rotation, defaults to vec2(0, 0)
+     * @param {Vec2} out the receiving vector, defaults to new vec2()
      * @returns {Vec2} out
      */
     rotate(rad?: number, origin?: Vec2, out?: Vec2): Vec2;
@@ -8575,28 +8606,28 @@ declare class Vec2 extends Float32Array {
      *
      * @param {Vec2} b the second operand
      * @param {Number} scale the amount to scale b by before adding
-     * @param {Vec2} out the receiving vector, defaults to this
+     * @param {Vec2} out the receiving vector, defaults to new vec2()
      * @returns {Vec2} out
      */
     scaleAndAdd(b: Vec2, scale: number, out?: Vec2): Vec2;
     /**
      * Component-wise absolute value
      *
-     * @param {Vec2} out the receiving vector, defaults to this
+     * @param {Vec2} out the receiving vector, defaults to new vec2()
      * @returns {Vec2} out
      */
     abs(out?: Vec2): Vec2;
     /**
      * Component-wise sign
      *
-     * @param {Vec2} out the receiving vector, defaults to this
+     * @param {Vec2} out the receiving vector, defaults to new vec2()
      * @returns {Vec2} out
      */
     sign(out?: Vec2): Vec2;
     /**
      * Component-wise fractional part (x - floor(x))
      *
-     * @param {Vec2} out the receiving vector, defaults to this
+     * @param {Vec2} out the receiving vector, defaults to new vec2()
      * @returns {Vec2} out
      */
     fract(out?: Vec2): Vec2;
@@ -8605,14 +8636,14 @@ declare class Vec2 extends Float32Array {
      *
      * @param {Vec2 | Number} min the lower bound
      * @param {Vec2 | Number} max the upper bound
-     * @param {Vec2} out the receiving vector, defaults to this
+     * @param {Vec2} out the receiving vector, defaults to new vec2()
      * @returns {Vec2} out
      */
     clamp(min: Vec2 | number, max: Vec2 | number, out?: Vec2): Vec2;
     /**
      * Clamp components to [0, 1]
      *
-     * @param {Vec2} out the receiving vector, defaults to this
+     * @param {Vec2} out the receiving vector, defaults to new vec2()
      * @returns {Vec2} out
      */
     saturate(out?: Vec2): Vec2;
@@ -8621,7 +8652,7 @@ declare class Vec2 extends Float32Array {
      *
      * @param {Vec2} b the second operand
      * @param {Vec2 | Number} t interpolation factor (scalar or per-component)
-     * @param {Vec2} out the receiving vector, defaults to this
+     * @param {Vec2} out the receiving vector, defaults to new vec2()
      * @returns {Vec2} out
      */
     mix(b: Vec2, t: Vec2 | number, out?: Vec2): Vec2;
@@ -8629,7 +8660,7 @@ declare class Vec2 extends Float32Array {
      * Component-wise step function
      *
      * @param {Vec2 | Number} edge the edge threshold
-     * @param {Vec2} out the receiving vector, defaults to this
+     * @param {Vec2} out the receiving vector, defaults to new vec2()
      * @returns {Vec2} out
      */
     step(edge: Vec2 | number, out?: Vec2): Vec2;
@@ -8638,7 +8669,7 @@ declare class Vec2 extends Float32Array {
      *
      * @param {Vec2 | Number} edge0 the lower edge
      * @param {Vec2 | Number} edge1 the upper edge
-     * @param {Vec2} out the receiving vector, defaults to this
+     * @param {Vec2} out the receiving vector, defaults to new vec2()
      * @returns {Vec2} out
      */
     smoothstep(edge0: Vec2 | number, edge1: Vec2 | number, out?: Vec2): Vec2;
@@ -8646,7 +8677,7 @@ declare class Vec2 extends Float32Array {
      * Transforms the vec2 with a Mat2 (column-major 2x2)
      *
      * @param {Mat2} m matrix to transform with
-     * @param {Vec2} out the receiving vector, defaults to this
+     * @param {Vec2} out the receiving vector, defaults to new vec2()
      * @returns {Vec2} out
      */
     transformMat2(m: Mat2, out?: Vec2): Vec2;
@@ -8654,7 +8685,7 @@ declare class Vec2 extends Float32Array {
      * Transforms the vec2 with a Mat2x3 (2D affine transform)
      *
      * @param {Mat2x3} m matrix to transform with
-     * @param {Vec2} out the receiving vector, defaults to this
+     * @param {Vec2} out the receiving vector, defaults to new vec2()
      * @returns {Vec2} out
      */
     transformMat2x3(m: Mat2x3, out?: Vec2): Vec2;
@@ -8662,7 +8693,7 @@ declare class Vec2 extends Float32Array {
      * Transforms the vec2 with a Mat3 (column-major 3x3)
      *
      * @param {Mat3} m matrix to transform with
-     * @param {Vec2} out the receiving vector, defaults to this
+     * @param {Vec2} out the receiving vector, defaults to new vec2()
      * @returns {Vec2} out
      */
     transformMat3(m: Mat3, out?: Vec2): Vec2;
@@ -8670,7 +8701,7 @@ declare class Vec2 extends Float32Array {
      * Transforms the vec2 with a Mat4 (column-major 4x4)
      *
      * @param {Mat4} m matrix to transform with
-     * @param {Vec2} out the receiving vector, defaults to this
+     * @param {Vec2} out the receiving vector, defaults to new vec2()
      * @returns {Vec2} out
      */
     transformMat4(m: Mat4, out?: Vec2): Vec2;
@@ -8712,6 +8743,7 @@ interface Vec2 {
     transformMat2d: (m: Mat2x3, out?: Vec2) => Vec2;
     transformMat3x3: (m: Mat3, out?: Vec2) => Vec2;
     transformMat4x4: (m: Mat4, out?: Vec2) => Vec2;
+    normalized: (out?: Vec2) => Vec2;
     x0: Vec2;
     x1: Vec2;
     xx: Vec2;
@@ -11825,7 +11857,7 @@ declare class Quat2 extends Float32Array {
      * Multiply two dual quaternions
      *
      * @param {Quat2} b the second operand
-     * @param {Quat2} out the receiving dual quaternion, defaults to this
+     * @param {Quat2} out the receiving dual quaternion, defaults to new quat2()
      * @returns {Quat2} out
      */
     multiply: (b: Quat2, out?: Quat2) => Quat2;
@@ -11833,21 +11865,21 @@ declare class Quat2 extends Float32Array {
      * Translate by a Vec3
      *
      * @param {Vec3} v the translation vector
-     * @param {Quat2} out the receiving dual quaternion, defaults to this
+     * @param {Quat2} out the receiving dual quaternion, defaults to new quat2()
      * @returns {Quat2} out
      */
     translate(v: Vec3, out?: Quat2): Quat2;
     /**
      * Calculates the conjugate of a dual quaternion
      *
-     * @param {Quat2} out the receiving dual quaternion, defaults to this
+     * @param {Quat2} out the receiving dual quaternion, defaults to new quat2()
      * @returns {Quat2} out
      */
     conjugate(out?: Quat2): Quat2;
     /**
      * Calculates the inverse of a dual quaternion
      *
-     * @param {Quat2} out the receiving dual quaternion, defaults to this
+     * @param {Quat2} out the receiving dual quaternion, defaults to new quat2()
      * @returns {Quat2} out
      */
     invert(out?: Quat2): Quat2;
@@ -11866,7 +11898,15 @@ declare class Quat2 extends Float32Array {
     /**
      * Normalize the dual quaternion
      *
-     * @param {Quat2} out the receiving dual quaternion, defaults to this
+     * @param {Quat2} q the quaternion to normalize
+     * @param {Quat2} out the receiving dual quaternion, defaults to new quat2()
+     * @returns {Quat2} out
+     */
+    static normalize(q: Quat2, out?: Quat2): Quat2;
+    /**
+     * Normalize the dual quaternion
+     *
+     * @param {Quat2} out the receiving dual quaternion, defaults to new quat2()
      * @returns {Quat2} out
      */
     normalize(out?: Quat2): Quat2;
@@ -11892,7 +11932,7 @@ declare class Quat2 extends Float32Array {
      * Adds two dual quaternions
      *
      * @param {Quat2} b the second operand
-     * @param {Quat2} out the receiving dual quaternion, defaults to this
+     * @param {Quat2} out the receiving dual quaternion, defaults to new quat2()
      * @returns {Quat2} out
      */
     plus(b: Quat2, out?: Quat2): Quat2;
@@ -11900,7 +11940,7 @@ declare class Quat2 extends Float32Array {
      * Scales a dual quaternion by a scalar
      *
      * @param {Number} s the scalar to scale by
-     * @param {Quat2} out the receiving dual quaternion, defaults to this
+     * @param {Quat2} out the receiving dual quaternion, defaults to new quat2()
      * @returns {Quat2} out
      */
     scale(s: number, out?: Quat2): Quat2;
@@ -11929,8 +11969,10 @@ interface Quat2 {
     sqrLen: () => number;
     str: () => string;
     add: (b: Quat2, out?: Quat2) => Quat2;
+    normalized: (out?: Quat2) => Quat2;
 }
-declare const quat2: ((x1?: number, y1?: number, z1?: number, w1?: number, x2?: number, y2?: number, z2?: number, w2?: number) => Quat2) & typeof Quat2;
+declare const createQuat2: (x1?: number, y1?: number, z1?: number, w1?: number, x2?: number, y2?: number, z2?: number, w2?: number) => Quat2;
+declare const quat2: typeof createQuat2 & typeof Quat2;
 
 type Vec = Vec2 | Vec3 | Vec4;
 type Vector = Vec;