@vertexvis/geometry 1.0.2-canary.2 → 1.0.2-canary.20

package/dist/bundle.js

@@ -1,5 +1,3 @@
-import { __assign, __spreadArray } from 'tslib';
-
 /**
  * Clamps the given value between `min` and `max`.
  *
@@ -29,24 +27,22 @@ function lerp$2(a, b, t) {
 /**
  * Returns a new `Point` with the given horizontal and vertical position.
  */
-function create$d(x, y) {
-    if (x === void 0) { x = 0; }
-    if (y === void 0) { y = 0; }
-    return { x: x, y: y };
+function create$d(x = 0, y = 0) {
+    return { x, y };
 }
 /**
  * Converts a polar coordinate (length and angle) into a Cartesian coordinate.
  */
 function polar(length, radians) {
-    var x = Math.cos(radians) * length;
-    var y = Math.sin(radians) * length;
+    const x = Math.cos(radians) * length;
+    const y = Math.sin(radians) * length;
     return create$d(x, y);
 }
 /**
  * Returns the distance between two points.
  */
 function distance$2(a, b) {
-    var delta = subtract$1(a, b);
+    const delta = subtract$1(a, b);
     return Math.sqrt(delta.x * delta.x + delta.y * delta.y);
 }
 /**
@@ -118,7 +114,7 @@ function magnitude$2(pt) {
  * Transforms a vector into the corresponding normal (unit) vector.
  */
 function normalizeVector(pt) {
-    var magnitudeOfPoint = magnitude$2(pt);
+    const magnitudeOfPoint = magnitude$2(pt);
     if (magnitudeOfPoint === 0) {
         return create$d(0, 0);
     }
@@ -136,19 +132,19 @@ function normalDirectionVector(ptA, ptB) {
  * Returns a vector orthogonal to the vector between the two given points.
  */
 function orthogonalVector(ptA, ptB) {
-    var unitVectorBetweenPoints = normalDirectionVector(ptA, ptB);
+    const unitVectorBetweenPoints = normalDirectionVector(ptA, ptB);
     // Handle vectors that are parallel to the x or y axis
     if (unitVectorBetweenPoints.x === 0 || unitVectorBetweenPoints.y === 0) {
         return create$d(-1 * unitVectorBetweenPoints.y, unitVectorBetweenPoints.x);
     }
     if (Math.abs(unitVectorBetweenPoints.x) > Math.abs(unitVectorBetweenPoints.y)) {
-        var vectorXValue = 1 - Math.pow(unitVectorBetweenPoints.x, 2);
-        var vectorYValue = -1 * unitVectorBetweenPoints.x * unitVectorBetweenPoints.y;
+        const vectorXValue = 1 - Math.pow(unitVectorBetweenPoints.x, 2);
+        const vectorYValue = -1 * unitVectorBetweenPoints.x * unitVectorBetweenPoints.y;
         return normalizeVector(create$d(vectorXValue, vectorYValue));
     }
     else {
-        var vectorXValue = -1 * unitVectorBetweenPoints.x * unitVectorBetweenPoints.y;
-        var vectorYValue = 1 - Math.pow(unitVectorBetweenPoints.y, 2);
+        const vectorXValue = -1 * unitVectorBetweenPoints.x * unitVectorBetweenPoints.y;
+        const vectorYValue = 1 - Math.pow(unitVectorBetweenPoints.y, 2);
         return normalizeVector(create$d(vectorXValue, vectorYValue));
     }
 }
@@ -159,13 +155,13 @@ function orthogonalVector(ptA, ptB) {
  * @returns A parsed Point.
  */
 function fromJson$5(json) {
-    var obj = JSON.parse(json);
+    const obj = JSON.parse(json);
     if (Array.isArray(obj)) {
-        var x = obj[0], y = obj[1];
+        const [x, y] = obj;
         return create$d(x, y);
     }
     else {
-        var x = obj.x, y = obj.y;
+        const { x, y } = obj;
         return create$d(x, y);
     }
 }
@@ -197,8 +193,8 @@ var point = /*#__PURE__*/Object.freeze({
  * @returns An angle in radians.
  */
 function fromPoints$1(a, b) {
-    var delta = subtract$1(b, a);
-    var theta = Math.atan2(delta.y, delta.x);
+    const delta = subtract$1(b, a);
+    const theta = Math.atan2(delta.y, delta.x);
     return theta;
 }
 /**
@@ -210,8 +206,8 @@ function fromPoints$1(a, b) {
  * @deprecated Use {@link fromPoints} instead.
  */
 function fromPointsInDegrees(a, b) {
-    var delta = subtract$1(b, a);
-    var theta = Math.atan2(delta.y, delta.x);
+    const delta = subtract$1(b, a);
+    const theta = Math.atan2(delta.y, delta.x);
     return normalize$2(toDegrees(theta) - 270);
 }
 /**
@@ -257,10 +253,10 @@ function fromValues(
 m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41, m42, m43, m44) {
     /* eslint-disable prettier/prettier */
     return [
-        m11, m21, m31, m41,
-        m12, m22, m32, m42,
-        m13, m23, m33, m43,
-        m14, m24, m34, m44,
+        m11, m12, m13, m14,
+        m21, m22, m23, m24,
+        m31, m32, m33, m34,
+        m41, m42, m43, m44,
     ];
     /* eslint-enable prettier/prettier */
 }
@@ -298,7 +294,7 @@ function makeZero() {
  * @returns A translation matrix.
  */
 function makeTranslation(translation) {
-    var x = translation.x, y = translation.y, z = translation.z;
+    const { x, y, z } = translation;
     /* eslint-disable prettier/prettier */
     return [
         1, 0, 0, 0,
@@ -323,16 +319,16 @@ function makeTranslation(translation) {
  * @returns A rotation matrix.
  */
 function makeRotation(rotation) {
-    var x = rotation.x, y = rotation.y, z = rotation.z, w = rotation.w;
-    var x2 = x + x, y2 = y + y, z2 = z + z;
-    var xx = x * x2, xy = x * y2, xz = x * z2;
-    var yy = y * y2, yz = y * z2, zz = z * z2;
-    var wx = w * x2, wy = w * y2, wz = w * z2;
+    const { x, y, z, w } = rotation;
+    const x2 = x + x, y2 = y + y, z2 = z + z;
+    const xx = x * x2, xy = x * y2, xz = x * z2;
+    const yy = y * y2, yz = y * z2, zz = z * z2;
+    const wx = w * x2, wy = w * y2, wz = w * z2;
     /* eslint-disable prettier/prettier */
     return [
-        1 - (yy + zz), xy + wz, xz - wy, 0,
-        xy - wz, 1 - (xx + zz), yz + wx, 0,
-        xz + wy, yz - wx, 1 - (xx + yy), 0,
+        1 - (yy + zz), xy - wz, xz + wy, 0,
+        xy + wz, 1 - (xx + zz), yz - wx, 0,
+        xz - wy, yz + wx, 1 - (xx + yy), 0,
         0, 0, 0, 1
     ];
     /* eslint-enable prettier/prettier */
@@ -351,7 +347,7 @@ function makeRotation(rotation) {
  * @returns A scale matrix.
  */
 function makeScale(scale) {
-    var x = scale.x, y = scale.y, z = scale.z;
+    const { x, y, z } = scale;
     /* eslint-disable prettier/prettier */
     return [
         x, 0, 0, 0,
@@ -362,33 +358,33 @@ function makeScale(scale) {
     /* eslint-enable prettier/prettier */
 }
 /**
- * Creates a matrix that has translation, rotation and scale applied to it.
+ * Creates a matrix that has translation, rotation, and scale applied to it.
  *
  * @param translation The translation applied to the matrix.
  * @param rotation The rotation applied to the matrix.
  * @param scale The scale applied to the matrix.
- * @returns A transformed matrix.
+ * @returns A transformed matrix in column-major form.
  */
 function makeTRS(translation, rotation, scale) {
-    var t = makeTranslation(translation);
-    var r = makeRotation(rotation);
-    var s = makeScale(scale);
-    return multiply$2(multiply$2(t, r), s);
+    const t = makeTranslation(translation);
+    const r = transpose(makeRotation(rotation));
+    const s = makeScale(scale);
+    return multiply$2(s, multiply$2(r, t));
 }
 /**
  * Returns a matrix that has the basis components (upper left 3x3 matrix) set to
  * the following x, y, and z axis.
  *
  * ```
- * x.x  y.x  z.x  0
- * x.y  y.y  z.y  0
- * x.z  y.z  z.z  0
+ * x.x  x.y  x.z  0
+ * y.x  y.y  y.z  0
+ * z.x  z.y  z.z  0
  * 0    0    0    0
  * ```
  *
- * @param x The x axis to set.
- * @param y The y axis to set.
- * @param z The z axis to set.
+ * @param x The x-axis to set.
+ * @param y The y-axis to set.
+ * @param z The z-axis to set.
  * @returns A matrix with its basis components populated.
  */
 function makeBasis(x, y, z) {
@@ -401,30 +397,6 @@ function makeBasis(x, y, z) {
     ];
     /* eslint-enable prettier/prettier */
 }
-/**
- * Creates a rotation matrix that is rotated around a given axis by the given
- * angle.
- *
- * @param axis The axis of rotation.
- * @param radians The angle of rotation.
- * @returns A rotation matrix.
- */
-function makeRotationAxis(axis, radians) {
-    var c = Math.cos(radians);
-    var s = Math.sin(radians);
-    var t = 1 - c;
-    var x = axis.x, y = axis.y, z = axis.z;
-    var tx = t * x;
-    var ty = t * y;
-    /* eslint-disable prettier/prettier */
-    return [
-        tx * x + c, tx * y + s * z, tx * z - s * y, 0,
-        tx * y - s * z, ty * y + c, ty * z + s * x, 0,
-        tx * z + s * y, ty * z - s * x, t * z * z + c, 0,
-        0, 0, 0, 1
-    ];
-    /* eslint-enable prettier/prettier */
-}
 /**
  * Creates a matrix used for [perspective
  * projections](https://en.wikipedia.org/wiki/3D_projection#Perspective_projection).
@@ -444,12 +416,12 @@ function makeRotationAxis(axis, radians) {
  * @returns A matrix representing a view frustum.
  */
 function makeFrustum(left, right, top, bottom, near, far) {
-    var x = (2 * near) / (right - left);
-    var y = (2 * near) / (top - bottom);
-    var a = (right + left) / (right - left);
-    var b = (top + bottom) / (top - bottom);
-    var c = -(far + near) / (far - near);
-    var d = (-2 * far * near) / (far - near);
+    const x = (2 * near) / (right - left);
+    const y = (2 * near) / (top - bottom);
+    const a = (right + left) / (right - left);
+    const b = (top + bottom) / (top - bottom);
+    const c = -(far + near) / (far - near);
+    const d = (-2 * far * near) / (far - near);
     /* eslint-disable prettier/prettier */
     return [
         x, 0, 0, 0,
@@ -478,12 +450,12 @@ function makeFrustum(left, right, top, bottom, near, far) {
  * @returns A matrix.
  */
 function makePerspective(near, far, fovY, aspect) {
-    var ymax = near * Math.tan(toRadians(fovY / 2.0));
-    var xmax = ymax * aspect;
-    var left = -xmax;
-    var right = xmax;
-    var top = ymax;
-    var bottom = -ymax;
+    const ymax = near * Math.tan(toRadians(fovY / 2.0));
+    const xmax = ymax * aspect;
+    const left = -xmax;
+    const right = xmax;
+    const top = ymax;
+    const bottom = -ymax;
     return makeFrustum(left, right, top, bottom, near, far);
 }
 /**
@@ -504,12 +476,12 @@ function makePerspective(near, far, fovY, aspect) {
  * @returns A matrix.
  */
 function makeOrthographic(left, right, bottom, top, near, far) {
-    var w = 1.0 / (right - left);
-    var h = 1.0 / (top - bottom);
-    var d = 1.0 / (far - near);
-    var x = (right + left) * w;
-    var y = (top + bottom) * h;
-    var z = (far + near) * d;
+    const w = 1.0 / (right - left);
+    const h = 1.0 / (top - bottom);
+    const d = 1.0 / (far - near);
+    const x = (right + left) * w;
+    const y = (top + bottom) * h;
+    const z = (far + near) * d;
     /* eslint-disable prettier/prettier */
     return [
         2 * w, 0, 0, -x,
@@ -539,12 +511,12 @@ function makeOrthographic(left, right, bottom, top, near, far) {
  * @returns A matrix.
  */
 function makeLookAtView(position, lookAt, up) {
-    var z = normalize(subtract(position, lookAt));
-    var x = normalize(cross(up, z));
-    var y = cross(z, x);
-    var dotX = -dot$1(x, position);
-    var dotY = -dot$1(y, position);
-    var dotZ = -dot$1(z, position);
+    const z = normalize(subtract(position, lookAt));
+    const x = normalize(cross(up, z));
+    const y = cross(z, x);
+    const dotX = -dot$1(x, position);
+    const dotY = -dot$1(y, position);
+    const dotZ = -dot$1(z, position);
     /* eslint-disable prettier/prettier */
     return [
         x.x, y.x, z.x, 0,
@@ -568,9 +540,9 @@ function makeLookAtView(position, lookAt, up) {
  * @returns A matrix.
  */
 function makeLookAt(position, lookAt, up) {
-    var z = normalize(subtract(position, lookAt));
-    var x = normalize(cross(up, z));
-    var y = cross(z, x);
+    const z = normalize(subtract(position, lookAt));
+    const x = normalize(cross(up, z));
+    const y = cross(z, x);
     /* eslint-disable prettier/prettier */
     return [
         x.x, x.y, x.z, 0,
@@ -585,45 +557,45 @@ function makeLookAt(position, lookAt, up) {
  * zero, then a zero matrix is returned.
  */
 function invert(matrix) {
-    var a00 = matrix[0], a01 = matrix[1], a02 = matrix[2], a03 = matrix[3];
-    var a10 = matrix[4], a11 = matrix[5], a12 = matrix[6], a13 = matrix[7];
-    var a20 = matrix[8], a21 = matrix[9], a22 = matrix[10], a23 = matrix[11];
-    var a30 = matrix[12], a31 = matrix[13], a32 = matrix[14], a33 = matrix[15];
-    var b00 = a00 * a11 - a01 * a10;
-    var b01 = a00 * a12 - a02 * a10;
-    var b02 = a00 * a13 - a03 * a10;
-    var b03 = a01 * a12 - a02 * a11;
-    var b04 = a01 * a13 - a03 * a11;
-    var b05 = a02 * a13 - a03 * a12;
-    var b06 = a20 * a31 - a21 * a30;
-    var b07 = a20 * a32 - a22 * a30;
-    var b08 = a20 * a33 - a23 * a30;
-    var b09 = a21 * a32 - a22 * a31;
-    var b10 = a21 * a33 - a23 * a31;
-    var b11 = a22 * a33 - a23 * a32;
+    const a00 = matrix[0], a01 = matrix[1], a02 = matrix[2], a03 = matrix[3];
+    const a10 = matrix[4], a11 = matrix[5], a12 = matrix[6], a13 = matrix[7];
+    const a20 = matrix[8], a21 = matrix[9], a22 = matrix[10], a23 = matrix[11];
+    const a30 = matrix[12], a31 = matrix[13], a32 = matrix[14], a33 = matrix[15];
+    const b00 = a00 * a11 - a01 * a10;
+    const b01 = a00 * a12 - a02 * a10;
+    const b02 = a00 * a13 - a03 * a10;
+    const b03 = a01 * a12 - a02 * a11;
+    const b04 = a01 * a13 - a03 * a11;
+    const b05 = a02 * a13 - a03 * a12;
+    const b06 = a20 * a31 - a21 * a30;
+    const b07 = a20 * a32 - a22 * a30;
+    const b08 = a20 * a33 - a23 * a30;
+    const b09 = a21 * a32 - a22 * a31;
+    const b10 = a21 * a33 - a23 * a31;
+    const b11 = a22 * a33 - a23 * a32;
     // Calculate the determinant
-    var det = b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06;
+    const det = b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06;
     if (!det) {
         return makeZero();
     }
-    det = 1.0 / det;
+    const oneOverDet = 1 / det;
     return [
-        (a11 * b11 - a12 * b10 + a13 * b09) * det,
-        (a02 * b10 - a01 * b11 - a03 * b09) * det,
-        (a31 * b05 - a32 * b04 + a33 * b03) * det,
-        (a22 * b04 - a21 * b05 - a23 * b03) * det,
-        (a12 * b08 - a10 * b11 - a13 * b07) * det,
-        (a00 * b11 - a02 * b08 + a03 * b07) * det,
-        (a32 * b02 - a30 * b05 - a33 * b01) * det,
-        (a20 * b05 - a22 * b02 + a23 * b01) * det,
-        (a10 * b10 - a11 * b08 + a13 * b06) * det,
-        (a01 * b08 - a00 * b10 - a03 * b06) * det,
-        (a30 * b04 - a31 * b02 + a33 * b00) * det,
-        (a21 * b02 - a20 * b04 - a23 * b00) * det,
-        (a11 * b07 - a10 * b09 - a12 * b06) * det,
-        (a00 * b09 - a01 * b07 + a02 * b06) * det,
-        (a31 * b01 - a30 * b03 - a32 * b00) * det,
-        (a20 * b03 - a21 * b01 + a22 * b00) * det,
+        (a11 * b11 - a12 * b10 + a13 * b09) * oneOverDet,
+        (a02 * b10 - a01 * b11 - a03 * b09) * oneOverDet,
+        (a31 * b05 - a32 * b04 + a33 * b03) * oneOverDet,
+        (a22 * b04 - a21 * b05 - a23 * b03) * oneOverDet,
+        (a12 * b08 - a10 * b11 - a13 * b07) * oneOverDet,
+        (a00 * b11 - a02 * b08 + a03 * b07) * oneOverDet,
+        (a32 * b02 - a30 * b05 - a33 * b01) * oneOverDet,
+        (a20 * b05 - a22 * b02 + a23 * b01) * oneOverDet,
+        (a10 * b10 - a11 * b08 + a13 * b06) * oneOverDet,
+        (a01 * b08 - a00 * b10 - a03 * b06) * oneOverDet,
+        (a30 * b04 - a31 * b02 + a33 * b00) * oneOverDet,
+        (a21 * b02 - a20 * b04 - a23 * b00) * oneOverDet,
+        (a11 * b07 - a10 * b09 - a12 * b06) * oneOverDet,
+        (a00 * b09 - a01 * b07 + a02 * b06) * oneOverDet,
+        (a31 * b01 - a30 * b03 - a32 * b00) * oneOverDet,
+        (a20 * b03 - a21 * b01 + a22 * b00) * oneOverDet,
     ];
 }
 /**
@@ -637,70 +609,58 @@ function invert(matrix) {
  * @returns A rotation matrix.
  */
 function lookAt(m, position, target, up) {
-    var z = subtract(position, target);
+    let z = subtract(position, target);
     if (magnitudeSquared(z) === 0) {
-        z = __assign(__assign({}, z), { z: 1 });
+        z = { ...z, z: 1 };
     }
     z = normalize(z);
-    var x = cross(up, z);
+    let x = cross(up, z);
     if (magnitudeSquared(x) === 0) {
         if (Math.abs(up.z) === 1) {
-            z = __assign(__assign({}, z), { x: z.x + 0.0001 });
+            z = { ...z, x: z.x + 0.0001 };
         }
         else {
-            z = __assign(__assign({}, z), { z: z.z + 0.0001 });
+            z = { ...z, z: z.z + 0.0001 };
         }
         z = normalize(z);
         x = cross(up, z);
     }
     x = normalize(x);
-    var y = cross(z, x);
-    var res = __spreadArray([], m, true);
+    const y = cross(z, x);
+    const res = [...m];
     /* eslint-disable prettier/prettier */
     res[0] = x.x;
-    res[4] = y.x;
-    res[8] = z.x;
     res[1] = x.y;
-    res[5] = y.y;
-    res[9] = z.y;
     res[2] = x.z;
+    res[4] = y.x;
+    res[5] = y.y;
     res[6] = y.z;
+    res[8] = z.x;
+    res[9] = z.y;
     res[10] = z.z;
     /* eslint-enable prettier/prettier */
     return res;
 }
 /**
- * Returns a post-multiplied matrix.
+ * Returns a post-multiplied matrix equal to ab.
  */
 function multiply$2(a, b) {
-    var ae = a;
-    var be = b;
-    var a11 = ae[0], a12 = ae[4], a13 = ae[8], a14 = ae[12];
-    var a21 = ae[1], a22 = ae[5], a23 = ae[9], a24 = ae[13];
-    var a31 = ae[2], a32 = ae[6], a33 = ae[10], a34 = ae[14];
-    var a41 = ae[3], a42 = ae[7], a43 = ae[11], a44 = ae[15];
-    var b11 = be[0], b12 = be[4], b13 = be[8], b14 = be[12];
-    var b21 = be[1], b22 = be[5], b23 = be[9], b24 = be[13];
-    var b31 = be[2], b32 = be[6], b33 = be[10], b34 = be[14];
-    var b41 = be[3], b42 = be[7], b43 = be[11], b44 = be[15];
-    var mat = makeIdentity();
-    mat[0] = a11 * b11 + a12 * b21 + a13 * b31 + a14 * b41;
-    mat[4] = a11 * b12 + a12 * b22 + a13 * b32 + a14 * b42;
-    mat[8] = a11 * b13 + a12 * b23 + a13 * b33 + a14 * b43;
-    mat[12] = a11 * b14 + a12 * b24 + a13 * b34 + a14 * b44;
-    mat[1] = a21 * b11 + a22 * b21 + a23 * b31 + a24 * b41;
-    mat[5] = a21 * b12 + a22 * b22 + a23 * b32 + a24 * b42;
-    mat[9] = a21 * b13 + a22 * b23 + a23 * b33 + a24 * b43;
-    mat[13] = a21 * b14 + a22 * b24 + a23 * b34 + a24 * b44;
-    mat[2] = a31 * b11 + a32 * b21 + a33 * b31 + a34 * b41;
-    mat[6] = a31 * b12 + a32 * b22 + a33 * b32 + a34 * b42;
-    mat[10] = a31 * b13 + a32 * b23 + a33 * b33 + a34 * b43;
-    mat[14] = a31 * b14 + a32 * b24 + a33 * b34 + a34 * b44;
-    mat[3] = a41 * b11 + a42 * b21 + a43 * b31 + a44 * b41;
-    mat[7] = a41 * b12 + a42 * b22 + a43 * b32 + a44 * b42;
-    mat[11] = a41 * b13 + a42 * b23 + a43 * b33 + a44 * b43;
-    mat[15] = a41 * b14 + a42 * b24 + a43 * b34 + a44 * b44;
-    return mat;
+    const result = makeIdentity();
+    // Consider each row i in the final matrix
+    for (let i = 0; i < 4; i++) {
+        // Consider each column j in the final matrix
+        for (let j = 0; j < 4; j++) {
+            // Calculate the value at row i and column j
+            let value = 0;
+            for (let k = 0; k < 4; k++) {
+                // Calculate (ik + kj) and add it to the value
+                value += a[i * 4 + k] * b[k * 4 + j];
+            }
+            const positionInResultingMatrix = 4 * i + j;
+            result[positionInResultingMatrix] = value;
+        }
+    }
+    return result;
 }
 /**
  * Returns the [transpose](https://en.wikipedia.org/wiki/Transpose) of the given
@@ -717,45 +677,60 @@ function transpose(matrix) {
     /* eslint-enable prettier/prettier */
 }
 /**
- * Multiplies the columns of a matrix by the given vector.
+ * Multiplies the columns of a row-major matrix by the given vector.
  */
 function scale$4(matrix, scale) {
-    var x = scale.x, y = scale.y, z = scale.z;
-    var m = __spreadArray([], matrix, true);
+    const { x, y, z } = scale;
+    const m = [...matrix];
     /* eslint-disable prettier/prettier */
     m[0] *= x;
-    m[4] *= y;
-    m[8] *= z;
     m[1] *= x;
-    m[5] *= y;
-    m[9] *= z;
     m[2] *= x;
-    m[6] *= y;
-    m[10] *= z;
     m[3] *= x;
+    m[4] *= y;
+    m[5] *= y;
+    m[6] *= y;
     m[7] *= y;
+    m[8] *= z;
+    m[9] *= z;
+    m[10] *= z;
     m[11] *= z;
     /* eslint-enable prettier/prettier */
     return m;
 }
-function position(matrix, other) {
-    var m = __spreadArray([], matrix, true);
-    m[12] = other[12];
-    m[13] = other[13];
-    m[14] = other[14];
+/**
+ * Sets the position of the matrix given as the first parameter
+ * to the position of the matrix given as the second parameter.
+ * Both matrices should have row-major format.
+ */
+function position(originalMatrix, matrixWithDesiredPosition) {
+    const m = [...originalMatrix];
+    m[12] = matrixWithDesiredPosition[12];
+    m[13] = matrixWithDesiredPosition[13];
+    m[14] = matrixWithDesiredPosition[14];
     return m;
 }
 /**
  * Returns true if the matrix is an identity matrix.
  */
 function isIdentity(matrix) {
-    var identity = makeIdentity();
-    return matrix.every(function (v, i) { return v === identity[i]; });
+    const identity = makeIdentity();
+    return matrix.every((v, i) => v === identity[i]);
 }
 /**
  * Returns an object representation of a `Matrix4`.
+ * @param m A Matrix4 item written in column-major form.
+ *
+ * @deprecated Use {@link toObjectColumnMajor} or {@link toObjectRowMajor} instead.
  */
 function toObject(m) {
+    return toObjectColumnMajor(m);
+}
+/**
+ * Returns an object representation of a `Matrix4`.
+ * @param m A Matrix4 item written in column-major form.
+ */
+function toObjectColumnMajor(m) {
     /* eslint-disable prettier/prettier */
     return {
         m11: m[0], m12: m[4], m13: m[8], m14: m[12],
@@ -765,6 +740,20 @@ function toObject(m) {
     };
     /* eslint-enable prettier/prettier */
 }
+/**
+ * Returns an object representation of a `Matrix4`.
+ * @param m A Matrix4 item written in row-major form.
+ */
+function toObjectRowMajor(m) {
+    /* eslint-disable prettier/prettier */
+    return {
+        m11: m[0], m12: m[1], m13: m[2], m14: m[3],
+        m21: m[4], m22: m[5], m23: m[6], m24: m[7],
+        m31: m[8], m32: m[9], m33: m[10], m34: m[11],
+        m41: m[12], m42: m[13], m43: m[14], m44: m[15],
+    };
+    /* eslint-enable prettier/prettier */
+}
 /**
  * A type guard to check if `obj` is of type `Matrix4`.
  */
@@ -788,7 +777,6 @@ var matrix4 = /*#__PURE__*/Object.freeze({
   makeOrthographic: makeOrthographic,
   makePerspective: makePerspective,
   makeRotation: makeRotation,
-  makeRotationAxis: makeRotationAxis,
   makeScale: makeScale,
   makeTRS: makeTRS,
   makeTranslation: makeTranslation,
@@ -797,6 +785,8 @@ var matrix4 = /*#__PURE__*/Object.freeze({
   position: position,
   scale: scale$4,
   toObject: toObject,
+  toObjectColumnMajor: toObjectColumnMajor,
+  toObjectRowMajor: toObjectRowMajor,
   transpose: transpose
 });
 
@@ -808,9 +798,8 @@ var matrix4 = /*#__PURE__*/Object.freeze({
  * @param value The values to populate the Euler angles with.
  * @returns A set of Euler angles.
  */
-function create$c(value) {
+function create$c(value = {}) {
     var _a, _b, _c, _d;
-    if (value === void 0) { value = {}; }
     return {
         x: (_a = value.x) !== null && _a !== void 0 ? _a : 0,
         y: (_b = value.y) !== null && _b !== void 0 ? _b : 0,
@@ -826,14 +815,13 @@ function create$c(value) {
  * @param value The values to populate the Euler angles with.
  * @returns A set of Euler angles.
  */
-function fromDegrees(value) {
-    if (value === void 0) { value = {}; }
-    var _a = value.x, x = _a === void 0 ? 0 : _a, _b = value.y, y = _b === void 0 ? 0 : _b, _c = value.z, z = _c === void 0 ? 0 : _c, order = value.order;
+function fromDegrees(value = {}) {
+    const { x = 0, y = 0, z = 0, order } = value;
     return create$c({
         x: toRadians(x),
         y: toRadians(y),
         z: toRadians(z),
-        order: order,
+        order,
     });
 }
 /**
@@ -847,10 +835,11 @@ function fromDegrees(value) {
  * @param matrix A pure rotation matrix, unscaled.
  * @param order The order that the rotations are applied.
  */
-function fromRotationMatrix(matrix, order) {
-    if (order === void 0) { order = 'xyz'; }
-    var m = toObject(matrix);
-    var x = 0, y = 0, z = 0;
+function fromRotationMatrix(matrix, order = 'xyz', matrixIsColumnMajor = true) {
+    const m = matrixIsColumnMajor
+        ? toObjectColumnMajor(matrix)
+        : toObjectRowMajor(matrix);
+    let x = 0, y = 0, z = 0;
     if (order === 'xyz') {
         y = Math.asin(clamp(m.m13, -1, 1));
         if (Math.abs(m.m13) < 0.9999999) {
@@ -917,7 +906,7 @@ function fromRotationMatrix(matrix, order) {
             y = 0;
         }
     }
-    return { x: x, y: y, z: z, order: order };
+    return { x, y, z, order };
 }
 /**
  * Returns a set of Euler angles that was decoded from a JSON string. Supports either
@@ -928,14 +917,14 @@ function fromRotationMatrix(matrix, order) {
  * @returns A set of Euler angles.
  */
 function fromJson$4(json) {
-    var obj = JSON.parse(json);
+    const obj = JSON.parse(json);
     if (Array.isArray(obj)) {
-        var x = obj[0], y = obj[1], z = obj[2], _a = obj[3], order = _a === void 0 ? 'xyz' : _a;
-        return { x: x, y: y, z: z, order: order };
+        const [x, y, z, order = 'xyz'] = obj;
+        return { x, y, z, order };
     }
     else {
-        var x = obj.x, y = obj.y, z = obj.z, _b = obj.order, order = _b === void 0 ? 'xyz' : _b;
-        return { x: x, y: y, z: z, order: order };
+        const { x, y, z, order = 'xyz' } = obj;
+        return { x, y, z, order };
     }
 }
 /**
@@ -943,7 +932,7 @@ function fromJson$4(json) {
  */
 function isType$1(obj) {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    var o = obj;
+    const o = obj;
     return (o != null &&
         o.hasOwnProperty('x') &&
         o.hasOwnProperty('y') &&
@@ -964,9 +953,8 @@ var euler = /*#__PURE__*/Object.freeze({
  * Returns a new quaternion. If `value` is undefined, then `{x: 0, y: 0, z: 0,
  * w: 1}` is returned.
  */
-function create$b(value) {
-    if (value === void 0) { value = {}; }
-    return __assign({ x: 0, y: 0, z: 0, w: 1 }, value);
+function create$b(value = {}) {
+    return { x: 0, y: 0, z: 0, w: 1, ...value };
 }
 /**
  * Parses a JSON string representation of a `Quaternion`.
@@ -975,10 +963,10 @@ function create$b(value) {
  * @returns A parsed `Quaternion`.
  */
 function fromJson$3(json) {
-    var obj = JSON.parse(json);
+    const obj = JSON.parse(json);
     if (Array.isArray(obj)) {
-        var x = obj[0], y = obj[1], z = obj[2], w = obj[3];
-        return create$b({ x: x, y: y, z: z, w: w });
+        const [x, y, z, w] = obj;
+        return create$b({ x, y, z, w });
     }
     else {
         return create$b(obj);
@@ -1015,80 +1003,72 @@ function scale$3(scalar, q) {
  * @returns A rotated quaternion.
  */
 function fromAxisAngle(axis, radians) {
-    var halfAngle = radians / 2;
-    var s = Math.sin(halfAngle);
-    var x = axis.x * s;
-    var y = axis.y * s;
-    var z = axis.z * s;
-    var w = Math.cos(halfAngle);
-    return { x: x, y: y, z: z, w: w };
+    const halfAngle = radians / 2;
+    const s = Math.sin(halfAngle);
+    const x = axis.x * s;
+    const y = axis.y * s;
+    const z = axis.z * s;
+    const w = Math.cos(halfAngle);
+    return { x, y, z, w };
 }
 /**
  * Returns a quaternion using the upper 3x3 of a pure rotation matrix
  * (unscaled).
  */
 function fromMatrixRotation(matrix) {
-    var m = toObject(matrix);
-    var scale = fromMatrixScale(matrix);
-    var is1 = 1 / scale.x;
-    var is2 = 1 / scale.y;
-    var is3 = 1 / scale.z;
-    var sm11 = m.m11 * is1;
-    var sm12 = m.m21 * is2;
-    var sm13 = m.m31 * is3;
-    var sm21 = m.m12 * is1;
-    var sm22 = m.m22 * is2;
-    var sm23 = m.m32 * is3;
-    var sm31 = m.m13 * is1;
-    var sm32 = m.m23 * is2;
-    var sm33 = m.m33 * is3;
-    var trace = sm11 + sm22 + sm33;
+    // Determine the scalars for each vector
+    const scale = fromMatrixScale(matrix);
+    const oneOverScaleVector = create$a(1 / scale.x, 1 / scale.y, 1 / scale.z);
+    // Scale the matrix
+    const scaledMatrix = scale$4(matrix, oneOverScaleVector);
+    const sM = toObjectRowMajor(scaledMatrix);
+    const trace = sM.m11 + sM.m22 + sM.m33;
     if (trace > 0) {
-        var s = Math.sqrt(trace + 1.0) * 2;
+        const s = Math.sqrt(trace + 1) * 2;
         return {
-            x: (sm23 - sm32) / s,
-            y: (sm31 - sm13) / s,
-            z: (sm12 - sm21) / s,
+            x: (sM.m23 - sM.m32) / s,
+            y: (sM.m31 - sM.m13) / s,
+            z: (sM.m12 - sM.m21) / s,
             w: 0.25 * s,
         };
     }
-    else if (sm11 > sm22 && sm11 > sm33) {
-        var s = Math.sqrt(1.0 + sm11 - sm22 - sm33) * 2;
+    else if (sM.m11 > sM.m22 && sM.m11 > sM.m33) {
+        const s = Math.sqrt(1 + sM.m11 - sM.m22 - sM.m33) * 2;
         return {
             x: 0.25 * s,
-            y: (sm12 + sm21) / s,
-            z: (sm31 + sm13) / s,
-            w: (sm23 - sm32) / s,
+            y: (sM.m12 + sM.m21) / s,
+            z: (sM.m31 + sM.m13) / s,
+            w: (sM.m23 - sM.m32) / s,
         };
     }
-    else if (sm22 > sm33) {
-        var s = Math.sqrt(1.0 + sm22 - sm11 - sm33) * 2;
+    else if (sM.m22 > sM.m33) {
+        const s = Math.sqrt(1 + sM.m22 - sM.m11 - sM.m33) * 2;
         return {
-            x: (sm12 + sm21) / s,
+            x: (sM.m12 + sM.m21) / s,
             y: 0.25 * s,
-            z: (sm23 + sm32) / s,
-            w: (sm31 - sm13) / s,
+            z: (sM.m23 + sM.m32) / s,
+            w: (sM.m31 - sM.m13) / s,
         };
     }
     else {
-        var s = Math.sqrt(1.0 + sm33 - sm11 - sm22) * 2;
+        const s = Math.sqrt(1 + sM.m33 - sM.m11 - sM.m22) * 2;
         return {
-            x: (sm31 + sm13) / s,
-            y: (sm23 + sm32) / s,
+            x: (sM.m31 + sM.m13) / s,
+            y: (sM.m23 + sM.m32) / s,
             z: 0.25 * s,
-            w: (sm12 - sm21) / s,
+            w: (sM.m12 - sM.m21) / s,
         };
     }
 }
 function fromEuler(euler) {
-    var ex = euler.x, ey = euler.y, ez = euler.z, order = euler.order;
-    var c1 = Math.cos(ex / 2);
-    var c2 = Math.cos(ey / 2);
-    var c3 = Math.cos(ez / 2);
-    var s1 = Math.sin(ex / 2);
-    var s2 = Math.sin(ey / 2);
-    var s3 = Math.sin(ez / 2);
-    var x = 0, y = 0, z = 0, w = 0;
+    const { x: ex, y: ey, z: ez, order } = euler;
+    const c1 = Math.cos(ex / 2);
+    const c2 = Math.cos(ey / 2);
+    const c3 = Math.cos(ez / 2);
+    const s1 = Math.sin(ex / 2);
+    const s2 = Math.sin(ey / 2);
+    const s3 = Math.sin(ez / 2);
+    let x = 0, y = 0, z = 0, w = 0;
     switch (order) {
         case 'xyz':
             x = s1 * c2 * c3 + c1 * s2 * s3;
@@ -1127,7 +1107,7 @@ function fromEuler(euler) {
             w = c1 * c2 * c3 + s1 * s2 * s3;
             break;
     }
-    return { x: x, y: y, z: z, w: w };
+    return { x, y, z, w };
 }
 /**
  * Multiplies `a` x `b` and returns a new quaternion with the result.
@@ -1146,7 +1126,7 @@ function multiply$1(a, b) {
  */
 function isType(obj) {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    var o = obj;
+    const o = obj;
     return (o != null &&
         o.hasOwnProperty('x') &&
         o.hasOwnProperty('y') &&
@@ -1168,12 +1148,8 @@ var quaternion = /*#__PURE__*/Object.freeze({
   scale: scale$3
 });
 
-function create$a() {
+function create$a(...args) {
     var _a, _b, _c, _d, _e, _f;
-    var args = [];
-    for (var _i = 0; _i < arguments.length; _i++) {
-        args[_i] = arguments[_i];
-    }
     if (args.length === 1) {
         return {
             x: (_a = args[0].x) !== null && _a !== void 0 ? _a : 0,
@@ -1200,27 +1176,33 @@ function create$a() {
  * Checks if each component of the given vector is populated with a numeric
  * component. A component is invalid if it contains a non-finite or NaN value.
  */
-function isValid$1(_a) {
-    var x = _a.x, y = _a.y, z = _a.z;
-    return [x, y, z].every(function (v) { return isFinite(v) && !isNaN(v); });
+function isValid$1({ x, y, z }) {
+    return [x, y, z].every((v) => isFinite(v) && !isNaN(v));
+}
+/**
+ * Checks if every component of the given vector is zero.
+ * Useful for detecting potentially problematic camera vectors, for example.
+ */
+function isZeroVector({ x, y, z }) {
+    return [x, y, z].every((v) => v === 0);
 }
 /**
  * Returns a vector representing the scale elements of `matrix`.
  */
 function fromMatrixScale(matrix) {
-    var m = toObject(matrix);
+    const m = toObjectRowMajor(matrix);
     return {
-        x: Math.hypot(m.m11, m.m21, m.m31),
-        y: Math.hypot(m.m12, m.m22, m.m32),
-        z: Math.hypot(m.m13, m.m23, m.m33),
+        x: Math.hypot(m.m11, m.m12, m.m13),
+        y: Math.hypot(m.m21, m.m22, m.m23),
+        z: Math.hypot(m.m31, m.m32, m.m33),
     };
 }
 /**
  * Returns a vector representing the position elements of `matrix`.
  */
 function fromMatrixPosition(matrix) {
-    var m = toObject(matrix);
-    return { x: m.m14, y: m.m24, z: m.m34 };
+    const m = toObjectRowMajor(matrix);
+    return { x: m.m41, y: m.m42, z: m.m43 };
 }
 /**
  * Parses a JSON string representation of a Vector3 and returns an object.
@@ -1229,13 +1211,13 @@ function fromMatrixPosition(matrix) {
  * @returns A parsed Vector3.
  */
 function fromJson$2(json) {
-    var obj = JSON.parse(json);
+    const obj = JSON.parse(json);
     if (Array.isArray(obj)) {
-        var x = obj[0], y = obj[1], z = obj[2];
+        const [x, y, z] = obj;
         return create$a(x, y, z);
     }
     else {
-        var x = obj.x, y = obj.y, z = obj.z;
+        const { x, y, z } = obj;
         return create$a(x, y, z);
     }
 }
@@ -1246,11 +1228,10 @@ function fromJson$2(json) {
  * @see #toArray()
  * @see #create()
  */
-function fromArray(nums, offset) {
-    if (offset === void 0) { offset = 0; }
-    var x = nums[offset];
-    var y = nums[offset + 1];
-    var z = nums[offset + 2];
+function fromArray(nums, offset = 0) {
+    const x = nums[offset];
+    const y = nums[offset + 1];
+    const z = nums[offset + 2];
     return create$a(x, y, z);
 }
 /**
@@ -1260,8 +1241,7 @@ function fromArray(nums, offset) {
  * @see #fromArray()
  * @see #create()
  */
-function toArray(_a) {
-    var x = _a.x, y = _a.y, z = _a.z;
+function toArray({ x, y, z }) {
     return [x, y, z];
 }
 /**
@@ -1310,7 +1290,7 @@ function origin() {
  * Returns a vector with that will have a magnitude of 1.
  */
 function normalize(vector) {
-    var length = magnitude(vector);
+    const length = magnitude(vector);
     return { x: vector.x / length, y: vector.y / length, z: vector.z / length };
 }
 /**
@@ -1347,24 +1327,16 @@ function cross(a, b) {
 /**
  * Returns a vector that is the sum of two vectors.
  */
-function add(a) {
-    var vectors = [];
-    for (var _i = 1; _i < arguments.length; _i++) {
-        vectors[_i - 1] = arguments[_i];
-    }
-    return vectors.reduce(function (res, next) {
+function add(a, ...vectors) {
+    return vectors.reduce((res, next) => {
         return { x: res.x + next.x, y: res.y + next.y, z: res.z + next.z };
     }, a);
 }
 /**
  * Returns a vector that is the difference between two vectors.
  */
-function subtract(a) {
-    var vectors = [];
-    for (var _i = 1; _i < arguments.length; _i++) {
-        vectors[_i - 1] = arguments[_i];
-    }
-    return vectors.reduce(function (res, next) {
+function subtract(a, ...vectors) {
+    return vectors.reduce((res, next) => {
         return { x: res.x - next.x, y: res.y - next.y, z: res.z - next.z };
     }, a);
 }
@@ -1398,7 +1370,7 @@ function dot$1(a, b) {
  * result is never greater than 180 degrees.
  */
 function angleTo(a, b) {
-    var theta = dot$1(a, b) / (magnitude(a) * magnitude(b));
+    const theta = dot$1(a, b) / (magnitude(a) * magnitude(b));
     // Clamp to avoid numerical problems.
     return Math.acos(theta);
 }
@@ -1409,16 +1381,19 @@ function angleTo(a, b) {
  * algorithm described in https://www.xarg.org/proof/quaternion-from-two-vectors/.
  */
 function eulerTo(a, b) {
-    var normalizedA = normalize(a);
-    var normalizedB = normalize(b);
-    var dotDelta = Math.cos(toRadians(1));
-    var dotAB = dot$1(normalizedA, normalizedB);
-    var vectorsAreParallel = Math.abs(dotAB) > dotDelta;
+    const normalizedA = normalize(a);
+    const normalizedB = normalize(b);
+    const dotDelta = Math.cos(toRadians(1));
+    const dotAB = dot$1(normalizedA, normalizedB);
+    const vectorsAreParallel = Math.abs(dotAB) > dotDelta;
     if (vectorsAreParallel) {
         return dotAB > 1 - 1e-6 ? create$c() : create$c({ x: Math.PI });
     }
-    var normalizedQ = normalize$1(create$b(__assign({ w: 1 + dotAB }, cross(normalizedA, normalizedB))));
-    return fromRotationMatrix(makeRotation(normalizedQ));
+    const normalizedQ = normalize$1(create$b({
+        w: 1 + dotAB,
+        ...cross(normalizedA, normalizedB),
+    }));
+    return fromRotationMatrix(makeRotation(normalizedQ), 'xyz', false);
 }
 /**
  * Performs a projection of a `vector` onto `onNormal`.
@@ -1448,18 +1423,18 @@ function project(vector, onNormal) {
  */
 function rotateAboutAxis(angle, point, axisDirection, axisPosition) {
     if (angle !== 0) {
-        var x = point.x, y = point.y, z = point.z;
-        var a = axisPosition.x, b = axisPosition.y, c = axisPosition.z;
-        var u = axisDirection.x, v = axisDirection.y, w = axisDirection.z;
-        var newX = (a * (v * v + w * w) - u * (b * v + c * w - u * x - v * y - w * z)) *
+        const { x, y, z } = point;
+        const { x: a, y: b, z: c } = axisPosition;
+        const { x: u, y: v, z: w } = axisDirection;
+        const newX = (a * (v * v + w * w) - u * (b * v + c * w - u * x - v * y - w * z)) *
             (1 - Math.cos(angle)) +
             x * Math.cos(angle) +
             (-c * v + b * w - w * y + v * z) * Math.sin(angle);
-        var newY = (b * (u * u + w * w) - v * (a * u + c * w - u * x - v * y - w * z)) *
+        const newY = (b * (u * u + w * w) - v * (a * u + c * w - u * x - v * y - w * z)) *
             (1 - Math.cos(angle)) +
             y * Math.cos(angle) +
             (c * u - a * w + w * x - u * z) * Math.sin(angle);
-        var newZ = (c * (u * u + v * v) - w * (a * u + b * v - u * x - v * y - w * z)) *
+        const newZ = (c * (u * u + v * v) - w * (a * u + b * v - u * x - v * y - w * z)) *
             (1 - Math.cos(angle)) +
             z * Math.cos(angle) +
             (-b * u + a * v - v * x + u * y) * Math.sin(angle);
@@ -1470,17 +1445,43 @@ function rotateAboutAxis(angle, point, axisDirection, axisPosition) {
     }
 }
 /**
- * Returns a vector that is multiplied with a matrix.
+ * Returns a vector that is multiplied with a matrix in column-major form.
+ * @param vector A Vector3 item.
+ * @param m A Matrix4 item written in column-major form.
+ *
+ * @deprecated Use {@link multiplyByTransformMatrixColumnMajor} or {@link multiplyByTransformMatrixRowMajor} instead.
  */
 function transformMatrix$1(vector, m) {
-    var x = vector.x, y = vector.y, z = vector.z;
-    var w = 1 / (m[3] * x + m[7] * y + m[11] * z + m[15]);
+    return multiplyByTransformMatrixColumnMajor(vector, m);
+}
+/**
+ * Returns a vector that is multiplied with a matrix in column-major form.
+ * @param vector A Vector3 item.
+ * @param m A Matrix4 item written in column-major form.
+ */
+function multiplyByTransformMatrixColumnMajor(vector, m) {
+    const { x, y, z } = vector;
+    const w = 1 / (m[3] * x + m[7] * y + m[11] * z + m[15]);
     return {
         x: (m[0] * x + m[4] * y + m[8] * z + m[12]) * w,
         y: (m[1] * x + m[5] * y + m[9] * z + m[13]) * w,
         z: (m[2] * x + m[6] * y + m[10] * z + m[14]) * w,
     };
 }
+/**
+ * Returns a vector that is multiplied with a matrix in row-major form.
+ * @param vector A Vector3 item.
+ * @param m A Matrix4 item written in row-major form.
+ */
+function multiplyByTransformMatrixRowMajor(vector, m) {
+    const { x, y, z } = vector;
+    const w = 1 / (m[12] * x + m[13] * y + m[14] * z + m[15]);
+    return {
+        x: (m[0] * x + m[1] * y + m[2] * z + m[3]) * w,
+        y: (m[4] * x + m[5] * y + m[6] * z + m[7]) * w,
+        z: (m[8] * x + m[9] * y + m[10] * z + m[11]) * w,
+    };
+}
 /**
  * Euclidean distance between two vectors
  */
@@ -1492,7 +1493,7 @@ function distance$1(a, b) {
  * distances, this is slightly more efficient than `distanceTo`.
  */
 function distanceSquared$1(a, b) {
-    var _a = subtract(a, b), dx = _a.x, dy = _a.y, dz = _a.z;
+    const { x: dx, y: dy, z: dz } = subtract(a, b);
     return dx * dx + dy * dy + dz * dz;
 }
 /**
@@ -1544,7 +1545,7 @@ function lerp(a, b, t) {
  * @returns A point in world space coordinates.
  */
 function transformNdcToWorldSpace(ndc, worldMatrix, projectionMatrixInverse) {
-    return transformMatrix$1(transformMatrix$1(ndc, projectionMatrixInverse), worldMatrix);
+    return multiplyByTransformMatrixColumnMajor(multiplyByTransformMatrixColumnMajor(ndc, projectionMatrixInverse), worldMatrix);
 }
 
 var vector3 = /*#__PURE__*/Object.freeze({
@@ -1566,6 +1567,7 @@ var vector3 = /*#__PURE__*/Object.freeze({
   fromMatrixScale: fromMatrixScale,
   isEqual: isEqual$2,
   isValid: isValid$1,
+  isZeroVector: isZeroVector,
   left: left,
   lerp: lerp,
   magnitude: magnitude,
@@ -1573,6 +1575,8 @@ var vector3 = /*#__PURE__*/Object.freeze({
   max: max,
   min: min,
   multiply: multiply,
+  multiplyByTransformMatrixColumnMajor: multiplyByTransformMatrixColumnMajor,
+  multiplyByTransformMatrixRowMajor: multiplyByTransformMatrixRowMajor,
   negate: negate,
   normalize: normalize,
   origin: origin,
@@ -1590,42 +1594,38 @@ var vector3 = /*#__PURE__*/Object.freeze({
 /**
  * Returns a `BoundingBox` with the given min and max points.
  */
-var create$9 = function (min, max) {
-    return { min: min, max: max };
+const create$9 = (min, max) => {
+    return { min, max };
 };
 /**
  * Construct a minimal bounding box for a set of vectors, such that all vectors
  * are contained by the bounding box.
  */
-var fromVectors = function (vectors) {
-    return union.apply(void 0, vectors.map(function (v) { return create$9(v, v); }));
+const fromVectors = (vectors) => {
+    return union(...vectors.map((v) => create$9(v, v)));
 };
 /**
  * Returns the center point of the given `BoundingBox`.
  */
-var center$3 = function (boundingBox) {
+const center$3 = (boundingBox) => {
     return scale$2(0.5, add(boundingBox.min, boundingBox.max));
 };
 /**
  * Returns the diagonal vector between the `min` and `max` vectors of the
  * given `BoundingBox`.
  */
-var diagonal = function (boundingBox) {
+const diagonal = (boundingBox) => {
     return subtract(boundingBox.max, boundingBox.min);
 };
 /**
  * Returns a floating-point spatial error tolerance based on the extents of the box.
  */
-var epsilon = function (boundingBox) {
+const epsilon = (boundingBox) => {
     return (Math.max(Math.max(magnitude(boundingBox.max), magnitude(boundingBox.min)), magnitude(diagonal(boundingBox))) * 1e-6);
 };
-function union(box) {
-    var rest = [];
-    for (var _i = 1; _i < arguments.length; _i++) {
-        rest[_i - 1] = arguments[_i];
-    }
-    var boxes = __spreadArray([box], rest, true);
-    return boxes.reduce(function (a, b) {
+function union(box, ...rest) {
+    const boxes = [box, ...rest];
+    return boxes.reduce((a, b) => {
         return create$9(min(a.min, b.min), max(a.max, b.max));
     });
 }
@@ -1634,7 +1634,7 @@ function union(box) {
  * Returns the distance between the min and max for the provided
  * bounding box for each axis.
  */
-var lengths = function (box) {
+const lengths = (box) => {
     return create$a(box.max.x - box.min.x, box.max.y - box.min.y, box.max.z - box.min.z);
 };
 /**
@@ -1642,8 +1642,8 @@ var lengths = function (box) {
  * component. A component is invalid if it contains a non-finite or NaN value.
  */
 function isValid(boundingBox) {
-    var maxIsValid = isValid$1(boundingBox.max);
-    var minIsValid = isValid$1(boundingBox.min);
+    const maxIsValid = isValid$1(boundingBox.max);
+    const minIsValid = isValid$1(boundingBox.min);
     return maxIsValid && minIsValid;
 }
 
@@ -1662,13 +1662,13 @@ var boundingBox = /*#__PURE__*/Object.freeze({
 /**
  * Returns a `BoundingSphere` that encompasses the provided `BoundingBox`.
  */
-var create$8 = function (boundingBox$1) {
-    var boundingBoxCenter = center$3(boundingBox$1);
-    var centerToBoundingPlane = subtract(boundingBox$1.max, boundingBoxCenter);
-    var radius = magnitude(centerToBoundingPlane);
-    var length = Math.max(radius, magnitude(boundingBoxCenter));
-    var epsilon = length === 0 ? 1.0 : length * 1e-6;
-    return { center: boundingBoxCenter, radius: radius, epsilon: epsilon };
+const create$8 = (boundingBox$1) => {
+    const boundingBoxCenter = center$3(boundingBox$1);
+    const centerToBoundingPlane = subtract(boundingBox$1.max, boundingBoxCenter);
+    const radius = magnitude(centerToBoundingPlane);
+    const length = Math.max(radius, magnitude(boundingBoxCenter));
+    const epsilon = length === 0 ? 1.0 : length * 1e-6;
+    return { center: boundingBoxCenter, radius, epsilon };
 };
 
 var boundingSphere = /*#__PURE__*/Object.freeze({
@@ -1680,7 +1680,7 @@ var boundingSphere = /*#__PURE__*/Object.freeze({
  * Returns a new `Rectangle` with the given position and size.
  */
 function create$7(x, y, width, height) {
-    return { x: x, y: y, width: width, height: height };
+    return { x, y, width, height };
 }
 /**
  * Returns a new `Rectangle` at the origin point and given size.
@@ -1699,10 +1699,10 @@ function fromPointAndDimensions(point, dimensions) {
  * The returned rectangle will always returns a positive width and height.
  */
 function fromPoints(topLeftPt, bottomRightPt) {
-    var minX = Math.min(topLeftPt.x, bottomRightPt.x);
-    var minY = Math.min(topLeftPt.y, bottomRightPt.y);
-    var maxX = Math.max(topLeftPt.x, bottomRightPt.x);
-    var maxY = Math.max(topLeftPt.y, bottomRightPt.y);
+    const minX = Math.min(topLeftPt.x, bottomRightPt.x);
+    const minY = Math.min(topLeftPt.y, bottomRightPt.y);
+    const maxX = Math.max(topLeftPt.x, bottomRightPt.x);
+    const maxY = Math.max(topLeftPt.y, bottomRightPt.y);
     return create$7(minX, minY, maxX - minX, maxY - minY);
 }
 /**
@@ -1714,9 +1714,9 @@ function fromPoints(topLeftPt, bottomRightPt) {
  * @see {@link cropFit}
  */
 function containFit$1(to, rect) {
-    var scale = Math.min(to.width / rect.width, to.height / rect.height);
-    var dimensions$1 = proportionalScale(scale, rect);
-    var position = subtract$1(center$2(to), center$1(dimensions$1));
+    const scale = Math.min(to.width / rect.width, to.height / rect.height);
+    const dimensions$1 = proportionalScale(scale, rect);
+    const position = subtract$1(center$2(to), center$1(dimensions$1));
     return fromPointAndDimensions(position, dimensions$1);
 }
 /**
@@ -1728,9 +1728,9 @@ function containFit$1(to, rect) {
  * @see {@link containFit}
  */
 function cropFit$1(to, rect) {
-    var scale = Math.max(to.width / rect.width, to.height / rect.height);
-    var dimensions$1 = proportionalScale(scale, rect);
-    var position = subtract$1(center$2(to), center$1(dimensions$1));
+    const scale = Math.max(to.width / rect.width, to.height / rect.height);
+    const dimensions$1 = proportionalScale(scale, rect);
+    const position = subtract$1(center$2(to), center$1(dimensions$1));
     return fromPointAndDimensions(position, dimensions$1);
 }
 /**
@@ -1742,9 +1742,9 @@ function cropFit$1(to, rect) {
  * @param rect - the rectangle to scale to fit the specified area
  */
 function scaleFit$1(to, rect) {
-    var scale = Math.min(Math.sqrt(to / area$1(rect)), 1);
-    var dimensions$1 = floor(proportionalScale(scale, rect));
-    var position = subtract$1(center$2(rect), center$1(dimensions$1));
+    const scale = Math.min(Math.sqrt(to / area$1(rect)), 1);
+    const dimensions$1 = floor(proportionalScale(scale, rect));
+    const position = subtract$1(center$2(rect), center$1(dimensions$1));
     return fromPointAndDimensions(position, dimensions$1);
 }
 /**
@@ -1763,8 +1763,8 @@ function scale$1(rect, scaleOrScaleX, scaleY) {
         return scale$1(rect, scaleOrScaleX, scaleOrScaleX);
     }
     else {
-        var x = rect.x, y = rect.y, width = rect.width, height = rect.height;
-        var scaleX = scaleOrScaleX;
+        const { x, y, width, height } = rect;
+        const scaleX = scaleOrScaleX;
         return create$7(x * scaleX, y * scaleY, width * scaleX, height * scaleY);
     }
 }
@@ -1838,12 +1838,8 @@ function pad(rect, padding) {
  * @param rect The rectangle to check against.
  * @param points The points to check.
  */
-function containsPoints(rect) {
-    var points = [];
-    for (var _i = 1; _i < arguments.length; _i++) {
-        points[_i - 1] = arguments[_i];
-    }
-    return points.every(function (point) {
+function containsPoints(rect, ...points) {
+    return points.every((point) => {
         return (rect.x <= point.x &&
             rect.x + rect.width >= point.x &&
             rect.y <= point.y &&
@@ -1857,13 +1853,13 @@ function containsPoints(rect) {
  * @returns A parsed Point.
  */
 function fromJson$1(json) {
-    var obj = JSON.parse(json);
+    const obj = JSON.parse(json);
     if (Array.isArray(obj)) {
-        var x = obj[0], y = obj[1], width = obj[2], height = obj[3];
+        const [x, y, width, height] = obj;
         return create$7(x, y, width, height);
     }
     else {
-        var x = obj.x, y = obj.y, width = obj.width, height = obj.height;
+        const { x, y, width, height } = obj;
         return create$7(x, y, width, height);
     }
 }
@@ -1896,27 +1892,27 @@ var rectangle = /*#__PURE__*/Object.freeze({
  * Returns a `Dimensions` with the given width and height.
  *
  */
-var create$6 = function (width, height) {
-    return { width: width, height: height };
+const create$6 = (width, height) => {
+    return { width, height };
 };
 /**
  * Returns a `Dimensions` with the same width and height.
  */
-var square = function (size) {
+const square = (size) => {
     return create$6(size, size);
 };
 /**
  * Returns `true` if two dimensions have the same width and height. Otherwise
  * `false`.
  */
-var isEqual = function (a, b) {
+const isEqual = (a, b) => {
     return a.width === b.width && a.height === b.height;
 };
 /**
  * Returns a scaled dimensions, where the width is scaled by `scaleX` and height
  * is scaled by `scaleY`.
  */
-var scale = function (scaleX, scaleY, dimensions) {
+const scale = (scaleX, scaleY, dimensions) => {
     return {
         width: dimensions.width * scaleX,
         height: dimensions.height * scaleY,
@@ -1925,14 +1921,14 @@ var scale = function (scaleX, scaleY, dimensions) {
 /**
  * Returns a dimension where each length is scaled by `scaleFactor`.
  */
-var proportionalScale = function (scaleFactor, dimensions) {
+const proportionalScale = (scaleFactor, dimensions) => {
     return scale(scaleFactor, scaleFactor, dimensions);
 };
 /**
  * Returns a `Dimensions` where the lengths of `dimensions` are trimmed to fit
  * into `to`.
  */
-var trim = function (to, dimensions) {
+const trim = (to, dimensions) => {
     return {
         width: Math.min(to.width, dimensions.width),
         height: Math.min(to.height, dimensions.height),
@@ -1945,9 +1941,9 @@ var trim = function (to, dimensions) {
  *
  * @see #cropFit()
  */
-var containFit = function (to, dimensions) {
-    var _a = containFit$1(toRectangle(to), toRectangle(dimensions)), width = _a.width, height = _a.height;
-    return { width: width, height: height };
+const containFit = (to, dimensions) => {
+    const { width, height } = containFit$1(toRectangle(to), toRectangle(dimensions));
+    return { width, height };
 };
 /**
  * Returns a `Dimensions` where the shortest length of `dimensions` will be
@@ -1956,9 +1952,9 @@ var containFit = function (to, dimensions) {
  *
  * @see #containFit()
  */
-var cropFit = function (to, dimensions) {
-    var _a = cropFit$1(toRectangle(to), toRectangle(dimensions)), width = _a.width, height = _a.height;
-    return { width: width, height: height };
+const cropFit = (to, dimensions) => {
+    const { width, height } = cropFit$1(toRectangle(to), toRectangle(dimensions));
+    return { width, height };
 };
 /**
  * Returns a `Dimensions` where each side of `dimensions` will be reduced proportionally
@@ -1968,14 +1964,14 @@ var cropFit = function (to, dimensions) {
  * @param to - the maximum area this dimensions can have
  * @param dimensions - the dimensions to scale to fit the specified area
  */
-var scaleFit = function (to, dimensions) {
-    var _a = scaleFit$1(to, toRectangle(dimensions)), width = _a.width, height = _a.height;
-    return { width: width, height: height };
+const scaleFit = (to, dimensions) => {
+    const { width, height } = scaleFit$1(to, toRectangle(dimensions));
+    return { width, height };
 };
 /**
  * Returns a `Dimensions` with each length rounded.
  */
-var round = function (dimensions) {
+const round = (dimensions) => {
     return {
         width: Math.round(dimensions.width),
         height: Math.round(dimensions.height),
@@ -1984,7 +1980,7 @@ var round = function (dimensions) {
 /**
  * Returns a `Dimensions` with each length rounded down.
  */
-var floor = function (dimensions) {
+const floor = (dimensions) => {
     return {
         width: Math.floor(dimensions.width),
         height: Math.floor(dimensions.height),
@@ -1993,22 +1989,20 @@ var floor = function (dimensions) {
 /**
  * Returns the center point of the given `dimensions`.
  */
-var center$1 = function (dimensions) {
+const center$1 = (dimensions) => {
     return { x: dimensions.width / 2, y: dimensions.height / 2 };
 };
 /**
  * Returns the aspect ratio of the given `dimensions`, as defined by width over
  * height.
  */
-var aspectRatio = function (_a) {
-    var width = _a.width, height = _a.height;
+const aspectRatio = ({ width, height }) => {
     return width / height;
 };
 /**
  * Returns the area of the given `dimensions`.
  */
-var area = function (_a) {
-    var width = _a.width, height = _a.height;
+const area = ({ width, height }) => {
     return width * height;
 };
 /**
@@ -2017,7 +2011,7 @@ var area = function (_a) {
  * @param ratio - Aspect ratio to fit the provided Dimensions to
  * @param dimensions - Dimensions to fit to the specified ratio
  */
-var fitToRatio = function (ratio, dimensions) {
+const fitToRatio = (ratio, dimensions) => {
     if (dimensions.width >= dimensions.height * ratio) {
         return create$6(dimensions.height * ratio, dimensions.height);
     }
@@ -2026,8 +2020,7 @@ var fitToRatio = function (ratio, dimensions) {
 /**
  * Converts a dimension to a rectangle, with an optional position.
  */
-function toRectangle(dimensions, position) {
-    if (position === void 0) { position = create$d(); }
+function toRectangle(dimensions, position = create$d()) {
     return fromPointAndDimensions(position, dimensions);
 }
 
@@ -2057,9 +2050,8 @@ var dimensions = /*#__PURE__*/Object.freeze({
  *
  * @param values The values to assign to the line.
  */
-function create$5(values) {
+function create$5(values = {}) {
     var _a, _b;
-    if (values === void 0) { values = {}; }
     return {
         start: (_a = values.start) !== null && _a !== void 0 ? _a : origin(),
         end: (_b = values.end) !== null && _b !== void 0 ? _b : origin(),
@@ -2080,9 +2072,9 @@ function center(line) {
  * @returns A transformed line.
  */
 function transformMatrix(line, matrix) {
-    var start = transformMatrix$1(line.start, matrix);
-    var end = transformMatrix$1(line.end, matrix);
-    return { start: start, end: end };
+    const start = multiplyByTransformMatrixColumnMajor(line.start, matrix);
+    const end = multiplyByTransformMatrixColumnMajor(line.end, matrix);
+    return { start, end };
 }
 /**
  * Euclidean distance between the start and end points of the line.
@@ -2117,62 +2109,56 @@ var line3 = /*#__PURE__*/Object.freeze({
 /**
  * Creates a new matrix. If arguments are undefined, returns an identity matrix.
  */
-var create$4 = function (a, b, c, d, tx, ty) {
-    if (a === void 0) { a = 1; }
-    if (b === void 0) { b = 0; }
-    if (c === void 0) { c = 0; }
-    if (d === void 0) { d = 1; }
-    if (tx === void 0) { tx = 0; }
-    if (ty === void 0) { ty = 0; }
-    return { a: a, b: b, c: c, d: d, tx: tx, ty: ty };
+const create$4 = (a = 1, b = 0, c = 0, d = 1, tx = 0, ty = 0) => {
+    return { a, b, c, d, tx, ty };
 };
 /**
  * Returns an identity matrix.
  */
-var identity = function () {
+const identity = () => {
     return create$4();
 };
 /**
  * Creates a matrix that is translated by the given `tx` and `ty` values.
  */
-var translation = function (tx, ty) {
+const translation = (tx, ty) => {
     return translate(tx, ty, identity());
 };
 /**
  * Creates a matrix that is rotated by the given degrees.
  */
-var rotation = function (degrees) {
+const rotation = (degrees) => {
     return rotate(degrees, identity());
 };
 /**
  * Rotates the given matrix by the given degrees.
  */
-var rotate = function (degrees, matrix) {
-    var radians = toRadians(degrees);
-    var cos = Math.cos(radians);
-    var sin = Math.sin(radians);
-    var a = matrix.a * cos + matrix.c * sin;
-    var b = matrix.b * cos + matrix.d * sin;
-    var c = matrix.a * -sin + matrix.c * cos;
-    var d = matrix.b * -sin + matrix.d * cos;
+const rotate = (degrees, matrix) => {
+    const radians = toRadians(degrees);
+    const cos = Math.cos(radians);
+    const sin = Math.sin(radians);
+    const a = matrix.a * cos + matrix.c * sin;
+    const b = matrix.b * cos + matrix.d * sin;
+    const c = matrix.a * -sin + matrix.c * cos;
+    const d = matrix.b * -sin + matrix.d * cos;
     return create$4(a, b, c, d, matrix.tx, matrix.ty);
 };
 /**
  * Translates the given matrix along the horizontal and vertical axis by the
  * given `dx` and `dy` delta values.
  */
-var translate = function (dx, dy, matrix) {
-    var newTx = matrix.a * dx + matrix.c * dy + matrix.tx;
-    var newTy = matrix.b * dx + matrix.d * dy + matrix.ty;
+const translate = (dx, dy, matrix) => {
+    const newTx = matrix.a * dx + matrix.c * dy + matrix.tx;
+    const newTy = matrix.b * dx + matrix.d * dy + matrix.ty;
     return create$4(matrix.a, matrix.b, matrix.c, matrix.d, newTx, newTy);
 };
 /**
  * Returns the result of applying a geometric transformation of a matrix on the
  * given point.
  */
-var transformPoint = function (matrix, pt) {
-    var x = matrix.a * pt.x + matrix.c * pt.y + matrix.tx;
-    var y = matrix.b * pt.x + matrix.d * pt.y + matrix.ty;
+const transformPoint = (matrix, pt) => {
+    const x = matrix.a * pt.x + matrix.c * pt.y + matrix.tx;
+    const y = matrix.b * pt.x + matrix.d * pt.y + matrix.ty;
     return create$d(x, y);
 };
 
@@ -2187,11 +2173,7 @@ var matrix = /*#__PURE__*/Object.freeze({
   translation: translation
 });
 
-function create$3() {
-    var args = [];
-    for (var _i = 0; _i < arguments.length; _i++) {
-        args[_i] = arguments[_i];
-    }
+function create$3(...args) {
     if (args.length === 2) {
         return {
             a: args[0].x,
@@ -2241,9 +2223,8 @@ var matrix2 = /*#__PURE__*/Object.freeze({
  * @param values Values to assign to the plane.
  * @returns A new plane.
  */
-function create$2(values) {
-    if (values === void 0) { values = {}; }
-    return __assign({ normal: origin(), constant: 0 }, values);
+function create$2(values = {}) {
+    return { normal: origin(), constant: 0, ...values };
 }
 /**
  * Creates a plane from a normal and an arbitrary point on a plane.
@@ -2253,8 +2234,8 @@ function create$2(values) {
  * @returns A new plane.
  */
 function fromNormalAndCoplanarPoint(normal, point) {
-    var constant = -dot$1(point, normal);
-    return create$2({ normal: normal, constant: constant });
+    const constant = -dot$1(point, normal);
+    return create$2({ normal, constant });
 }
 /**
  * Returns the perpendicular distance from the plane to the given point.
@@ -2276,8 +2257,8 @@ function distanceToPoint(plane, point) {
  * @returns An intersecting point on the plane and line.
  */
 function intersectLine(plane, line) {
-    var direction$1 = direction(line);
-    var denominator = dot$1(plane.normal, direction$1);
+    const direction$1 = direction(line);
+    const denominator = dot$1(plane.normal, direction$1);
     if (denominator === 0) {
         if (distanceToPoint(plane, line.start) === 0) {
             return line.start;
@@ -2286,7 +2267,7 @@ function intersectLine(plane, line) {
             return undefined;
         }
     }
-    var t = -(dot$1(line.start, plane.normal) + plane.constant) / denominator;
+    const t = -(dot$1(line.start, plane.normal) + plane.constant) / denominator;
     if (t < 0 || t > 1) {
         return undefined;
     }
@@ -2302,7 +2283,7 @@ function intersectLine(plane, line) {
  * @returns The projected point.
  */
 function projectPoint(plane, point) {
-    var d = distanceToPoint(plane, point);
+    const d = distanceToPoint(plane, point);
     return add(point, scale$2(-d, plane.normal));
 }
 
@@ -2322,9 +2303,8 @@ var plane = /*#__PURE__*/Object.freeze({
  * @param value The values of the ray.
  * @returns A new ray.
  */
-function create$1(value) {
+function create$1(value = {}) {
     var _a, _b;
-    if (value === void 0) { value = {}; }
     return {
         origin: (_a = value.origin) !== null && _a !== void 0 ? _a : origin(),
         direction: (_b = value.direction) !== null && _b !== void 0 ? _b : forward(),
@@ -2350,13 +2330,13 @@ function at(ray, distance) {
  * @returns The distance to the plane, or `undefined` if it cannot be computed.
  */
 function distanceToPlane(ray, plane$1) {
-    var d = dot$1(plane$1.normal, ray.direction);
+    const d = dot$1(plane$1.normal, ray.direction);
     if (d === 0) {
         // Ray is on plane.
         return distanceToPoint(plane$1, ray.origin) === 0 ? 0 : undefined;
     }
     else {
-        var t = -(dot$1(ray.origin, plane$1.normal) + plane$1.constant) / d;
+        const t = -(dot$1(ray.origin, plane$1.normal) + plane$1.constant) / d;
         // Checks if ray intersects plane.
         return t >= 0 ? t : undefined;
     }
@@ -2371,7 +2351,7 @@ function distanceToPlane(ray, plane$1) {
  * intersect.
  */
 function intersectPlane(ray, plane) {
-    var t = distanceToPlane(ray, plane);
+    const t = distanceToPlane(ray, plane);
     return t != null ? at(ray, t) : undefined;
 }
 
@@ -2387,9 +2367,8 @@ var ray = /*#__PURE__*/Object.freeze({
  * Returns a new Vector4. If `value` is undefined, then `{x: 0, y: 0, z: 0,
  * w: 0}` is returned.
  */
-function create(value) {
-    if (value === void 0) { value = {}; }
-    return __assign({ x: 0, y: 0, z: 0, w: 0 }, value);
+function create(value = {}) {
+    return { x: 0, y: 0, z: 0, w: 0, ...value };
 }
 /**
  * Parses a JSON string representation of a `Vector4`.
@@ -2398,10 +2377,10 @@ function create(value) {
  * @returns A parsed `Vector4`.
  */
 function fromJson(json) {
-    var obj = JSON.parse(json);
+    const obj = JSON.parse(json);
     if (Array.isArray(obj)) {
-        var x = obj[0], y = obj[1], z = obj[2], w = obj[3];
-        return create({ x: x, y: y, z: z, w: w });
+        const [x, y, z, w] = obj;
+        return create({ x, y, z, w });
     }
     else {
         return create(obj);