glmaths 0.0.2 → 0.0.4

package/dist/cjs/glmaths.js

@@ -7,20 +7,20 @@ Object.defineProperty(exports, '__esModule', { value: true });
  * @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
@@ -42,10 +42,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;
@@ -62,10 +62,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;
@@ -82,10 +82,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;
@@ -102,10 +102,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;
@@ -118,7 +118,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];
@@ -132,18 +132,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];
@@ -152,13 +152,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)
@@ -169,12 +169,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)
@@ -205,7 +205,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
      */
@@ -214,7 +214,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
      */
@@ -223,104 +223,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
@@ -340,7 +340,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
@@ -371,10 +371,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;
@@ -414,10 +414,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;
@@ -430,10 +430,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;
@@ -450,7 +450,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]);
@@ -463,7 +463,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]);
@@ -478,7 +478,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];
@@ -499,7 +499,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;
@@ -521,7 +521,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];
@@ -537,14 +537,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];
@@ -553,13 +553,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];
@@ -568,14 +568,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];
@@ -584,12 +584,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];
@@ -598,14 +598,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];
@@ -614,12 +614,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];
@@ -637,7 +637,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;
@@ -658,7 +658,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;
@@ -677,10 +677,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;
@@ -691,10 +691,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];
@@ -707,10 +707,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) {
@@ -729,10 +729,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;
@@ -746,10 +746,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;
@@ -769,10 +769,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;
@@ -797,22 +797,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]);
@@ -823,10 +823,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];
@@ -843,10 +843,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;
@@ -863,10 +863,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;
@@ -884,10 +884,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];
@@ -905,10 +905,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]);
@@ -917,10 +917,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;
@@ -929,10 +929,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);
@@ -942,10 +942,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];
@@ -956,10 +956,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;
@@ -972,10 +972,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;
@@ -1009,6 +1009,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) => {
@@ -1033,14 +1034,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
@@ -1066,10 +1067,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;
@@ -1088,10 +1089,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;
@@ -1110,10 +1111,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;
@@ -1132,10 +1133,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;
@@ -1150,7 +1151,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];
@@ -1168,17 +1169,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];
@@ -1190,10 +1191,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) {
@@ -1245,10 +1265,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]);
@@ -1258,10 +1278,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]);
@@ -1271,10 +1291,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]);
@@ -1284,10 +1304,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];
@@ -1295,12 +1315,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
@@ -1314,10 +1334,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;
@@ -1355,10 +1375,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;
@@ -1401,10 +1421,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;
@@ -1417,10 +1437,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]);
@@ -1432,10 +1452,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]);
@@ -1451,7 +1471,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];
@@ -1475,7 +1495,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;
@@ -1499,7 +1519,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];
@@ -1526,7 +1546,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;
@@ -1539,7 +1559,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]);
@@ -1554,7 +1574,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];
@@ -1577,7 +1597,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;
@@ -1599,7 +1619,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;
@@ -1622,7 +1642,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];
@@ -1647,7 +1667,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]);
@@ -1660,7 +1680,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;
@@ -1673,7 +1693,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);
@@ -1687,7 +1707,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;
@@ -1702,7 +1722,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;
@@ -1729,7 +1749,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;
@@ -1753,6 +1773,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();
@@ -1838,12 +1859,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
      *
@@ -1863,10 +1884,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;
@@ -1881,10 +1902,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;
@@ -1899,10 +1920,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;
@@ -1917,10 +1938,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;
@@ -1935,10 +1956,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];
@@ -1953,10 +1974,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;
@@ -1970,15 +1991,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];
@@ -1986,11 +2007,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) {
@@ -2040,10 +2078,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;
@@ -2051,10 +2089,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;
@@ -2062,10 +2100,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;
@@ -2073,10 +2111,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;
@@ -2086,16 +2124,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);
@@ -2118,7 +2156,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;
@@ -2212,7 +2250,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;
@@ -2225,7 +2263,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;
@@ -2237,7 +2275,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;
@@ -2250,7 +2288,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);
@@ -2273,7 +2311,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;
@@ -2292,7 +2330,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];
@@ -2308,10 +2346,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;
@@ -2319,10 +2357,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;
@@ -2330,10 +2368,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;
@@ -2341,10 +2379,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;
@@ -2354,10 +2392,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);
@@ -2375,10 +2413,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;
@@ -2388,10 +2426,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;
@@ -2406,10 +2444,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;
@@ -2425,10 +2463,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];
@@ -2443,10 +2481,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;
@@ -2456,10 +2494,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];
@@ -2469,10 +2507,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];
@@ -2482,10 +2520,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];
@@ -2500,7 +2538,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;
@@ -2513,7 +2551,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];
@@ -2537,6 +2575,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;
@@ -2563,9 +2602,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
      *
