glmaths 0.0.2 → 0.0.4

package/dist/esm/glmaths.js

@@ -3,20 +3,20 @@
  * @extends Float32Array
  */
 class Vec3 extends Float32Array {
-    static get zero() { return new Vec3(0, 0, 0); }
-    static get Zero() { return new Vec3(0, 0, 0); }
-    static get ZERO() { return new Vec3(0, 0, 0); }
-    static get one() { return new Vec3(1, 1, 1); }
-    static get One() { return new Vec3(1, 1, 1); }
-    static get ONE() { return new Vec3(1, 1, 1); }
-    static get unitX() { return new Vec3(1, 0, 0); }
-    static get UnitX() { return new Vec3(1, 0, 0); }
-    static get unitY() { return new Vec3(0, 1, 0); }
-    static get UnitY() { return new Vec3(0, 1, 0); }
-    static get unitZ() { return new Vec3(0, 0, 1); }
-    static get UnitZ() { return new Vec3(0, 0, 1); }
-    /**
-     * Creates a new Vec3
+    static get zero() { return vec3(0, 0, 0); }
+    static get Zero() { return vec3(0, 0, 0); }
+    static get ZERO() { return vec3(0, 0, 0); }
+    static get one() { return vec3(1, 1, 1); }
+    static get One() { return vec3(1, 1, 1); }
+    static get ONE() { return vec3(1, 1, 1); }
+    static get unitX() { return vec3(1, 0, 0); }
+    static get UnitX() { return vec3(1, 0, 0); }
+    static get unitY() { return vec3(0, 1, 0); }
+    static get UnitY() { return vec3(0, 1, 0); }
+    static get unitZ() { return vec3(0, 0, 1); }
+    static get UnitZ() { return vec3(0, 0, 1); }
+    /**
+     * Creates new vec3
      *
      * @param {Number} x X component, defaults to 0
      * @param {Number} y Y component, defaults to 0
@@ -38,10 +38,10 @@ 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, out = index.ALWAYS_COPY ? new Vec3() : this) {
+    plus(b, out = index.ALWAYS_COPY ? vec3() : this) {
         if (typeof b === 'number') {
             out[0] = this[0] + b;
             out[1] = this[1] + b;
@@ -58,10 +58,10 @@ 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, out = index.ALWAYS_COPY ? new Vec3() : this) {
+    minus(b, out = index.ALWAYS_COPY ? vec3() : this) {
         if (typeof b === 'number') {
             out[0] = this[0] - b;
             out[1] = this[1] - b;
@@ -78,10 +78,10 @@ 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, out = index.ALWAYS_COPY ? new Vec3() : this) {
+    mult(b, out = index.ALWAYS_COPY ? vec3() : this) {
         if (typeof b === 'number') {
             out[0] = this[0] * b;
             out[1] = this[1] * b;
@@ -98,10 +98,10 @@ 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, out = index.ALWAYS_COPY ? new Vec3() : this) {
+    div(b, out = index.ALWAYS_COPY ? vec3() : this) {
         if (typeof b === 'number') {
             out[0] = this[0] / b;
             out[1] = this[1] / b;
@@ -114,7 +114,7 @@ class Vec3 extends Float32Array {
         }
         return out;
     }
-    invDiv(b, out = index.ALWAYS_COPY ? new Vec3() : this) {
+    invDiv(b, out = index.ALWAYS_COPY ? vec3() : this) {
         if (typeof b === 'number') {
             out[0] = b / this[0];
             out[1] = b / this[1];
@@ -128,18 +128,18 @@ class Vec3 extends Float32Array {
         return out;
     }
     /**
-     * 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 = index.ALWAYS_COPY ? new Vec3() : this) {
+    negate(out = index.ALWAYS_COPY ? vec3() : this) {
         out[0] = -this[0];
         out[1] = -this[1];
         out[2] = -this[2];
         return out;
     }
-    unaryPlus(out = index.ALWAYS_COPY ? new Vec3() : this) {
+    unaryPlus(out = index.ALWAYS_COPY ? vec3() : this) {
         if (!out.equals(this)) {
             out[0] = this[0];
             out[1] = this[1];
@@ -148,13 +148,13 @@ class Vec3 extends Float32Array {
         return out;
     }
     /**
-     * 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, out = new Vec3()) {
+    static normalize(v, out = vec3()) {
         const x = v[0], y = v[1], z = v[2];
         let len = x * x + y * y + z * z;
         if (len > 0)
@@ -165,12 +165,12 @@ class Vec3 extends Float32Array {
         return out;
     }
     /**
-     * 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 = index.ALWAYS_COPY ? new Vec3() : this) {
+    normalize(out = index.ALWAYS_COPY ? vec3() : this) {
         const x = this[0], y = this[1], z = this[2];
         let len = x * x + y * y + z * z;
         if (len > 0)
@@ -201,7 +201,7 @@ class Vec3 extends Float32Array {
         return this[0] === b[0] && this[1] === b[1] && this[2] === b[2];
     }
     /**
-     * Calculates the squared length of a vec3
+     * Calculates the squared length of vec3
      *
      * @returns {Number} squared length of a vector
      */
@@ -210,7 +210,7 @@ class Vec3 extends Float32Array {
         return x * x + y * y + z * z;
     }
     /**
-     * Calculates the length of a vec3
+     * Calculates the length of vec3
      *
      * @returns {Number} length of a vector
      */
@@ -219,104 +219,104 @@ class Vec3 extends Float32Array {
         return Math.sqrt(x * x + y * y + z * z);
     }
     /**
-     * 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, out = new Vec3()) {
+    static floor(v, out = vec3()) {
         out[0] = Math.floor(v[0]);
         out[1] = Math.floor(v[1]);
         out[2] = Math.floor(v[2]);
         return out;
     }
     /**
-     * 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, out = new Vec3()) {
+    static round(v, out = vec3()) {
         out[0] = Math.round(v[0]);
         out[1] = Math.round(v[1]);
         out[2] = Math.round(v[2]);
         return out;
     }
     /**
-     * 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, out = new Vec3()) {
+    static ceil(v, out = vec3()) {
         out[0] = Math.ceil(v[0]);
         out[1] = Math.ceil(v[1]);
         out[2] = Math.ceil(v[2]);
         return out;
     }
     /**
-     * Floors each component of a vec3
+     * Floors each component of vec3
      *
      * @returns {Vec3} this
      */
-    floor(out = index.ALWAYS_COPY ? new Vec3() : this) {
+    floor(out = index.ALWAYS_COPY ? vec3() : this) {
         out[0] = Math.floor(this[0]);
         out[1] = Math.floor(this[1]);
         out[2] = Math.floor(this[2]);
         return out;
     }
     /**
-     * Rounds each component of a vec3
+     * Rounds each component of vec3
      *
      * @returns {Vec3} this
      */
-    round(out = index.ALWAYS_COPY ? new Vec3() : this) {
+    round(out = index.ALWAYS_COPY ? vec3() : this) {
         out[0] = Math.round(this[0]);
         out[1] = Math.round(this[1]);
         out[2] = Math.round(this[2]);
         return out;
     }
     /**
-     * Ceils each component of a vec3
+     * Ceils each component of vec3
      *
      * @returns {Vec3} this
      */
-    ceil(out = index.ALWAYS_COPY ? new Vec3() : this) {
+    ceil(out = index.ALWAYS_COPY ? vec3() : this) {
         out[0] = Math.ceil(this[0]);
         out[1] = Math.ceil(this[1]);
         out[2] = Math.ceil(this[2]);
         return out;
     }
     /**
-     * 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, out = new Vec3()) {
+    static inverse(v, out = vec3()) {
         out[0] = 1.0 / v[0];
         out[1] = 1.0 / v[1];
         out[2] = 1.0 / v[2];
         return out;
     }
     /**
-     * Inverts a vec3 component-wise
+     * Inverts vec3 component-wise
      *
      * @returns {Vec3} this
      */
-    inverse(out = index.ALWAYS_COPY ? new Vec3() : this) {
+    inverse(out = index.ALWAYS_COPY ? vec3() : this) {
         out[0] = 1.0 / this[0];
         out[1] = 1.0 / this[1];
         out[2] = 1.0 / this[2];
         return out;
     }
     /**
-     * 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() {
-        return new Vec3(this[0], this[1], this[2]);
+        return vec3(this[0], this[1], this[2]);
     }
     /**
      * Returns a string representation of a vector
@@ -336,7 +336,7 @@ class Vec3 extends Float32Array {
         const r = index.RANDOM() * 2.0 * Math.PI;
         const z = index.RANDOM() * 2.0 - 1.0;
         const zScale = Math.sqrt(1.0 - z * z) * scale;
-        return new Vec3(Math.cos(r) * zScale, Math.sin(r) * zScale, z * scale);
+        return vec3(Math.cos(r) * zScale, Math.sin(r) * zScale, z * scale);
     }
     /**
      * Calculates the angle between two vec3's
@@ -367,10 +367,10 @@ 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, b, out = new Vec3()) {
+    static cross(a, b, out = vec3()) {
         const ax = a[0], ay = a[1], az = a[2];
         const bx = b[0], by = b[1], bz = b[2];
         out[0] = ay * bz - az * by;
@@ -410,10 +410,10 @@ 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, b, t, out = new Vec3()) {
+    static lerp(a, b, t, out = vec3()) {
         const ax = a[0], ay = a[1], az = a[2];
         out[0] = ax + (b[0] - ax) * t;
         out[1] = ay + (b[1] - ay) * t;
@@ -426,10 +426,10 @@ 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, b, t, out = new Vec3()) {
+    static slerp(a, b, t, out = vec3()) {
         const angle = Math.acos(Math.min(Math.max(Vec3.dot(a, b), -1), 1));
         const sinTotal = Math.sin(angle);
         const ratioA = Math.sin((1 - t) * angle) / sinTotal;
@@ -446,7 +446,7 @@ class Vec3 extends Float32Array {
      * @param {Vec3} b the second operand
      * @returns {Vec3} a new vector with the max components
      */
-    static max(a, b, out = new Vec3()) {
+    static max(a, b, out = vec3()) {
         out[0] = Math.max(a[0], b[0]);
         out[1] = Math.max(a[1], b[1]);
         out[2] = Math.max(a[2], b[2]);
@@ -459,7 +459,7 @@ class Vec3 extends Float32Array {
      * @param {Vec3} b the second operand
      * @returns {Vec3} a new vector with the min components
      */
-    static min(a, b, out = new Vec3()) {
+    static min(a, b, out = vec3()) {
         out[0] = Math.min(a[0], b[0]);
         out[1] = Math.min(a[1], b[1]);
         out[2] = Math.min(a[2], b[2]);
@@ -474,7 +474,7 @@ class Vec3 extends Float32Array {
      * @param {Vec3} out the receiving vector
      * @returns {Vec3} out
      */
-    static clamp(v, min, max, out = new Vec3()) {
+    static clamp(v, min, max, out = vec3()) {
         const minX = typeof min === 'number' ? min : min[0];
         const minY = typeof min === 'number' ? min : min[1];
         const minZ = typeof min === 'number' ? min : min[2];
@@ -495,7 +495,7 @@ class Vec3 extends Float32Array {
      * @param {Vec3} out the receiving vector
      * @returns {Vec3} out
      */
-    static mix(a, b, t, out = new Vec3()) {
+    static mix(a, b, t, out = vec3()) {
         if (typeof t === 'number') {
             out[0] = a[0] + (b[0] - a[0]) * t;
             out[1] = a[1] + (b[1] - a[1]) * t;
@@ -517,7 +517,7 @@ class Vec3 extends Float32Array {
      * @param {Vec3} out the receiving vector
      * @returns {Vec3} out
      */
-    static smoothstep(edge0, edge1, v, out = new Vec3()) {
+    static smoothstep(edge0, edge1, v, out = vec3()) {
         const e0x = typeof edge0 === 'number' ? edge0 : edge0[0];
         const e0y = typeof edge0 === 'number' ? edge0 : edge0[1];
         const e0z = typeof edge0 === 'number' ? edge0 : edge0[2];
@@ -533,14 +533,14 @@ class Vec3 extends Float32Array {
         return out;
     }
     /**
-     * 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, rad, origin = Vec3.zero, out = new Vec3()) {
+    static rotateX(v, rad, origin = vec3.zero, out = vec3()) {
         const p1 = v[1] - origin[1];
         const p2 = v[2] - origin[2];
         out[0] = v[0];
@@ -549,13 +549,13 @@ class Vec3 extends Float32Array {
         return out;
     }
     /**
-     * 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, origin = Vec3.zero, out = index.ALWAYS_COPY ? new Vec3() : this) {
+    rotateX(rad, origin = vec3.zero, out = index.ALWAYS_COPY ? vec3() : this) {
         const p1 = this[1] - origin[1];
         const p2 = this[2] - origin[2];
         out[0] = this[0];
@@ -564,14 +564,14 @@ class Vec3 extends Float32Array {
         return out;
     }
     /**
-     * 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, rad, origin = Vec3.zero, out = new Vec3()) {
+    static rotateY(v, rad, origin = vec3.zero, out = vec3()) {
         const p0 = v[0] - origin[0];
         const p2 = v[2] - origin[2];
         out[0] = p2 * Math.sin(rad) + p0 * Math.cos(rad) + origin[0];
@@ -580,12 +580,12 @@ class Vec3 extends Float32Array {
         return out;
     }
     /**
-     * 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, origin = Vec3.zero, out = index.ALWAYS_COPY ? new Vec3() : this) {
+    rotateY(rad, origin = vec3.zero, out = index.ALWAYS_COPY ? vec3() : this) {
         const p0 = this[0] - origin[0];
         const p2 = this[2] - origin[2];
         out[0] = p2 * Math.sin(rad) + p0 * Math.cos(rad) + origin[0];
@@ -594,14 +594,14 @@ class Vec3 extends Float32Array {
         return out;
     }
     /**
-     * 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
      * @param {Vec3} origin the origin of the rotation, defaults to ZERO
      * @returns {Vec3} a new rotated vector
      */
-    static rotateZ(v, rad, origin = Vec3.zero, out = new Vec3()) {
+    static rotateZ(v, rad, origin = vec3.zero, out = vec3()) {
         const p0 = v[0] - origin[0];
         const p1 = v[1] - origin[1];
         out[0] = p0 * Math.cos(rad) - p1 * Math.sin(rad) + origin[0];
@@ -610,12 +610,12 @@ class Vec3 extends Float32Array {
         return out;
     }
     /**
-     * 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, origin = Vec3.zero, out = index.ALWAYS_COPY ? new Vec3() : this) {
+    rotateZ(rad, origin = vec3.zero, out = index.ALWAYS_COPY ? vec3() : this) {
         const p0 = this[0] - origin[0];
         const p1 = this[1] - origin[1];
         out[0] = p0 * Math.cos(rad) - p1 * Math.sin(rad) + origin[0];
@@ -633,7 +633,7 @@ class Vec3 extends Float32Array {
      * @param {Number} t interpolation amount, in the range [0-1], between the two inputs
      * @returns {Vec3} a new vector
      */
-    static hermite(a, b, c, d, t, out = new Vec3()) {
+    static hermite(a, b, c, d, t, out = vec3()) {
         const factorTimes2 = t * t;
         const factor1 = factorTimes2 * (2 * t - 3) + 1;
         const factor2 = factorTimes2 * (t - 2) + t;
@@ -654,7 +654,7 @@ class Vec3 extends Float32Array {
      * @param {Number} t interpolation amount, in the range [0-1], between the two inputs
      * @returns {Vec3} a new vector
      */
-    static bezier(a, b, c, d, t, out = new Vec3()) {
+    static bezier(a, b, c, d, t, out = vec3()) {
         const inverseFactor = 1 - t;
         const inverseFactorTimesTwo = inverseFactor * inverseFactor;
         const factorTimes2 = t * t;
@@ -673,10 +673,10 @@ 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, b, scale, out = new Vec3()) {
+    static scaleAndAdd(a, b, scale, out = vec3()) {
         out[0] = a[0] + b[0] * scale;
         out[1] = a[1] + b[1] * scale;
         out[2] = a[2] + b[2] * scale;
@@ -687,10 +687,10 @@ 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, N, out = new Vec3()) {
+    static reflect(I, N, out = vec3()) {
         const d = Vec3.dot(N, I) * 2;
         out[0] = I[0] - d * N[0];
         out[1] = I[1] - d * N[1];
@@ -703,10 +703,10 @@ 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, N, eta, out = new Vec3()) {
+    static refract(I, N, eta, out = vec3()) {
         const d = Vec3.dot(N, I);
         const k = 1.0 - eta * eta * (1.0 - d * d);
         if (k < 0.0) {
@@ -725,10 +725,10 @@ 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, I, Nref, out = new Vec3()) {
+    static faceforward(N, I, Nref, out = vec3()) {
         const d = Vec3.dot(Nref, I);
         const sign = d < 0 ? 1 : -1;
         out[0] = N[0] * sign;
@@ -742,10 +742,10 @@ 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, p2, p3, out = new Vec3()) {
+    static triangleNormal(p1, p2, p3, out = vec3()) {
         const e1x = p2[0] - p1[0], e1y = p2[1] - p1[1], e1z = p2[2] - p1[2];
         const e2x = p3[0] - p1[0], e2y = p3[1] - p1[1], e2z = p3[2] - p1[2];
         out[0] = e1y * e2z - e1z * e2y;
@@ -765,10 +765,10 @@ 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, b, out = new Vec3()) {
+    static project(a, b, out = vec3()) {
         const d = Vec3.dot(a, b) / Vec3.dot(b, b);
         out[0] = b[0] * d;
         out[1] = b[1] * d;
@@ -793,22 +793,22 @@ 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, scale, out = index.ALWAYS_COPY ? new Vec3() : this) {
+    scaleAndAdd(b, scale, out = index.ALWAYS_COPY ? vec3() : this) {
         out[0] = this[0] + b[0] * scale;
         out[1] = this[1] + b[1] * scale;
         out[2] = this[2] + b[2] * scale;
         return out;
     }
     /**
-     * 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 = index.ALWAYS_COPY ? new Vec3() : this) {
+    abs(out = index.ALWAYS_COPY ? vec3() : this) {
         out[0] = Math.abs(this[0]);
         out[1] = Math.abs(this[1]);
         out[2] = Math.abs(this[2]);
@@ -819,10 +819,10 @@ 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, max, out = index.ALWAYS_COPY ? new Vec3() : this) {
+    clamp(min, max, out = index.ALWAYS_COPY ? vec3() : this) {
         const minX = typeof min === 'number' ? min : min[0];
         const minY = typeof min === 'number' ? min : min[1];
         const minZ = typeof min === 'number' ? min : min[2];
@@ -839,10 +839,10 @@ 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, t, out = index.ALWAYS_COPY ? new Vec3() : this) {
+    mix(b, t, out = index.ALWAYS_COPY ? vec3() : this) {
         if (typeof t === 'number') {
             out[0] = this[0] + (b[0] - this[0]) * t;
             out[1] = this[1] + (b[1] - this[1]) * t;
@@ -859,10 +859,10 @@ 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, out = index.ALWAYS_COPY ? new Vec3() : this) {
+    step(edge, out = index.ALWAYS_COPY ? vec3() : this) {
         if (typeof edge === 'number') {
             out[0] = this[0] < edge ? 0 : 1;
             out[1] = this[1] < edge ? 0 : 1;
@@ -880,10 +880,10 @@ 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, edge1, out = index.ALWAYS_COPY ? new Vec3() : this) {
+    smoothstep(edge0, edge1, out = index.ALWAYS_COPY ? vec3() : this) {
         const e0x = typeof edge0 === 'number' ? edge0 : edge0[0];
         const e0y = typeof edge0 === 'number' ? edge0 : edge0[1];
         const e0z = typeof edge0 === 'number' ? edge0 : edge0[2];
@@ -901,10 +901,10 @@ class Vec3 extends Float32Array {
     /**
      * 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 = index.ALWAYS_COPY ? new Vec3() : this) {
+    fract(out = index.ALWAYS_COPY ? vec3() : this) {
         out[0] = this[0] - Math.floor(this[0]);
         out[1] = this[1] - Math.floor(this[1]);
         out[2] = this[2] - Math.floor(this[2]);
@@ -913,10 +913,10 @@ class Vec3 extends Float32Array {
     /**
      * 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 = index.ALWAYS_COPY ? new Vec3() : this) {
+    sign(out = index.ALWAYS_COPY ? vec3() : this) {
         out[0] = this[0] > 0 ? 1 : this[0] < 0 ? -1 : 0;
         out[1] = this[1] > 0 ? 1 : this[1] < 0 ? -1 : 0;
         out[2] = this[2] > 0 ? 1 : this[2] < 0 ? -1 : 0;
@@ -925,10 +925,10 @@ class Vec3 extends Float32Array {
     /**
      * 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 = index.ALWAYS_COPY ? new Vec3() : this) {
+    saturate(out = index.ALWAYS_COPY ? vec3() : this) {
         out[0] = Math.min(Math.max(this[0], 0), 1);
         out[1] = Math.min(Math.max(this[1], 0), 1);
         out[2] = Math.min(Math.max(this[2], 0), 1);
@@ -938,10 +938,10 @@ 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, out = index.ALWAYS_COPY ? new Vec3() : this) {
+    transformMat3(m, out = index.ALWAYS_COPY ? vec3() : this) {
         const x = this[0], y = this[1], z = this[2];
         out[0] = x * m[0] + y * m[3] + z * m[6];
         out[1] = x * m[1] + y * m[4] + z * m[7];
@@ -952,10 +952,10 @@ 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, out = index.ALWAYS_COPY ? new Vec3() : this) {
+    transformMat4(m, out = index.ALWAYS_COPY ? vec3() : this) {
         const x = this[0], y = this[1], z = this[2];
         let w = m[3] * x + m[7] * y + m[11] * z + m[15];
         w = w || 1.0;
@@ -968,10 +968,10 @@ 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, out = index.ALWAYS_COPY ? new Vec3() : this) {
+    transformQuat(q, out = index.ALWAYS_COPY ? vec3() : this) {
         const qx = q[0], qy = q[1], qz = q[2], qw = q[3];
         const x = this[0], y = this[1], z = this[2];
         let uvx = qy * z - qz * y, uvy = qz * x - qx * z, uvz = qx * y - qy * x;
@@ -1005,6 +1005,7 @@ Vec3.prototype.neg = Vec3.prototype.negate;
 Vec3.prototype.unaryMinus = Vec3.prototype.negate;
 Vec3.prototype.sqrLen = Vec3.prototype.squaredLength;
 Vec3.prototype.str = Vec3.prototype.toString;
+Vec3.prototype.normalized = Vec3.prototype.normalize;
 Vec3.prototype.transformMat3x3 = Vec3.prototype.transformMat3;
 Vec3.prototype.transformMat4x4 = Vec3.prototype.transformMat4;
 const createVec3 = (...args) => {
@@ -1029,14 +1030,14 @@ const vec3 = createVec3;
  * @extends Float32Array
  */
 class Vec4 extends Float32Array {
-    static get zero() { return new Vec4(0, 0, 0, 0); }
-    static get Zero() { return new Vec4(0, 0, 0, 0); }
-    static get ZERO() { return new Vec4(0, 0, 0, 0); }
-    static get one() { return new Vec4(1, 1, 1, 1); }
-    static get One() { return new Vec4(1, 1, 1, 1); }
-    static get ONE() { return new Vec4(1, 1, 1, 1); }
+    static get zero() { return vec4(0, 0, 0, 0); }
+    static get Zero() { return vec4(0, 0, 0, 0); }
+    static get ZERO() { return vec4(0, 0, 0, 0); }
+    static get one() { return vec4(1, 1, 1, 1); }
+    static get One() { return vec4(1, 1, 1, 1); }
+    static get ONE() { return vec4(1, 1, 1, 1); }
     /**
-     * Creates a new Vec4
+     * Creates a vec4
      *
      * @param {Number} x X component, defaults to 0
      * @param {Number} y Y component, defaults to 0
@@ -1062,10 +1063,10 @@ 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, out = index.ALWAYS_COPY ? new Vec4() : this) {
+    plus(b, out = index.ALWAYS_COPY ? vec4() : this) {
         if (typeof b === 'number') {
             out[0] = this[0] + b;
             out[1] = this[1] + b;
@@ -1084,10 +1085,10 @@ 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, out = index.ALWAYS_COPY ? new Vec4() : this) {
+    minus(b, out = index.ALWAYS_COPY ? vec4() : this) {
         if (typeof b === 'number') {
             out[0] = this[0] - b;
             out[1] = this[1] - b;
@@ -1106,10 +1107,10 @@ 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, out = index.ALWAYS_COPY ? new Vec4() : this) {
+    mult(b, out = index.ALWAYS_COPY ? vec4() : this) {
         if (typeof b === 'number') {
             out[0] = this[0] * b;
             out[1] = this[1] * b;
@@ -1128,10 +1129,10 @@ 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, out = index.ALWAYS_COPY ? new Vec4() : this) {
+    div(b, out = index.ALWAYS_COPY ? vec4() : this) {
         if (typeof b === 'number') {
             out[0] = this[0] / b;
             out[1] = this[1] / b;
@@ -1146,7 +1147,7 @@ class Vec4 extends Float32Array {
         }
         return out;
     }
-    invDiv(b, out = index.ALWAYS_COPY ? new Vec4() : this) {
+    invDiv(b, out = index.ALWAYS_COPY ? vec4() : this) {
         if (typeof b === 'number') {
             out[0] = b / this[0];
             out[1] = b / this[1];
@@ -1164,17 +1165,17 @@ 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 = index.ALWAYS_COPY ? new Vec4() : this) {
+    negate(out = index.ALWAYS_COPY ? vec4() : this) {
         out[0] = -this[0];
         out[1] = -this[1];
         out[2] = -this[2];
         out[3] = -this[3];
         return out;
     }
-    unaryPlus(out = index.ALWAYS_COPY ? new Vec4() : this) {
+    unaryPlus(out = index.ALWAYS_COPY ? vec4() : this) {
         if (!out.equals(this)) {
             out[0] = this[0];
             out[1] = this[1];
@@ -1186,10 +1187,29 @@ 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, out = vec4()) {
+        const x = v[0], y = v[1], z = v[2], w = v[3];
+        let len = x * x + y * y + z * z + w * w;
+        if (len > 0) {
+            len = 1.0 / Math.sqrt(len);
+        }
+        out[0] = x * len;
+        out[1] = y * len;
+        out[2] = z * len;
+        out[3] = w * len;
+        return out;
+    }
+    /**
+     * Normalizes a vec4
+     *
+     * @param {Vec4} out the receiving vector, defaults to new vec4()
      * @returns {Vec4} out
      */
-    normalize(out = index.ALWAYS_COPY ? new Vec4() : this) {
+    normalize(out = index.ALWAYS_COPY ? vec4() : this) {
         const x = this[0], y = this[1], z = this[2], w = this[3];
         let len = x * x + y * y + z * z + w * w;
         if (len > 0) {
@@ -1241,10 +1261,10 @@ 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 = index.ALWAYS_COPY ? new Vec4() : this) {
+    floor(out = index.ALWAYS_COPY ? vec4() : this) {
         out[0] = Math.floor(this[0]);
         out[1] = Math.floor(this[1]);
         out[2] = Math.floor(this[2]);
@@ -1254,10 +1274,10 @@ class Vec4 extends Float32Array {
     /**
      * 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 = index.ALWAYS_COPY ? new Vec4() : this) {
+    round(out = index.ALWAYS_COPY ? vec4() : this) {
         out[0] = Math.round(this[0]);
         out[1] = Math.round(this[1]);
         out[2] = Math.round(this[2]);
@@ -1267,10 +1287,10 @@ class Vec4 extends Float32Array {
     /**
      * 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 = index.ALWAYS_COPY ? new Vec4() : this) {
+    ceil(out = index.ALWAYS_COPY ? vec4() : this) {
         out[0] = Math.ceil(this[0]);
         out[1] = Math.ceil(this[1]);
         out[2] = Math.ceil(this[2]);
@@ -1280,10 +1300,10 @@ class Vec4 extends Float32Array {
     /**
      * 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 = index.ALWAYS_COPY ? new Vec4() : this) {
+    inverse(out = index.ALWAYS_COPY ? vec4() : this) {
         out[0] = 1.0 / this[0];
         out[1] = 1.0 / this[1];
         out[2] = 1.0 / this[2];
@@ -1291,12 +1311,12 @@ class Vec4 extends Float32Array {
         return out;
     }
     /**
-     * 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() {
-        return new Vec4(this[0], this[1], this[2], this[3]);
+        return vec4(this[0], this[1], this[2], this[3]);
     }
     /**
      * Returns a string representation of a vec4
@@ -1310,10 +1330,10 @@ 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 = 1.0, out = new Vec4()) {
+    static random(scale = 1.0, out = vec4()) {
         // Marsaglia, George. Choosing a Point from the Surface of a
         // Sphere. Ann. Math. Statist. 43 (1972), no. 2, 645--646.
         // http://projecteuclid.org/euclid.aoms/1177692644;
@@ -1351,10 +1371,10 @@ 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, v, w, out = new Vec4()) {
+    static cross(u, v, w, out = vec4()) {
         const A = v[0] * w[1] - v[1] * w[0], B = v[0] * w[2] - v[2] * w[0], C = v[0] * w[3] - v[3] * w[0], D = v[1] * w[2] - v[2] * w[1], E = v[1] * w[3] - v[3] * w[1], F = v[2] * w[3] - v[3] * w[2];
         const G = u[0], H = u[1], I = u[2], J = u[3];
         out[0] = H * F - I * E + J * D;
@@ -1397,10 +1417,10 @@ 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, b, t, out = new Vec4()) {
+    static lerp(a, b, t, out = vec4()) {
         const ax = a[0], ay = a[1], az = a[2], aw = a[3];
         out[0] = ax + (b[0] - ax) * t;
         out[1] = ay + (b[1] - ay) * t;
@@ -1413,10 +1433,10 @@ 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, b, out = new Vec4()) {
+    static max(a, b, out = vec4()) {
         out[0] = Math.max(a[0], b[0]);
         out[1] = Math.max(a[1], b[1]);
         out[2] = Math.max(a[2], b[2]);
@@ -1428,10 +1448,10 @@ 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, b, out = new Vec4()) {
+    static min(a, b, out = vec4()) {
         out[0] = Math.min(a[0], b[0]);
         out[1] = Math.min(a[1], b[1]);
         out[2] = Math.min(a[2], b[2]);
@@ -1447,7 +1467,7 @@ class Vec4 extends Float32Array {
      * @param {Vec4} out the receiving vector
      * @returns {Vec4} out
      */
-    static clamp(v, min, max, out = new Vec4()) {
+    static clamp(v, min, max, out = vec4()) {
         const minX = typeof min === 'number' ? min : min[0];
         const minY = typeof min === 'number' ? min : min[1];
         const minZ = typeof min === 'number' ? min : min[2];
@@ -1471,7 +1491,7 @@ class Vec4 extends Float32Array {
      * @param {Vec4} out the receiving vector
      * @returns {Vec4} out
      */
-    static mix(a, b, t, out = new Vec4()) {
+    static mix(a, b, t, out = vec4()) {
         if (typeof t === 'number') {
             out[0] = a[0] + (b[0] - a[0]) * t;
             out[1] = a[1] + (b[1] - a[1]) * t;
@@ -1495,7 +1515,7 @@ class Vec4 extends Float32Array {
      * @param {Vec4} out the receiving vector
      * @returns {Vec4} out
      */
-    static smoothstep(edge0, edge1, v, out = new Vec4()) {
+    static smoothstep(edge0, edge1, v, out = vec4()) {
         const e0x = typeof edge0 === 'number' ? edge0 : edge0[0];
         const e0y = typeof edge0 === 'number' ? edge0 : edge0[1];
         const e0z = typeof edge0 === 'number' ? edge0 : edge0[2];
@@ -1522,7 +1542,7 @@ class Vec4 extends Float32Array {
      * @param {Vec4} out the receiving vector
      * @returns {Vec4} out
      */
-    scaleAndAdd(b, scale, out = index.ALWAYS_COPY ? new Vec4() : this) {
+    scaleAndAdd(b, scale, out = index.ALWAYS_COPY ? vec4() : this) {
         out[0] = this[0] + b[0] * scale;
         out[1] = this[1] + b[1] * scale;
         out[2] = this[2] + b[2] * scale;
@@ -1535,7 +1555,7 @@ class Vec4 extends Float32Array {
      * @param {Vec4} out the receiving vector
      * @returns {Vec4} out
      */
-    abs(out = index.ALWAYS_COPY ? new Vec4() : this) {
+    abs(out = index.ALWAYS_COPY ? vec4() : this) {
         out[0] = Math.abs(this[0]);
         out[1] = Math.abs(this[1]);
         out[2] = Math.abs(this[2]);
@@ -1550,7 +1570,7 @@ class Vec4 extends Float32Array {
      * @param {Vec4} out the receiving vector
      * @returns {Vec4} out
      */
-    clamp(min, max, out = index.ALWAYS_COPY ? new Vec4() : this) {
+    clamp(min, max, out = index.ALWAYS_COPY ? vec4() : this) {
         const minX = typeof min === 'number' ? min : min[0];
         const minY = typeof min === 'number' ? min : min[1];
         const minZ = typeof min === 'number' ? min : min[2];
@@ -1573,7 +1593,7 @@ class Vec4 extends Float32Array {
      * @param {Vec4} out the receiving vector
      * @returns {Vec4} out
      */
-    mix(b, t, out = index.ALWAYS_COPY ? new Vec4() : this) {
+    mix(b, t, out = index.ALWAYS_COPY ? vec4() : this) {
         if (typeof t === 'number') {
             out[0] = this[0] + (b[0] - this[0]) * t;
             out[1] = this[1] + (b[1] - this[1]) * t;
@@ -1595,7 +1615,7 @@ class Vec4 extends Float32Array {
      * @param {Vec4} out the receiving vector
      * @returns {Vec4} out
      */
-    step(edge, out = index.ALWAYS_COPY ? new Vec4() : this) {
+    step(edge, out = index.ALWAYS_COPY ? vec4() : this) {
         if (typeof edge === 'number') {
             out[0] = this[0] < edge ? 0 : 1;
             out[1] = this[1] < edge ? 0 : 1;
@@ -1618,7 +1638,7 @@ class Vec4 extends Float32Array {
      * @param {Vec4} out the receiving vector
      * @returns {Vec4} out
      */
-    smoothstep(edge0, edge1, out = index.ALWAYS_COPY ? new Vec4() : this) {
+    smoothstep(edge0, edge1, out = index.ALWAYS_COPY ? vec4() : this) {
         const e0x = typeof edge0 === 'number' ? edge0 : edge0[0];
         const e0y = typeof edge0 === 'number' ? edge0 : edge0[1];
         const e0z = typeof edge0 === 'number' ? edge0 : edge0[2];
@@ -1643,7 +1663,7 @@ class Vec4 extends Float32Array {
      * @param {Vec4} out the receiving vector
      * @returns {Vec4} out
      */
-    fract(out = index.ALWAYS_COPY ? new Vec4() : this) {
+    fract(out = index.ALWAYS_COPY ? vec4() : this) {
         out[0] = this[0] - Math.floor(this[0]);
         out[1] = this[1] - Math.floor(this[1]);
         out[2] = this[2] - Math.floor(this[2]);
@@ -1656,7 +1676,7 @@ class Vec4 extends Float32Array {
      * @param {Vec4} out the receiving vector
      * @returns {Vec4} out
      */
-    sign(out = index.ALWAYS_COPY ? new Vec4() : this) {
+    sign(out = index.ALWAYS_COPY ? vec4() : this) {
         out[0] = this[0] > 0 ? 1 : this[0] < 0 ? -1 : 0;
         out[1] = this[1] > 0 ? 1 : this[1] < 0 ? -1 : 0;
         out[2] = this[2] > 0 ? 1 : this[2] < 0 ? -1 : 0;
@@ -1669,7 +1689,7 @@ class Vec4 extends Float32Array {
      * @param {Vec4} out the receiving vector
      * @returns {Vec4} out
      */
-    saturate(out = index.ALWAYS_COPY ? new Vec4() : this) {
+    saturate(out = index.ALWAYS_COPY ? vec4() : this) {
         out[0] = Math.min(Math.max(this[0], 0), 1);
         out[1] = Math.min(Math.max(this[1], 0), 1);
         out[2] = Math.min(Math.max(this[2], 0), 1);
@@ -1683,7 +1703,7 @@ class Vec4 extends Float32Array {
      * @param {Vec4} out the receiving vector
      * @returns {Vec4} out
      */
-    transformMat4(m, out = index.ALWAYS_COPY ? new Vec4() : this) {
+    transformMat4(m, out = index.ALWAYS_COPY ? vec4() : this) {
         const x = this[0], y = this[1], z = this[2], w = this[3];
         out[0] = m[0] * x + m[4] * y + m[8] * z + m[12] * w;
         out[1] = m[1] * x + m[5] * y + m[9] * z + m[13] * w;
@@ -1698,7 +1718,7 @@ class Vec4 extends Float32Array {
      * @param {Vec4} out the receiving vector
      * @returns {Vec4} out
      */
-    transformQuat(q, out = index.ALWAYS_COPY ? new Vec4() : this) {
+    transformQuat(q, out = index.ALWAYS_COPY ? vec4() : this) {
         const qx = q[0], qy = q[1], qz = q[2], qw = q[3];
         const x = this[0], y = this[1], z = this[2];
         let uvx = qy * z - qz * y, uvy = qz * x - qx * z, uvz = qx * y - qy * x;
@@ -1725,7 +1745,7 @@ class Vec4 extends Float32Array {
      * @param {Vec4} out the receiving vector
      * @returns {Vec4} out
      */
-    static scaleAndAdd(a, b, scale, out = new Vec4()) {
+    static scaleAndAdd(a, b, scale, out = vec4()) {
         out[0] = a[0] + b[0] * scale;
         out[1] = a[1] + b[1] * scale;
         out[2] = a[2] + b[2] * scale;
@@ -1749,6 +1769,7 @@ Vec4.prototype.neg = Vec4.prototype.negate;
 Vec4.prototype.unaryMinus = Vec4.prototype.negate;
 Vec4.prototype.sqrLen = Vec4.prototype.squaredLength;
 Vec4.prototype.str = Vec4.prototype.toString;
+Vec4.prototype.normalized = Vec4.prototype.normalize;
 Vec4.prototype.transformMat4x4 = Vec4.prototype.transformMat4;
 const createVec4 = (...args) => {
     const out = new Vec4();
@@ -1834,12 +1855,12 @@ function defineSwizzles(prototype, N = 4, S = ['xyzw', 'rgba', 'stpq', 'uv']) {
  * @extends Float32Array
  */
 class Vec2 extends Float32Array {
-    static get zero() { return new Vec2(0, 0); }
-    static get Zero() { return new Vec2(0, 0); }
-    static get ZERO() { return new Vec2(0, 0); }
-    static get one() { return new Vec2(1, 1); }
-    static get One() { return new Vec2(1, 1); }
-    static get ONE() { return new Vec2(1, 1); }
+    static get zero() { return vec2(0, 0); }
+    static get Zero() { return vec2(0, 0); }
+    static get ZERO() { return vec2(0, 0); }
+    static get one() { return vec2(1, 1); }
+    static get One() { return vec2(1, 1); }
+    static get ONE() { return vec2(1, 1); }
     /**
      * Creates a new Vec2 initialized with the given values
      *
@@ -1859,10 +1880,10 @@ 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, out = index.ALWAYS_COPY ? new Vec2() : this) {
+    plus(b, out = index.ALWAYS_COPY ? vec2() : this) {
         if (typeof b === 'number') {
             out[0] = this[0] + b;
             out[1] = this[1] + b;
@@ -1877,10 +1898,10 @@ 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, out = index.ALWAYS_COPY ? new Vec2() : this) {
+    minus(b, out = index.ALWAYS_COPY ? vec2() : this) {
         if (typeof b === 'number') {
             out[0] = this[0] - b;
             out[1] = this[1] - b;
@@ -1895,10 +1916,10 @@ 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, out = index.ALWAYS_COPY ? new Vec2() : this) {
+    mult(b, out = index.ALWAYS_COPY ? vec2() : this) {
         if (typeof b === 'number') {
             out[0] = this[0] * b;
             out[1] = this[1] * b;
@@ -1913,10 +1934,10 @@ 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, out = index.ALWAYS_COPY ? new Vec2() : this) {
+    div(b, out = index.ALWAYS_COPY ? vec2() : this) {
         if (typeof b === 'number') {
             out[0] = this[0] / b;
             out[1] = this[1] / b;
@@ -1931,10 +1952,10 @@ 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, out = index.ALWAYS_COPY ? new Vec2() : this) {
+    invDiv(a, out = index.ALWAYS_COPY ? vec2() : this) {
         if (typeof a === 'number') {
             out[0] = a / this[0];
             out[1] = a / this[1];
@@ -1949,10 +1970,10 @@ 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, out = index.ALWAYS_COPY ? new Vec2() : this) {
+    rem(b, out = index.ALWAYS_COPY ? vec2() : this) {
         if (typeof b === 'number') {
             out[0] = this[0] % b;
             out[1] = this[1] % b;
@@ -1966,15 +1987,15 @@ class Vec2 extends Float32Array {
     /**
      * 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 = index.ALWAYS_COPY ? new Vec2() : this) {
+    negate(out = index.ALWAYS_COPY ? vec2() : this) {
         out[0] = -this[0];
         out[1] = -this[1];
         return out;
     }
-    unaryPlus(out = index.ALWAYS_COPY ? new Vec2() : this) {
+    unaryPlus(out = index.ALWAYS_COPY ? vec2() : this) {
         if (!out.equals(this)) {
             out[0] = this[0];
             out[1] = this[1];
@@ -1982,11 +2003,28 @@ class Vec2 extends Float32Array {
         return out;
     }
     /**
-     * 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
      */
-    normalize(out = index.ALWAYS_COPY ? new Vec2() : this) {
+    static normalize(v, out = vec2()) {
+        const x = v[0], y = v[1];
+        let len = x * x + y * y;
+        if (len > 0) {
+            len = 1.0 / Math.sqrt(len);
+        }
+        out[0] = x * len;
+        out[1] = y * len;
+        return out;
+    }
+    /**
+     * Normalize a vector to unit length.
+     *
+     * @param {Vec2} out the receiving vector, defaults to new vec2()
+     * @returns {Vec2} this
+     */
+    normalize(out = index.ALWAYS_COPY ? vec2() : this) {
         const x = this[0], y = this[1];
         let len = x * x + y * y;
         if (len > 0) {
@@ -2036,10 +2074,10 @@ 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 = index.ALWAYS_COPY ? new Vec2() : this) {
+    floor(out = index.ALWAYS_COPY ? vec2() : this) {
         out[0] = Math.floor(this[0]);
         out[1] = Math.floor(this[1]);
         return out;
@@ -2047,10 +2085,10 @@ class Vec2 extends Float32Array {
     /**
      * 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 = index.ALWAYS_COPY ? new Vec2() : this) {
+    round(out = index.ALWAYS_COPY ? vec2() : this) {
         out[0] = Math.round(this[0]);
         out[1] = Math.round(this[1]);
         return out;
@@ -2058,10 +2096,10 @@ class Vec2 extends Float32Array {
     /**
      * 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 = index.ALWAYS_COPY ? new Vec2() : this) {
+    ceil(out = index.ALWAYS_COPY ? vec2() : this) {
         out[0] = Math.ceil(this[0]);
         out[1] = Math.ceil(this[1]);
         return out;
@@ -2069,10 +2107,10 @@ class Vec2 extends Float32Array {
     /**
      * 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 = index.ALWAYS_COPY ? new Vec2() : this) {
+    inverse(out = index.ALWAYS_COPY ? vec2() : this) {
         out[0] = 1.0 / this[0];
         out[1] = 1.0 / this[1];
         return out;
@@ -2082,16 +2120,16 @@ class Vec2 extends Float32Array {
      *
      * @returns {Vec2} a new Vec2
      */
-    clone() { return new Vec2(this[0], this[1]); }
+    clone() { return vec2(this[0], this[1]); }
     /**
      * 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 = 0, origin = Vec2.ZERO, out = index.ALWAYS_COPY ? new Vec2() : this) {
+    rotate(rad = 0, origin = vec2.zero, out = index.ALWAYS_COPY ? vec2() : this) {
         const p0 = this[0] - origin[0];
         const p1 = this[1] - origin[1];
         const sinC = Math.sin(rad);
@@ -2114,7 +2152,7 @@ class Vec2 extends Float32Array {
      * @param {Number} scale length of the resulting vector, defaults to 1.0
      * @returns {Vec2} a new random Vec2
      */
-    static random(scale = 1.0, out = new Vec2()) {
+    static random(scale = 1.0, out = vec2()) {
         const angleR = index.RANDOM() * 2.0 * Math.PI;
         out[0] = Math.cos(angleR) * scale;
         out[1] = Math.sin(angleR) * scale;
@@ -2208,7 +2246,7 @@ class Vec2 extends Float32Array {
      * @param {Number} t interpolation amount, in the range [0-1], between the two inputs
      * @returns {Vec2} a new interpolated Vec2
      */
-    static lerp(a, b, t, out = new Vec2()) {
+    static lerp(a, b, t, out = vec2()) {
         const a0 = a[0], a1 = a[1];
         out[0] = a0 + (b[0] - a0) * t;
         out[1] = a1 + (b[1] - a1) * t;
@@ -2221,7 +2259,7 @@ class Vec2 extends Float32Array {
      * @param {Vec2} b the second operand
      * @returns {Vec2} a new Vec2 with max components
      */
-    static max(a, b, out = new Vec2()) {
+    static max(a, b, out = vec2()) {
         out[0] = Math.max(a[0], b[0]);
         out[1] = Math.max(a[1], b[1]);
         return out;
@@ -2233,7 +2271,7 @@ class Vec2 extends Float32Array {
      * @param {Vec2} b the second operand
      * @returns {Vec2} a new Vec2 with min components
      */
-    static min(a, b, out = new Vec2()) {
+    static min(a, b, out = vec2()) {
         out[0] = Math.min(a[0], b[0]);
         out[1] = Math.min(a[1], b[1]);
         return out;
@@ -2246,7 +2284,7 @@ class Vec2 extends Float32Array {
      * @param {Vec2 | Number} max the upper bound
      * @returns {Vec2} a new clamped Vec2
      */
-    static clamp(v, min, max, out = new Vec2()) {
+    static clamp(v, min, max, out = vec2()) {
         if (typeof min === 'number' && typeof max === 'number') {
             out[0] = Math.min(Math.max(v[0], min), max);
             out[1] = Math.min(Math.max(v[1], min), max);
@@ -2269,7 +2307,7 @@ class Vec2 extends Float32Array {
      * @param {Vec2 | Number} t interpolation factor (scalar or per-component)
      * @returns {Vec2} a new interpolated Vec2
      */
-    static mix(a, b, t, out = new Vec2()) {
+    static mix(a, b, t, out = vec2()) {
         if (typeof t === 'number') {
             out[0] = a[0] + (b[0] - a[0]) * t;
             out[1] = a[1] + (b[1] - a[1]) * t;
@@ -2288,7 +2326,7 @@ class Vec2 extends Float32Array {
      * @param {Vec2} v the source vector
      * @returns {Vec2} a new smoothstepped Vec2
      */
-    static smoothstep(edge0, edge1, v, out = new Vec2()) {
+    static smoothstep(edge0, edge1, v, out = vec2()) {
         const e0x = typeof edge0 === 'number' ? edge0 : edge0[0];
         const e0y = typeof edge0 === 'number' ? edge0 : edge0[1];
         const e1x = typeof edge1 === 'number' ? edge1 : edge1[0];
@@ -2304,10 +2342,10 @@ 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, scale, out = index.ALWAYS_COPY ? new Vec2() : this) {
+    scaleAndAdd(b, scale, out = index.ALWAYS_COPY ? vec2() : this) {
         out[0] = this[0] + b[0] * scale;
         out[1] = this[1] + b[1] * scale;
         return out;
@@ -2315,10 +2353,10 @@ class Vec2 extends Float32Array {
     /**
      * 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 = index.ALWAYS_COPY ? new Vec2() : this) {
+    abs(out = index.ALWAYS_COPY ? vec2() : this) {
         out[0] = Math.abs(this[0]);
         out[1] = Math.abs(this[1]);
         return out;
@@ -2326,10 +2364,10 @@ class Vec2 extends Float32Array {
     /**
      * 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 = index.ALWAYS_COPY ? new Vec2() : this) {
+    sign(out = index.ALWAYS_COPY ? vec2() : this) {
         out[0] = this[0] > 0 ? 1 : this[0] < 0 ? -1 : 0;
         out[1] = this[1] > 0 ? 1 : this[1] < 0 ? -1 : 0;
         return out;
@@ -2337,10 +2375,10 @@ class Vec2 extends Float32Array {
     /**
      * 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 = index.ALWAYS_COPY ? new Vec2() : this) {
+    fract(out = index.ALWAYS_COPY ? vec2() : this) {
         out[0] = this[0] - Math.floor(this[0]);
         out[1] = this[1] - Math.floor(this[1]);
         return out;
@@ -2350,10 +2388,10 @@ 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, max, out = index.ALWAYS_COPY ? new Vec2() : this) {
+    clamp(min, max, out = index.ALWAYS_COPY ? vec2() : this) {
         if (typeof min === 'number' && typeof max === 'number') {
             out[0] = Math.min(Math.max(this[0], min), max);
             out[1] = Math.min(Math.max(this[1], min), max);
@@ -2371,10 +2409,10 @@ class Vec2 extends Float32Array {
     /**
      * 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 = index.ALWAYS_COPY ? new Vec2() : this) {
+    saturate(out = index.ALWAYS_COPY ? vec2() : this) {
         out[0] = Math.min(Math.max(this[0], 0), 1);
         out[1] = Math.min(Math.max(this[1], 0), 1);
         return out;
@@ -2384,10 +2422,10 @@ 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, t, out = index.ALWAYS_COPY ? new Vec2() : this) {
+    mix(b, t, out = index.ALWAYS_COPY ? vec2() : this) {
         if (typeof t === 'number') {
             out[0] = this[0] + (b[0] - this[0]) * t;
             out[1] = this[1] + (b[1] - this[1]) * t;
@@ -2402,10 +2440,10 @@ 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, out = index.ALWAYS_COPY ? new Vec2() : this) {
+    step(edge, out = index.ALWAYS_COPY ? vec2() : this) {
         if (typeof edge === 'number') {
             out[0] = this[0] < edge ? 0 : 1;
             out[1] = this[1] < edge ? 0 : 1;
@@ -2421,10 +2459,10 @@ 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, edge1, out = index.ALWAYS_COPY ? new Vec2() : this) {
+    smoothstep(edge0, edge1, out = index.ALWAYS_COPY ? vec2() : this) {
         const e0x = typeof edge0 === 'number' ? edge0 : edge0[0];
         const e0y = typeof edge0 === 'number' ? edge0 : edge0[1];
         const e1x = typeof edge1 === 'number' ? edge1 : edge1[0];
@@ -2439,10 +2477,10 @@ 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, out = index.ALWAYS_COPY ? new Vec2() : this) {
+    transformMat2(m, out = index.ALWAYS_COPY ? vec2() : this) {
         const x = this[0], y = this[1];
         out[0] = m[0] * x + m[2] * y;
         out[1] = m[1] * x + m[3] * y;
@@ -2452,10 +2490,10 @@ 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, out = index.ALWAYS_COPY ? new Vec2() : this) {
+    transformMat2x3(m, out = index.ALWAYS_COPY ? vec2() : this) {
         const x = this[0], y = this[1];
         out[0] = m[0] * x + m[2] * y + m[4];
         out[1] = m[1] * x + m[3] * y + m[5];
@@ -2465,10 +2503,10 @@ 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, out = index.ALWAYS_COPY ? new Vec2() : this) {
+    transformMat3(m, out = index.ALWAYS_COPY ? vec2() : this) {
         const x = this[0], y = this[1];
         out[0] = m[0] * x + m[3] * y + m[6];
         out[1] = m[1] * x + m[4] * y + m[7];
@@ -2478,10 +2516,10 @@ 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, out = index.ALWAYS_COPY ? new Vec2() : this) {
+    transformMat4(m, out = index.ALWAYS_COPY ? vec2() : this) {
         const x = this[0], y = this[1];
         out[0] = m[0] * x + m[4] * y + m[12];
         out[1] = m[1] * x + m[5] * y + m[13];
@@ -2496,7 +2534,7 @@ class Vec2 extends Float32Array {
      * @param {Vec2} out the receiving vector
      * @returns {Vec2} out
      */
-    static scaleAndAdd(a, b, scale, out = new Vec2()) {
+    static scaleAndAdd(a, b, scale, out = vec2()) {
         out[0] = a[0] + b[0] * scale;
         out[1] = a[1] + b[1] * scale;
         return out;
@@ -2509,7 +2547,7 @@ class Vec2 extends Float32Array {
      * @param {Vec2} out the receiving vector
      * @returns {Vec2} out
      */
-    static reflect(I, N, out = new Vec2()) {
+    static reflect(I, N, out = vec2()) {
         const d = Vec2.dot(N, I);
         out[0] = I[0] - 2 * d * N[0];
         out[1] = I[1] - 2 * d * N[1];
@@ -2533,6 +2571,7 @@ Vec2.prototype.unaryMinus = Vec2.prototype.negate;
 Vec2.prototype.sqrLen = Vec2.prototype.squaredLength;
 Vec2.prototype.str = Vec2.prototype.toString;
 Vec2.prototype.lerpV = Vec2.prototype.mix;
+Vec2.prototype.normalized = Vec2.prototype.normalize;
 Vec2.prototype.transformMat2x2 = Vec2.prototype.transformMat2;
 Vec2.prototype.transformMat2d = Vec2.prototype.transformMat2x3;
 Vec2.prototype.transformMat3x3 = Vec2.prototype.transformMat3;
@@ -2559,9 +2598,9 @@ const vec2 = createVec2;
  * @extends Float32Array
  */
 class Mat3 extends Float32Array {
-    static get identity() { return new Mat3(1, 0, 0, 0, 1, 0, 0, 0, 1); }
-    static get Identity() { return new Mat3(1, 0, 0, 0, 1, 0, 0, 0, 1); }
-    static get IDENTITY() { return new Mat3(1, 0, 0, 0, 1, 0, 0, 0, 1); }
+    static get identity() { return mat3(1, 0, 0, 0, 1, 0, 0, 0, 1); }
+    static get Identity() { return mat3(1, 0, 0, 0, 1, 0, 0, 0, 1); }
+    static get IDENTITY() { return mat3(1, 0, 0, 0, 1, 0, 0, 0, 1); }
     /**
      * Create a new mat3 with the given values
      *
@@ -2593,15 +2632,15 @@ class Mat3 extends Float32Array {
      * @returns {Mat3} a new Mat3
      */
     clone() {
-        return new Mat3(this[0], this[1], this[2], this[3], this[4], this[5], this[6], this[7], this[8]);
+        return mat3(this[0], this[1], this[2], this[3], this[4], this[5], this[6], this[7], this[8]);
     }
     /**
      * 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 = index.ALWAYS_COPY ? new Mat3() : this) {
+    transpose(out = index.ALWAYS_COPY ? mat3() : this) {
         if (out.exactEquals(this)) {
             const a01 = this[1], a02 = this[2], a12 = this[5];
             out[1] = this[3];
@@ -2627,10 +2666,10 @@ class Mat3 extends Float32Array {
     /**
      * 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 = index.ALWAYS_COPY ? new Mat3() : this) {
+    invert(out = index.ALWAYS_COPY ? mat3() : this) {
         const a00 = this[0], a01 = this[1], a02 = this[2];
         const a10 = this[3], a11 = this[4], a12 = this[5];
         const a20 = this[6], a21 = this[7], a22 = this[8];
@@ -2655,10 +2694,10 @@ class Mat3 extends Float32Array {
     /**
      * 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 = index.ALWAYS_COPY ? new Mat3() : this) {
+    adjoint(out = index.ALWAYS_COPY ? mat3() : this) {
         const a00 = this[0], a01 = this[1], a02 = this[2];
         const a10 = this[3], a11 = this[4], a12 = this[5];
         const a20 = this[6], a21 = this[7], a22 = this[8];
@@ -2684,7 +2723,7 @@ class Mat3 extends Float32Array {
         const a20 = this[6], a21 = this[7], a22 = this[8];
         return a00 * (a22 * a11 - a12 * a21) + a01 * (-a22 * a10 + a12 * a20) + a02 * (a21 * a10 - a11 * a20);
     }
-    multiply(b, out = index.ALWAYS_COPY ? new Mat3() : this) {
+    multiply(b, out = index.ALWAYS_COPY ? mat3() : this) {
         if (b instanceof Vec2)
             return b.transformMat3(this);
         if (b instanceof Vec3)
@@ -2710,10 +2749,10 @@ 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, out = index.ALWAYS_COPY ? new Mat3() : this) {
+    translate(v, out = index.ALWAYS_COPY ? mat3() : this) {
         const a00 = this[0], a01 = this[1], a02 = this[2];
         const a10 = this[3], a11 = this[4], a12 = this[5];
         const a20 = this[6], a21 = this[7], a22 = this[8];
@@ -2733,10 +2772,10 @@ 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, out = index.ALWAYS_COPY ? new Mat3() : this) {
+    rotate(rad, out = index.ALWAYS_COPY ? mat3() : this) {
         const a00 = this[0], a01 = this[1], a02 = this[2];
         const a10 = this[3], a11 = this[4], a12 = this[5];
         const a20 = this[6], a21 = this[7], a22 = this[8];
@@ -2756,10 +2795,10 @@ 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, out = index.ALWAYS_COPY ? new Mat3() : this) {
+    scale(v, out = index.ALWAYS_COPY ? mat3() : this) {
         const x = v[0], y = v[1];
         out[0] = x * this[0];
         out[1] = x * this[1];
@@ -2776,10 +2815,10 @@ 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, out = new Mat3()) {
+    static fromTranslation(v, out = mat3()) {
         out[0] = 1;
         out[1] = 0;
         out[2] = 0;
@@ -2795,10 +2834,10 @@ 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, out = new Mat3()) {
+    static fromRotation(rad, out = mat3()) {
         const s = Math.sin(rad), c = Math.cos(rad);
         out[0] = c;
         out[1] = s;
@@ -2815,10 +2854,10 @@ 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, out = new Mat3()) {
+    static fromScaling(v, out = mat3()) {
         out[0] = v[0];
         out[1] = 0;
         out[2] = 0;
@@ -2834,10 +2873,10 @@ 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, out = new Mat3()) {
+    static fromMat2x3(a, out = mat3()) {
         out[0] = a[0];
         out[1] = a[1];
         out[2] = 0;
@@ -2853,10 +2892,10 @@ 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, out = new Mat3()) {
+    static fromQuat(q, out = mat3()) {
         const x = q[0], y = q[1], z = q[2], w = q[3];
         const x2 = x + x, y2 = y + y, z2 = z + z;
         const xx = x * x2, yx = y * x2, yy = y * y2;
@@ -2877,10 +2916,10 @@ 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, out = new Mat3()) {
+    static normalFromMat4(a, out = mat3()) {
         const a00 = a[0], a01 = a[1], a02 = a[2], a03 = a[3];
         const a10 = a[4], a11 = a[5], a12 = a[6], a13 = a[7];
         const a20 = a[8], a21 = a[9], a22 = a[10], a23 = a[11];
@@ -2916,10 +2955,10 @@ 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, out = new Mat3()) {
+    static fromMat4(a, out = mat3()) {
         out[0] = a[0];
         out[1] = a[1];
         out[2] = a[2];
@@ -2936,10 +2975,10 @@ 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, height, out = new Mat3()) {
+    static projection(width, height, out = mat3()) {
         out[0] = 2 / width;
         out[1] = 0;
         out[2] = 0;
@@ -2965,10 +3004,10 @@ 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, out = index.ALWAYS_COPY ? new Mat3() : this) {
+    plus(b, out = index.ALWAYS_COPY ? mat3() : this) {
         out[0] = this[0] + b[0];
         out[1] = this[1] + b[1];
         out[2] = this[2] + b[2];
@@ -2984,10 +3023,10 @@ 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, out = index.ALWAYS_COPY ? new Mat3() : this) {
+    minus(b, out = index.ALWAYS_COPY ? mat3() : this) {
         out[0] = this[0] - b[0];
         out[1] = this[1] - b[1];
         out[2] = this[2] - b[2];
@@ -3003,10 +3042,10 @@ 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, out = index.ALWAYS_COPY ? new Mat3() : this) {
+    scaleScalar(b, out = index.ALWAYS_COPY ? mat3() : this) {
         out[0] = this[0] * b;
         out[1] = this[1] * b;
         out[2] = this[2] * b;
@@ -3023,10 +3062,10 @@ 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, scale, out = index.ALWAYS_COPY ? new Mat3() : this) {
+    multiplyScalarAndAdd(b, scale, out = index.ALWAYS_COPY ? mat3() : this) {
         out[0] = this[0] + b[0] * scale;
         out[1] = this[1] + b[1] * scale;
         out[2] = this[2] + b[2] * scale;
@@ -3086,7 +3125,7 @@ Mat3.prototype.mult = Mat3.prototype.multiply;
 Mat3.prototype.times = Mat3.prototype.multiply;
 Mat3.prototype.str = Mat3.prototype.toString;
 Mat3.prototype.multiplyScalar = Mat3.prototype.scaleScalar;
-const mat3 = Object.assign((...args) => {
+const createMat3 = (...args) => {
     const out = new Mat3();
     let i = 0;
     for (const a of args) {
@@ -3097,7 +3136,9 @@ const mat3 = Object.assign((...args) => {
                 out[i++] = v;
     }
     return out;
-}, Mat3);
+};
+Object.setPrototypeOf(createMat3, Mat3);
+const mat3 = createMat3;
 const mat3x3 = mat3;
 
 var _a;
@@ -3106,9 +3147,9 @@ var _a;
  * @extends Float32Array
  */
 class Mat4 extends Float32Array {
-    static get identity() { return new _a(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1); }
-    static get Identity() { return new _a(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1); }
-    static get IDENTITY() { return new _a(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1); }
+    static get identity() { return mat4(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1); }
+    static get Identity() { return mat4(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1); }
+    static get IDENTITY() { return mat4(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1); }
     /**
      * Creates a new 4x4 matrix
      *
@@ -3154,15 +3195,15 @@ class Mat4 extends Float32Array {
      * @returns {Mat4} a new 4x4 matrix
      */
     clone() {
-        return new _a(this[0], this[1], this[2], this[3], this[4], this[5], this[6], this[7], this[8], this[9], this[10], this[11], this[12], this[13], this[14], this[15]);
+        return mat4(this[0], this[1], this[2], this[3], this[4], this[5], this[6], this[7], this[8], this[9], this[10], this[11], this[12], this[13], this[14], this[15]);
     }
     /**
      * 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 = index.ALWAYS_COPY ? new _a() : this) {
+    transpose(out = index.ALWAYS_COPY ? mat4() : this) {
         if (out.exactEquals(this)) {
             const a01 = this[1], a02 = this[2], a03 = this[3];
             const a12 = this[6], a13 = this[7], a23 = this[11];
@@ -3202,10 +3243,10 @@ class Mat4 extends Float32Array {
     /**
      * 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 = index.ALWAYS_COPY ? new _a() : this) {
+    invert(out = index.ALWAYS_COPY ? mat4() : this) {
         const a00 = this[0], a01 = this[1], a02 = this[2], a03 = this[3];
         const a10 = this[4], a11 = this[5], a12 = this[6], a13 = this[7];
         const a20 = this[8], a21 = this[9], a22 = this[10], a23 = this[11];
@@ -3247,10 +3288,10 @@ class Mat4 extends Float32Array {
     /**
      * 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 = index.ALWAYS_COPY ? new _a() : this) {
+    adjoint(out = index.ALWAYS_COPY ? mat4() : this) {
         const a00 = this[0], a01 = this[1], a02 = this[2], a03 = this[3];
         const a10 = this[4], a11 = this[5], a12 = this[6], a13 = this[7];
         const a20 = this[8], a21 = this[9], a22 = this[10], a23 = this[11];
@@ -3302,7 +3343,7 @@ class Mat4 extends Float32Array {
             (a01 * a13 - a03 * a11) * (a20 * a32 - a22 * a30) +
             (a02 * a13 - a03 * a12) * (a20 * a31 - a21 * a30));
     }
-    multiply(b, out = index.ALWAYS_COPY ? new _a() : this) {
+    multiply(b, out = index.ALWAYS_COPY ? mat4() : this) {
         if (b instanceof Vec2)
             return b.transformMat4(this);
         if (b instanceof Vec3)
@@ -3348,10 +3389,10 @@ 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, out = index.ALWAYS_COPY ? new _a() : this) {
+    translate(v, out = index.ALWAYS_COPY ? mat4() : this) {
         const x = v[0], y = v[1], z = v[2];
         if (out.exactEquals(this)) {
             out[12] = this[0] * x + this[4] * y + this[8] * z + this[12];
@@ -3386,10 +3427,10 @@ 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, out = index.ALWAYS_COPY ? new _a() : this) {
+    scale(v, out = index.ALWAYS_COPY ? mat4() : this) {
         const x = v[0], y = v[1], z = v[2];
         out[0] = this[0] * x;
         out[1] = this[1] * x;
@@ -3414,10 +3455,10 @@ 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, axis, out = index.ALWAYS_COPY ? new _a() : this) {
+    rotate(rad, axis, out = index.ALWAYS_COPY ? mat4() : this) {
         let x = axis[0], y = axis[1], z = axis[2];
         let len = Math.sqrt(x * x + y * y + z * z);
         if (len < index.EPSILON)
@@ -3455,10 +3496,10 @@ 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, out = index.ALWAYS_COPY ? new _a() : this) {
+    rotateX(rad, out = index.ALWAYS_COPY ? mat4() : this) {
         const s = Math.sin(rad), c = Math.cos(rad);
         const a10 = this[4], a11 = this[5], a12 = this[6], a13 = this[7];
         const a20 = this[8], a21 = this[9], a22 = this[10], a23 = this[11];
@@ -3486,10 +3527,10 @@ 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, out = index.ALWAYS_COPY ? new _a() : this) {
+    rotateY(rad, out = index.ALWAYS_COPY ? mat4() : this) {
         const s = Math.sin(rad), c = Math.cos(rad);
         const a00 = this[0], a01 = this[1], a02 = this[2], a03 = this[3];
         const a20 = this[8], a21 = this[9], a22 = this[10], a23 = this[11];
@@ -3517,10 +3558,10 @@ 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, out = index.ALWAYS_COPY ? new _a() : this) {
+    rotateZ(rad, out = index.ALWAYS_COPY ? mat4() : this) {
         const s = Math.sin(rad), c = Math.cos(rad);
         const a00 = this[0], a01 = this[1], a02 = this[2], a03 = this[3];
         const a10 = this[4], a11 = this[5], a12 = this[6], a13 = this[7];
@@ -3676,10 +3717,10 @@ 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, out = new _a()) {
+    static fromTranslation(v, out = mat4()) {
         out[0] = out[5] = out[10] = out[15] = 1;
         out[1] = out[2] = out[3] = out[4] = out[6] = out[7] = out[8] = out[9] = out[11] = 0;
         out[12] = v[0];
@@ -3691,10 +3732,10 @@ 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, out = new _a()) {
+    static fromScaling(v, out = mat4()) {
         out[0] = v[0];
         out[5] = v[1];
         out[10] = v[2];
@@ -3707,10 +3748,10 @@ 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, axis, out = new _a()) {
+    static fromRotation(rad, axis, out = mat4()) {
         let x = axis[0], y = axis[1], z = axis[2];
         let len = Math.sqrt(x * x + y * y + z * z);
         if (len < index.EPSILON)
@@ -3740,10 +3781,10 @@ 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, out = new _a()) {
+    static fromXRotation(rad, out = mat4()) {
         const s = Math.sin(rad), c = Math.cos(rad);
         out[0] = 1;
         out[1] = out[2] = out[3] = out[4] = out[7] = out[8] = out[11] = out[12] = out[13] = out[14] = 0;
@@ -3758,10 +3799,10 @@ 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, out = new _a()) {
+    static fromYRotation(rad, out = mat4()) {
         const s = Math.sin(rad), c = Math.cos(rad);
         out[0] = c;
         out[1] = out[3] = out[4] = out[6] = out[7] = out[9] = out[11] = out[12] = out[13] = out[14] = 0;
@@ -3775,10 +3816,10 @@ 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, out = new _a()) {
+    static fromZRotation(rad, out = mat4()) {
         const s = Math.sin(rad), c = Math.cos(rad);
         out[0] = c;
         out[1] = s;
@@ -3793,10 +3834,10 @@ 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, v, out = new _a()) {
+    static fromRotationTranslation(q, v, out = mat4()) {
         const x = q[0], y = q[1], z = q[2], w = q[3];
         const x2 = x + x, y2 = y + y, z2 = z + z;
         const xx = x * x2, xy = x * y2, xz = x * z2;
@@ -3824,10 +3865,10 @@ 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, v, s, out = new _a()) {
+    static fromRotationTranslationScale(q, v, s, out = mat4()) {
         const x = q[0], y = q[1], z = q[2], w = q[3];
         const x2 = x + x, y2 = y + y, z2 = z + z;
         const xx = x * x2, xy = x * y2, xz = x * z2;
@@ -3857,10 +3898,10 @@ 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, v, s, o, out = new _a()) {
+    static fromRotationTranslationScaleOrigin(q, v, s, o, out = mat4()) {
         const x = q[0], y = q[1], z = q[2], w = q[3];
         const x2 = x + x, y2 = y + y, z2 = z + z;
         const xx = x * x2, xy = x * y2, xz = x * z2;
@@ -3897,10 +3938,10 @@ 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, out = new _a()) {
+    static fromQuat(q, out = mat4()) {
         const x = q[0], y = q[1], z = q[2], w = q[3];
         const x2 = x + x, y2 = y + y, z2 = z + z;
         const xx = x * x2, yx = y * x2, yy = y * y2;
@@ -3928,10 +3969,10 @@ 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, right, bottom, top, near, far, out = new _a()) {
+    static frustum(left, right, bottom, top, near, far, out = mat4()) {
         const rl = 1 / (right - left);
         const tb = 1 / (top - bottom);
         const nf = 1 / (near - far);
@@ -3955,10 +3996,10 @@ 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, aspect, near, far, out = new _a()) {
+    static perspectiveNO(fovy, aspect, near, far, out = mat4()) {
         const f = 1.0 / Math.tan(fovy / 2);
         const lh = index.LEFT_HANDED;
         out[0] = f / aspect;
@@ -3985,10 +4026,10 @@ 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, aspect, near, far, out = new _a()) {
+    static perspectiveZO(fovy, aspect, near, far, out = mat4()) {
         const f = 1.0 / Math.tan(fovy / 2);
         const lh = index.LEFT_HANDED;
         out[0] = f / aspect;
@@ -4022,10 +4063,10 @@ 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, near, far, out = new _a()) {
+    static perspectiveFromFieldOfView(fov, near, far, out = mat4()) {
         const upTan = Math.tan((fov.upDegrees * Math.PI) / 180.0);
         const downTan = Math.tan((fov.downDegrees * Math.PI) / 180.0);
         const leftTan = Math.tan((fov.leftDegrees * Math.PI) / 180.0);
@@ -4062,10 +4103,10 @@ 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, right, bottom, top, near, far, out = new _a()) {
+    static orthoNO(left, right, bottom, top, near, far, out = mat4()) {
         const lr = 1 / (left - right);
         const bt = 1 / (bottom - top);
         const nf = 1 / (near - far);
@@ -4099,10 +4140,10 @@ 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, right, bottom, top, near, far, out = new _a()) {
+    static orthoZO(left, right, bottom, top, near, far, out = mat4()) {
         const lr = 1 / (left - right);
         const bt = 1 / (bottom - top);
         const nf = 1 / (near - far);
@@ -4132,10 +4173,10 @@ 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, center, up, out = new _a()) {
+    static lookAt(eye, center, up, out = mat4()) {
         let x0, x1, x2, y0, y1, y2, z0, z1, z2, len;
         const eyex = eye[0], eyey = eye[1], eyez = eye[2];
         const upx = up[0], upy = up[1], upz = up[2];
@@ -4227,10 +4268,10 @@ 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, target, up, out = new _a()) {
+    static targetTo(eye, target, up, out = mat4()) {
         const eyex = eye[0], eyey = eye[1], eyez = eye[2];
         const upx = up[0], upy = up[1], upz = up[2];
         let z0, z1, z2;
@@ -4289,7 +4330,7 @@ class Mat4 extends Float32Array {
      * @param {Mat4} out the receiving matrix, defaults to a new Mat4
      * @returns {Mat4} out
      */
-    static infinitePerspective(fovy, aspect, near, out = new _a()) {
+    static infinitePerspective(fovy, aspect, near, out = mat4()) {
         const f = 1.0 / Math.tan(fovy / 2);
         const lh = index.LEFT_HANDED;
         out[0] = f / aspect;
@@ -4346,7 +4387,7 @@ class Mat4 extends Float32Array {
         const a10 = model[4], a11 = model[5], a12 = model[6], a13 = model[7];
         const a20 = model[8], a21 = model[9], a22 = model[10], a23 = model[11];
         const a30 = model[12], a31 = model[13], a32 = model[14], a33 = model[15];
-        const pm = new _a();
+        const pm = mat4();
         let b0 = proj[0], b1 = proj[1], b2 = proj[2], b3 = proj[3];
         pm[0] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;
         pm[1] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;
@@ -4404,10 +4445,10 @@ 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, out = index.ALWAYS_COPY ? new _a() : this) {
+    plus(b, out = index.ALWAYS_COPY ? mat4() : this) {
         out[0] = this[0] + b[0];
         out[1] = this[1] + b[1];
         out[2] = this[2] + b[2];
@@ -4430,10 +4471,10 @@ 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, out = index.ALWAYS_COPY ? new _a() : this) {
+    minus(b, out = index.ALWAYS_COPY ? mat4() : this) {
         out[0] = this[0] - b[0];
         out[1] = this[1] - b[1];
         out[2] = this[2] - b[2];
@@ -4456,10 +4497,10 @@ 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, out = index.ALWAYS_COPY ? new _a() : this) {
+    scaleScalar(b, out = index.ALWAYS_COPY ? mat4() : this) {
         out[0] = this[0] * b;
         out[1] = this[1] * b;
         out[2] = this[2] * b;
@@ -4483,10 +4524,10 @@ 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, scale, out = index.ALWAYS_COPY ? new _a() : this) {
+    multiplyScalarAndAdd(b, scale, out = index.ALWAYS_COPY ? mat4() : this) {
         out[0] = this[0] + b[0] * scale;
         out[1] = this[1] + b[1] * scale;
         out[2] = this[2] + b[2] * scale;
@@ -4550,7 +4591,7 @@ Mat4.prototype.mult = Mat4.prototype.multiply;
 Mat4.prototype.times = Mat4.prototype.multiply;
 Mat4.prototype.str = Mat4.prototype.toString;
 Mat4.prototype.multiplyScalar = Mat4.prototype.scaleScalar;
-const mat4 = Object.assign((...args) => {
+const createMat4 = (...args) => {
     const out = new Mat4();
     let i = 0;
     for (const a of args) {
@@ -4561,7 +4602,9 @@ const mat4 = Object.assign((...args) => {
                 out[i++] = v;
     }
     return out;
-}, Mat4);
+};
+Object.setPrototypeOf(createMat4, Mat4);
+const mat4 = createMat4;
 const mat4x4 = mat4;
 
 /**
@@ -4569,9 +4612,9 @@ const mat4x4 = mat4;
  * @extends Vec4
  */
 class Quat extends Float32Array {
-    static get identity() { return new Quat(0, 0, 0, 1); }
-    static get Identity() { return new Quat(0, 0, 0, 1); }
-    static get IDENTITY() { return new Quat(0, 0, 0, 1); }
+    static get identity() { return quat(0, 0, 0, 1); }
+    static get Identity() { return quat(0, 0, 0, 1); }
+    static get IDENTITY() { return quat(0, 0, 0, 1); }
     /**
      * Creates a new quaternion
      *
@@ -4591,10 +4634,10 @@ 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, out = index.ALWAYS_COPY ? new Quat() : this) {
+    multiply(b, out = index.ALWAYS_COPY ? quat() : this) {
         if (typeof b === 'number') {
             out[0] = this[0] * b;
             out[1] = this[1] * b;
@@ -4632,7 +4675,7 @@ 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, rad, out = index.ALWAYS_COPY ? quat() : this) {
@@ -4687,7 +4730,7 @@ 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, out = index.ALWAYS_COPY ? quat() : this) {
@@ -4704,7 +4747,7 @@ 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, out = index.ALWAYS_COPY ? quat() : this) {
@@ -4721,7 +4764,7 @@ 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, out = index.ALWAYS_COPY ? quat() : this) {
@@ -4764,7 +4807,7 @@ 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 = index.ALWAYS_COPY ? quat() : this) {
@@ -4798,7 +4841,7 @@ 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 = index.ALWAYS_COPY ? quat() : this) {
@@ -4872,7 +4915,7 @@ 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, t, out = index.ALWAYS_COPY ? quat() : this) {
@@ -4951,7 +4994,7 @@ 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 = index.ALWAYS_COPY ? quat() : this) {
@@ -4982,7 +5025,7 @@ 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 = index.ALWAYS_COPY ? quat() : this) {
@@ -5203,11 +5246,12 @@ 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
      */
-    normalize(out = index.ALWAYS_COPY ? new Quat() : this) {
-        const x = this[0], y = this[1], z = this[2], w = this[3];
+    static normalize(q, out = quat()) {
+        const x = q[0], y = q[1], z = q[2], w = q[3];
         let len = x * x + y * y + z * z + w * w;
         if (len > 0) {
             len = 1.0 / Math.sqrt(len);
@@ -5218,6 +5262,15 @@ class Quat extends Float32Array {
         out[3] = w * len;
         return out;
     }
+    /**
+     * Normalizes a quaternion
+     *
+     * @param {Quat} out the receiving vector, defaults to new quat()
+     * @returns {Quat} out
+     */
+    normalize(out = index.ALWAYS_COPY ? quat() : this) {
+        return Quat.normalize(this, out);
+    }
     /**
      * Creates a quaternion that looks along the given direction vector
      *
@@ -5226,7 +5279,7 @@ class Quat extends Float32Array {
      * @param {Quat} out the receiving quaternion, defaults to quat()
      * @returns {Quat} out
      */
-    static quatLookAt(direction, up, out = new Quat()) {
+    static quatLookAt(direction, up, out = quat()) {
         const f = vec3(direction[0], direction[1], direction[2]).normalize();
         const s = Vec3.cross(f, up).normalize();
         const u = Vec3.cross(s, f);
@@ -5346,7 +5399,10 @@ Quat.prototype.mul = Quat.prototype.multiply;
 Quat.prototype.scale = Quat.prototype.multiply;
 Quat.prototype.times = Quat.prototype.multiply;
 Quat.prototype.str = Quat.prototype.toString;
-const quat = Object.assign((x = 0, y = 0, z = 0, w = 1) => new Quat(x, y, z, w), Quat);
+Quat.prototype.normalized = Quat.prototype.normalize;
+const createQuat = (x = 0, y = 0, z = 0, w = 1) => new Quat(x, y, z, w);
+Object.setPrototypeOf(createQuat, Quat);
+const quat = createQuat;
 
 /**
  * Dual Quaternion for rigid body transformations (rotation + translation)
@@ -5354,9 +5410,9 @@ const quat = Object.assign((x = 0, y = 0, z = 0, w = 1) => new Quat(x, y, z, w),
  * @extends Float32Array
  */
 class Quat2 extends Float32Array {
-    static get identity() { return new Quat2(0, 0, 0, 1, 0, 0, 0, 0); }
-    static get Identity() { return new Quat2(0, 0, 0, 1, 0, 0, 0, 0); }
-    static get IDENTITY() { return new Quat2(0, 0, 0, 1, 0, 0, 0, 0); }
+    static get identity() { return quat2(0, 0, 0, 1, 0, 0, 0, 0); }
+    static get Identity() { return quat2(0, 0, 0, 1, 0, 0, 0, 0); }
+    static get IDENTITY() { return quat2(0, 0, 0, 1, 0, 0, 0, 0); }
     /**
      * Creates a new dual quaternion
      *
@@ -5375,11 +5431,11 @@ 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
          */
         // @ts-ignore
-        this.multiply = (b, out = index.ALWAYS_COPY ? new Quat2() : this) => {
+        this.multiply = (b, out = index.ALWAYS_COPY ? quat2() : this) => {
             const ax0 = this[0], ay0 = this[1], az0 = this[2], aw0 = this[3];
             const bx1 = b[4], by1 = b[5], bz1 = b[6], bw1 = b[7];
             const ax1 = this[4], ay1 = this[5], az1 = this[6], aw1 = this[7];
@@ -5481,7 +5537,7 @@ class Quat2 extends Float32Array {
      * @param {Quat2} out the receiving dual quaternion, defaults to quat2()
      * @returns {Quat2} out
      */
-    static fromRotationTranslation(q, t, out = new Quat2()) {
+    static fromRotationTranslation(q, t, out = quat2()) {
         const ax = t[0] * 0.5, ay = t[1] * 0.5, az = t[2] * 0.5;
         const bx = q[0], by = q[1], bz = q[2], bw = q[3];
         out[0] = bx;
@@ -5501,7 +5557,7 @@ class Quat2 extends Float32Array {
      * @param {Quat2} out the receiving dual quaternion, defaults to quat2()
      * @returns {Quat2} out
      */
-    static fromTranslation(t, out = new Quat2()) {
+    static fromTranslation(t, out = quat2()) {
         out[0] = 0;
         out[1] = 0;
         out[2] = 0;
@@ -5519,7 +5575,7 @@ class Quat2 extends Float32Array {
      * @param {Quat2} out the receiving dual quaternion, defaults to quat2()
      * @returns {Quat2} out
      */
-    static fromRotation(q, out = new Quat2()) {
+    static fromRotation(q, out = quat2()) {
         out[0] = q[0];
         out[1] = q[1];
         out[2] = q[2];
@@ -5537,7 +5593,7 @@ class Quat2 extends Float32Array {
      * @param {Quat2} out the receiving dual quaternion, defaults to quat2()
      * @returns {Quat2} out
      */
-    static fromMat4(m, out = new Quat2()) {
+    static fromMat4(m, out = quat2()) {
         const r = m.getRotation();
         const t = m.getTranslation();
         return Quat2.fromRotationTranslation(r, t, out);
@@ -5548,16 +5604,16 @@ class Quat2 extends Float32Array {
      * @returns {Quat2} a new dual quaternion
      */
     clone() {
-        return new Quat2(this[0], this[1], this[2], this[3], this[4], this[5], this[6], this[7]);
+        return quat2(this[0], this[1], this[2], this[3], this[4], this[5], this[6], this[7]);
     }
     /**
      * 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, out = index.ALWAYS_COPY ? new Quat2() : this) {
+    translate(v, out = index.ALWAYS_COPY ? quat2() : this) {
         const ax1 = this[0], ay1 = this[1], az1 = this[2], aw1 = this[3];
         const bx1 = v[0] * 0.5, by1 = v[1] * 0.5, bz1 = v[2] * 0.5;
         const ax2 = this[4], ay2 = this[5], az2 = this[6], aw2 = this[7];
@@ -5574,10 +5630,10 @@ class Quat2 extends Float32Array {
     /**
      * 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 = index.ALWAYS_COPY ? new Quat2() : this) {
+    conjugate(out = index.ALWAYS_COPY ? quat2() : this) {
         out[0] = -this[0];
         out[1] = -this[1];
         out[2] = -this[2];
@@ -5591,10 +5647,10 @@ class Quat2 extends Float32Array {
     /**
      * 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 = index.ALWAYS_COPY ? new Quat2() : this) {
+    invert(out = index.ALWAYS_COPY ? quat2() : this) {
         const sqlen = this.squaredLength();
         out[0] = -this[0] / sqlen;
         out[1] = -this[1] / sqlen;
@@ -5626,16 +5682,17 @@ 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
      */
-    normalize(out = index.ALWAYS_COPY ? new Quat2() : this) {
-        let magnitude = this.squaredLength();
+    static normalize(q, out = quat2()) {
+        let magnitude = q.squaredLength();
         if (magnitude > 0) {
             magnitude = Math.sqrt(magnitude);
-            const a0 = this[0] / magnitude, a1 = this[1] / magnitude;
-            const a2 = this[2] / magnitude, a3 = this[3] / magnitude;
-            const b0 = this[4], b1 = this[5], b2 = this[6], b3 = this[7];
+            const a0 = q[0] / magnitude, a1 = q[1] / magnitude;
+            const a2 = q[2] / magnitude, a3 = q[3] / magnitude;
+            const b0 = q[4], b1 = q[5], b2 = q[6], b3 = q[7];
             const a_dot_b = a0 * b0 + a1 * b1 + a2 * b2 + a3 * b3;
             out[0] = a0;
             out[1] = a1;
@@ -5648,6 +5705,15 @@ class Quat2 extends Float32Array {
         }
         return out;
     }
+    /**
+     * Normalize the dual quaternion
+     *
+     * @param {Quat2} out the receiving dual quaternion, defaults to new quat2()
+     * @returns {Quat2} out
+     */
+    normalize(out = index.ALWAYS_COPY ? quat2() : this) {
+        return Quat2.normalize(this, out);
+    }
     /**
      * Dot product of the real parts of two dual quaternions
      *
@@ -5667,7 +5733,7 @@ class Quat2 extends Float32Array {
      * @param {Quat2} out the receiving dual quaternion, defaults to quat2()
      * @returns {Quat2} out
      */
-    static lerp(a, b, t, out = new Quat2()) {
+    static lerp(a, b, t, out = quat2()) {
         const mt = 1 - t;
         if (Quat2.dot(a, b) < 0)
             t = -t;
@@ -5685,10 +5751,10 @@ 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, out = index.ALWAYS_COPY ? new Quat2() : this) {
+    plus(b, out = index.ALWAYS_COPY ? quat2() : this) {
         out[0] = this[0] + b[0];
         out[1] = this[1] + b[1];
         out[2] = this[2] + b[2];
@@ -5703,10 +5769,10 @@ 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, out = index.ALWAYS_COPY ? new Quat2() : this) {
+    scale(s, out = index.ALWAYS_COPY ? quat2() : this) {
         out[0] = this[0] * s;
         out[1] = this[1] * s;
         out[2] = this[2] * s;
@@ -5768,17 +5834,20 @@ class Quat2 extends Float32Array {
 }
 // @aliases
 Quat2.prototype.sqrLen = Quat2.prototype.squaredLength;
+Quat2.prototype.normalized = Quat2.prototype.normalize;
 Quat2.prototype.str = Quat2.prototype.toString;
 Quat2.prototype.add = Quat2.prototype.plus;
-const quat2 = Object.assign((x1 = 0, y1 = 0, z1 = 0, w1 = 1, x2 = 0, y2 = 0, z2 = 0, w2 = 0) => new Quat2(x1, y1, z1, w1, x2, y2, z2, w2), Quat2);
+const createQuat2 = (x1 = 0, y1 = 0, z1 = 0, w1 = 1, x2 = 0, y2 = 0, z2 = 0, w2 = 0) => new Quat2(x1, y1, z1, w1, x2, y2, z2, w2);
+Object.setPrototypeOf(createQuat2, Quat2);
+const quat2 = createQuat2;
 
 /** 2x2 Matrix in column-major order
  * @extends Float32Array
  */
 class Mat2 extends Float32Array {
-    static get identity() { return new Mat2(1, 0, 0, 1); }
-    static get Identity() { return new Mat2(1, 0, 0, 1); }
-    static get IDENTITY() { return new Mat2(1, 0, 0, 1); }
+    static get identity() { return mat2(1, 0, 0, 1); }
+    static get Identity() { return mat2(1, 0, 0, 1); }
+    static get IDENTITY() { return mat2(1, 0, 0, 1); }
     /**
      * Creates a new Mat2
      *
@@ -5800,15 +5869,15 @@ class Mat2 extends Float32Array {
      * @returns {Mat2} a new Mat2
      */
     clone() {
-        return new Mat2(this[0], this[1], this[2], this[3]);
+        return mat2(this[0], this[1], this[2], this[3]);
     }
     /**
      * 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 = index.ALWAYS_COPY ? new Mat2() : this) {
+    transpose(out = index.ALWAYS_COPY ? mat2() : this) {
         if (out.exactEquals(this)) {
             const tmp = out[1];
             out[1] = out[2];
@@ -5825,10 +5894,10 @@ class Mat2 extends Float32Array {
     /**
      * 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 = index.ALWAYS_COPY ? new Mat2() : this) {
+    invert(out = index.ALWAYS_COPY ? mat2() : this) {
         const a0 = this[0], a1 = this[1], a2 = this[2], a3 = this[3];
         // Calculate the determinant
         let det = a0 * a3 - a2 * a1;
@@ -5844,10 +5913,10 @@ class Mat2 extends Float32Array {
     /**
      * 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 = index.ALWAYS_COPY ? new Mat2() : this) {
+    adjoint(out = index.ALWAYS_COPY ? mat2() : this) {
         let a0 = this[0];
         out[0] = this[3];
         out[1] = -this[1];
@@ -5867,10 +5936,10 @@ 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, out = index.ALWAYS_COPY ? new Mat2() : this) {
+    rotate(rad, out = index.ALWAYS_COPY ? mat2() : this) {
         const a0 = this[0], a1 = this[1], a2 = this[2], a3 = this[3];
         const s = Math.sin(rad), c = Math.cos(rad);
         out[0] = a0 * c + a2 * s;
@@ -5883,10 +5952,10 @@ 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, out = index.ALWAYS_COPY ? new Mat2() : this) {
+    scale(v, out = index.ALWAYS_COPY ? mat2() : this) {
         const v0 = v[0], v1 = v[1];
         out[0] = this[0] * v0;
         out[1] = this[1] * v0;
@@ -5898,10 +5967,10 @@ 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, out = new Mat2()) {
+    static fromRotation(rad, out = mat2()) {
         const s = Math.sin(rad), c = Math.cos(rad);
         out[0] = c;
         out[1] = s;
@@ -5913,10 +5982,10 @@ 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, out = new Mat2()) {
+    static fromScaling(v, out = mat2()) {
         out[0] = v[0];
         out[1] = out[2] = 0;
         out[3] = v[1];
@@ -5944,7 +6013,7 @@ class Mat2 extends Float32Array {
      * @param {Mat2} D the diagonal matrix
      * @param {Mat2} U the upper triangular matrix
      */
-    LDU(L = new Mat2(), D = new Mat2(), U = new Mat2()) {
+    LDU(L = mat2(), D = mat2(), U = mat2()) {
         L[2] = this[2] / this[0];
         U[0] = this[0];
         U[1] = this[1];
@@ -5955,10 +6024,10 @@ 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, out = index.ALWAYS_COPY ? new Mat2() : this) {
+    plus(b, out = index.ALWAYS_COPY ? mat2() : this) {
         out[0] = this[0] + b[0];
         out[1] = this[1] + b[1];
         out[2] = this[2] + b[2];
@@ -5969,17 +6038,17 @@ 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, out = index.ALWAYS_COPY ? new Mat2() : this) {
+    minus(b, out = index.ALWAYS_COPY ? mat2() : this) {
         out[0] = this[0] - b[0];
         out[1] = this[1] - b[1];
         out[2] = this[2] - b[2];
         out[3] = this[3] - b[3];
         return out;
     }
-    multiply(b, out = index.ALWAYS_COPY ? new Mat2() : this) {
+    multiply(b, out = index.ALWAYS_COPY ? mat2() : this) {
         if (b instanceof Vec2)
             return b.transformMat2(this);
         const a0 = this[0], a1 = this[1], a2 = this[2], a3 = this[3];
@@ -6013,10 +6082,10 @@ 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, out = index.ALWAYS_COPY ? new Mat2() : this) {
+    scaleScalar(b, out = index.ALWAYS_COPY ? mat2() : this) {
         out[0] = this[0] * b;
         out[1] = this[1] * b;
         out[2] = this[2] * b;
@@ -6053,9 +6122,9 @@ const mat2x2 = mat2;
  * @extends Float32Array
  */
 class Mat2x3 extends Float32Array {
-    static get identity() { return new Mat2x3(1, 0, 0, 1, 0, 0); }
-    static get Identity() { return new Mat2x3(1, 0, 0, 1, 0, 0); }
-    static get IDENTITY() { return new Mat2x3(1, 0, 0, 1, 0, 0); }
+    static get identity() { return mat2x3(1, 0, 0, 1, 0, 0); }
+    static get Identity() { return mat2x3(1, 0, 0, 1, 0, 0); }
+    static get IDENTITY() { return mat2x3(1, 0, 0, 1, 0, 0); }
     /**
      * Creates a new Mat2x3
      *
@@ -6078,10 +6147,10 @@ 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 = index.ALWAYS_COPY ? new Mat2x3() : this) {
+    invert(out = index.ALWAYS_COPY ? mat2x3() : this) {
         const aa = this[0], ab = this[1], ac = this[2], ad = this[3];
         const atx = this[4], aty = this[5];
         let det = aa * ad - ab * ac;
@@ -6108,10 +6177,10 @@ 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, out = index.ALWAYS_COPY ? new Mat2x3() : this) {
+    rotate(rad, out = index.ALWAYS_COPY ? mat2x3() : this) {
         const a0 = this[0], a1 = this[1], a2 = this[2], a3 = this[3], a4 = this[4], a5 = this[5];
         const s = Math.sin(rad);
         const c = Math.cos(rad);
@@ -6127,10 +6196,10 @@ 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, out = index.ALWAYS_COPY ? new Mat2x3() : this) {
+    scale(v, out = index.ALWAYS_COPY ? mat2x3() : this) {
         const a0 = this[0], a1 = this[1], a2 = this[2], a3 = this[3], a4 = this[4], a5 = this[5];
         const v0 = v[0], v1 = v[1];
         out[0] = a0 * v0;
@@ -6145,10 +6214,10 @@ 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, out = index.ALWAYS_COPY ? new Mat2x3() : this) {
+    translate(v, out = index.ALWAYS_COPY ? mat2x3() : this) {
         const a0 = this[0], a1 = this[1], a2 = this[2], a3 = this[3], a4 = this[4], a5 = this[5];
         const v0 = v[0], v1 = v[1];
         out[0] = a0;
@@ -6163,10 +6232,10 @@ 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, out = new Mat2x3()) {
+    static fromRotation(rad, out = mat2x3()) {
         const s = Math.sin(rad), c = Math.cos(rad);
         out[0] = c;
         out[1] = s;
@@ -6179,10 +6248,10 @@ 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, out = new Mat2x3()) {
+    static fromScaling(v, out = mat2x3()) {
         out[0] = v[0];
         out[1] = out[2] = 0;
         out[3] = v[1];
@@ -6193,10 +6262,10 @@ 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, out = new Mat2x3()) {
+    static fromTranslation(v, out = mat2x3()) {
         out[0] = out[3] = 1;
         out[1] = out[2] = 0;
         out[4] = v[0];
@@ -6223,10 +6292,10 @@ 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, out = index.ALWAYS_COPY ? new Mat2x3() : this) {
+    plus(b, out = index.ALWAYS_COPY ? mat2x3() : this) {
         out[0] = this[0] + b[0];
         out[1] = this[1] + b[1];
         out[2] = this[2] + b[2];
@@ -6239,10 +6308,10 @@ 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, out = index.ALWAYS_COPY ? new Mat2x3() : this) {
+    minus(b, out = index.ALWAYS_COPY ? mat2x3() : this) {
         out[0] = this[0] - b[0];
         out[1] = this[1] - b[1];
         out[2] = this[2] - b[2];
@@ -6251,7 +6320,7 @@ class Mat2x3 extends Float32Array {
         out[5] = this[5] - b[5];
         return out;
     }
-    multiply(b, out = index.ALWAYS_COPY ? new Mat2x3() : this) {
+    multiply(b, out = index.ALWAYS_COPY ? mat2x3() : this) {
         if (b instanceof Vec2)
             return b.transformMat2x3(this);
         const a0 = this[0], a1 = this[1], a2 = this[2], a3 = this[3], a4 = this[4], a5 = this[5];
@@ -6288,10 +6357,10 @@ 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, out = index.ALWAYS_COPY ? new Mat2x3() : this) {
+    scaleScalar(b, out = index.ALWAYS_COPY ? mat2x3() : this) {
         out[0] = this[0] * b;
         out[1] = this[1] * b;
         out[2] = this[2] * b;
@@ -6306,7 +6375,7 @@ class Mat2x3 extends Float32Array {
      * @returns {Mat2x3} a new Mat2x3
      */
     clone() {
-        return new Mat2x3(this[0], this[1], this[2], this[3], this[4], this[5]);
+        return mat2x3(this[0], this[1], this[2], this[3], this[4], this[5]);
     }
 }
 // @aliases
@@ -6318,7 +6387,20 @@ Mat2x3.prototype.mult = Mat2x3.prototype.multiply;
 Mat2x3.prototype.times = Mat2x3.prototype.multiply;
 Mat2x3.prototype.str = Mat2x3.prototype.toString;
 Mat2x3.prototype.multiplyScalar = Mat2x3.prototype.scaleScalar;
-const mat2x3 = Object.assign((a = 0, b = 0, c = 0, d = 0, tx = 0, ty = 0) => new Mat2x3(a, b, c, d, tx, ty), Mat2x3);
+const createMat2x3 = (...args) => {
+    const out = new Mat2x3();
+    let i = 0;
+    for (const a of args) {
+        if (typeof a === 'number')
+            out[i++] = a;
+        else
+            for (const v of a)
+                out[i++] = v;
+    }
+    return out;
+};
+Object.setPrototypeOf(createMat2x3, Mat2x3);
+const mat2x3 = createMat2x3;
 const mat2d = mat2x3;
 
 function makeArr(a) {