@@ -2597,15 +2636,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];
@@ -2631,10 +2670,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];
@@ -2659,10 +2698,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];
@@ -2688,7 +2727,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)
@@ -2714,10 +2753,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];
@@ -2737,10 +2776,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];
@@ -2760,10 +2799,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];
@@ -2780,10 +2819,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;
@@ -2799,10 +2838,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;
@@ -2819,10 +2858,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;
@@ -2838,10 +2877,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;
@@ -2857,10 +2896,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;
@@ -2881,10 +2920,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];
@@ -2920,10 +2959,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];
@@ -2940,10 +2979,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;
@@ -2969,10 +3008,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];
@@ -2988,10 +3027,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];
@@ -3007,10 +3046,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;
@@ -3027,10 +3066,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;
@@ -3090,7 +3129,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) {
@@ -3101,7 +3140,9 @@ const mat3 = Object.assign((...args) => {
                 out[i++] = v;
     }
     return out;
-}, Mat3);
+};
+Object.setPrototypeOf(createMat3, Mat3);
+const mat3 = createMat3;
 const mat3x3 = mat3;
 
 var _a;
@@ -3110,9 +3151,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
      *
@@ -3158,15 +3199,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];
@@ -3206,10 +3247,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];
@@ -3251,10 +3292,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];
@@ -3306,7 +3347,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)
@@ -3352,10 +3393,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];
@@ -3390,10 +3431,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;
@@ -3418,10 +3459,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)
@@ -3459,10 +3500,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];
@@ -3490,10 +3531,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];
@@ -3521,10 +3562,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];
@@ -3680,10 +3721,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];
@@ -3695,10 +3736,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];
@@ -3711,10 +3752,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)
@@ -3744,10 +3785,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;
@@ -3762,10 +3803,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;
@@ -3779,10 +3820,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;
@@ -3797,10 +3838,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;
@@ -3828,10 +3869,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;
@@ -3861,10 +3902,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;
@@ -3901,10 +3942,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;
@@ -3932,10 +3973,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);
@@ -3959,10 +4000,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;
@@ -3989,10 +4030,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;
@@ -4026,10 +4067,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);
@@ -4066,10 +4107,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);
@@ -4103,10 +4144,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);
@@ -4136,10 +4177,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];
@@ -4231,10 +4272,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;
@@ -4293,7 +4334,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;
@@ -4350,7 +4391,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;
@@ -4408,10 +4449,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];
@@ -4434,10 +4475,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];
@@ -4460,10 +4501,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;
@@ -4487,10 +4528,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;
@@ -4554,7 +4595,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) {
@@ -4565,7 +4606,9 @@ const mat4 = Object.assign((...args) => {
                 out[i++] = v;
     }
     return out;
-}, Mat4);
+};
+Object.setPrototypeOf(createMat4, Mat4);
+const mat4 = createMat4;
 const mat4x4 = mat4;
 
 /**
@@ -4573,9 +4616,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
      *
@@ -4595,10 +4638,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;
@@ -4636,7 +4679,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) {
@@ -4691,7 +4734,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) {
@@ -4708,7 +4751,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) {
@@ -4725,7 +4768,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) {
@@ -4768,7 +4811,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) {
@@ -4802,7 +4845,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) {
@@ -4876,7 +4919,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) {
@@ -4955,7 +4998,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) {
@@ -4986,7 +5029,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) {
@@ -5207,11 +5250,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);
@@ -5222,6 +5266,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
      *
@@ -5230,7 +5283,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);
@@ -5350,7 +5403,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)
@@ -5358,9 +5414,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
      *
@@ -5379,11 +5435,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];
@@ -5485,7 +5541,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;
@@ -5505,7 +5561,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;
@@ -5523,7 +5579,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];
@@ -5541,7 +5597,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);
@@ -5552,16 +5608,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];
@@ -5578,10 +5634,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];
@@ -5595,10 +5651,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;
@@ -5630,16 +5686,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;
@@ -5652,6 +5709,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
      *
@@ -5671,7 +5737,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;
@@ -5689,10 +5755,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];
@@ -5707,10 +5773,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;
@@ -5772,17 +5838,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
      *
@@ -5804,15 +5873,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];
@@ -5829,10 +5898,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;
@@ -5848,10 +5917,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];
@@ -5871,10 +5940,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;
@@ -5887,10 +5956,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;
@@ -5902,10 +5971,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;
@@ -5917,10 +5986,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];
@@ -5948,7 +6017,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];
@@ -5959,10 +6028,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];
@@ -5973,17 +6042,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];
@@ -6017,10 +6086,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;
@@ -6057,9 +6126,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
      *
@@ -6082,10 +6151,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;
@@ -6112,10 +6181,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);
@@ -6131,10 +6200,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;
@@ -6149,10 +6218,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;
@@ -6167,10 +6236,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;
@@ -6183,10 +6252,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];
@@ -6197,10 +6266,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];
@@ -6227,10 +6296,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];
@@ -6243,10 +6312,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];
@@ -6255,7 +6324,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];
@@ -6292,10 +6361,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;
@@ -6310,7 +6379,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
@@ -6322,7 +6391,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) {