@vertexvis/geometry 1.0.2-testing.4 → 1.0.2-testing.5

package/dist/cdn/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);
 }
 /**
@@ -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,11 +319,11 @@ 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,
@@ -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,
@@ -370,9 +366,9 @@ function makeScale(scale) {
  * @returns A transformed matrix in column-major form.
  */
 function makeTRS(translation, rotation, scale) {
-    var t = makeTranslation(translation);
-    var r = transpose(makeRotation(rotation));
-    var s = makeScale(scale);
+    const t = makeTranslation(translation);
+    const r = transpose(makeRotation(rotation));
+    const s = makeScale(scale);
     return multiply$2(s, multiply$2(r, t));
 }
 /**
@@ -420,12 +416,12 @@ function makeBasis(x, y, z) {
  * @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,
@@ -454,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);
 }
 /**
@@ -480,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,
@@ -515,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,
@@ -544,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,
@@ -561,28 +557,28 @@ 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();
     }
-    var oneOverDet = 1 / det;
+    const oneOverDet = 1 / det;
     return [
         (a11 * b11 - a12 * b10 + a13 * b09) * oneOverDet,
         (a02 * b10 - a01 * b11 - a03 * b09) * oneOverDet,
@@ -613,25 +609,25 @@ 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[1] = x.y;
@@ -649,18 +645,18 @@ function lookAt(m, position, target, up) {
  * Returns a post-multiplied matrix equal to ab.
  */
 function multiply$2(a, b) {
-    var result = makeIdentity();
+    const result = makeIdentity();
     // Consider each row i in the final matrix
-    for (var i = 0; i < 4; i++) {
+    for (let i = 0; i < 4; i++) {
         // Consider each column j in the final matrix
-        for (var j = 0; j < 4; j++) {
+        for (let j = 0; j < 4; j++) {
             // Calculate the value at row i and column j
-            var value = 0;
-            for (var k = 0; k < 4; k++) {
+            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];
             }
-            var positionInResultingMatrix = 4 * i + j;
+            const positionInResultingMatrix = 4 * i + j;
             result[positionInResultingMatrix] = value;
         }
     }
@@ -684,8 +680,8 @@ function transpose(matrix) {
  * 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[1] *= x;
@@ -708,7 +704,7 @@ function scale$4(matrix, scale) {
  * Both matrices should have row-major format.
  */
 function position(originalMatrix, matrixWithDesiredPosition) {
-    var m = __spreadArray([], originalMatrix, true);
+    const m = [...originalMatrix];
     m[12] = matrixWithDesiredPosition[12];
     m[13] = matrixWithDesiredPosition[13];
     m[14] = matrixWithDesiredPosition[14];
@@ -718,8 +714,8 @@ function position(originalMatrix, matrixWithDesiredPosition) {
  * 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`.
@@ -802,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,
@@ -820,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,
     });
 }
 /**
@@ -841,13 +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, matrixIsColumnMajor) {
-    if (order === void 0) { order = 'xyz'; }
-    if (matrixIsColumnMajor === void 0) { matrixIsColumnMajor = true; }
-    var m = matrixIsColumnMajor
+function fromRotationMatrix(matrix, order = 'xyz', matrixIsColumnMajor = true) {
+    const m = matrixIsColumnMajor
         ? toObjectColumnMajor(matrix)
         : toObjectRowMajor(matrix);
-    var x = 0, y = 0, z = 0;
+    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) {
@@ -914,7 +906,7 @@ function fromRotationMatrix(matrix, order, matrixIsColumnMajor) {
             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
@@ -925,14 +917,14 @@ function fromRotationMatrix(matrix, order, matrixIsColumnMajor) {
  * @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 };
     }
 }
 /**
@@ -940,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') &&
@@ -961,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`.
@@ -972,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);
@@ -1012,13 +1003,13 @@ 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
@@ -1026,14 +1017,14 @@ function fromAxisAngle(axis, radians) {
  */
 function fromMatrixRotation(matrix) {
     // Determine the scalars for each vector
-    var scale = fromMatrixScale(matrix);
-    var oneOverScaleVector = create$a(1 / scale.x, 1 / scale.y, 1 / scale.z);
+    const scale = fromMatrixScale(matrix);
+    const oneOverScaleVector = create$a(1 / scale.x, 1 / scale.y, 1 / scale.z);
     // Scale the matrix
-    var scaledMatrix = scale$4(matrix, oneOverScaleVector);
-    var sM = toObjectRowMajor(scaledMatrix);
-    var trace = sM.m11 + sM.m22 + sM.m33;
+    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) * 2;
+        const s = Math.sqrt(trace + 1) * 2;
         return {
             x: (sM.m23 - sM.m32) / s,
             y: (sM.m31 - sM.m13) / s,
@@ -1042,7 +1033,7 @@ function fromMatrixRotation(matrix) {
         };
     }
     else if (sM.m11 > sM.m22 && sM.m11 > sM.m33) {
-        var s = Math.sqrt(1 + sM.m11 - sM.m22 - sM.m33) * 2;
+        const s = Math.sqrt(1 + sM.m11 - sM.m22 - sM.m33) * 2;
         return {
             x: 0.25 * s,
             y: (sM.m12 + sM.m21) / s,
@@ -1051,7 +1042,7 @@ function fromMatrixRotation(matrix) {
         };
     }
     else if (sM.m22 > sM.m33) {
-        var s = Math.sqrt(1 + sM.m22 - sM.m11 - sM.m33) * 2;
+        const s = Math.sqrt(1 + sM.m22 - sM.m11 - sM.m33) * 2;
         return {
             x: (sM.m12 + sM.m21) / s,
             y: 0.25 * s,
@@ -1060,7 +1051,7 @@ function fromMatrixRotation(matrix) {
         };
     }
     else {
-        var s = Math.sqrt(1 + sM.m33 - sM.m11 - sM.m22) * 2;
+        const s = Math.sqrt(1 + sM.m33 - sM.m11 - sM.m22) * 2;
         return {
             x: (sM.m31 + sM.m13) / s,
             y: (sM.m23 + sM.m32) / s,
@@ -1070,14 +1061,14 @@ function fromMatrixRotation(matrix) {
     }
 }
 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;
@@ -1116,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.
@@ -1135,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') &&
@@ -1157,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,
@@ -1189,23 +1176,21 @@ 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(_a) {
-    var x = _a.x, y = _a.y, z = _a.z;
-    return [x, y, z].every(function (v) { return v === 0; });
+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 = toObjectRowMajor(matrix);
+    const m = toObjectRowMajor(matrix);
     return {
         x: Math.hypot(m.m11, m.m12, m.m13),
         y: Math.hypot(m.m21, m.m22, m.m23),
@@ -1216,7 +1201,7 @@ function fromMatrixScale(matrix) {
  * Returns a vector representing the position elements of `matrix`.
  */
 function fromMatrixPosition(matrix) {
-    var m = toObjectRowMajor(matrix);
+    const m = toObjectRowMajor(matrix);
     return { x: m.m41, y: m.m42, z: m.m43 };
 }
 /**
@@ -1226,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);
     }
 }
@@ -1243,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);
 }
 /**
@@ -1257,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];
 }
 /**
@@ -1307,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 };
 }
 /**
@@ -1344,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);
 }
@@ -1395,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);
 }
@@ -1406,15 +1381,18 @@ 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))));
+    const normalizedQ = normalize$1(create$b({
+        w: 1 + dotAB,
+        ...cross(normalizedA, normalizedB),
+    }));
     return fromRotationMatrix(makeRotation(normalizedQ), 'xyz', false);
 }
 /**
@@ -1445,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);
@@ -1482,8 +1460,8 @@ function transformMatrix$1(vector, m) {
  * @param m A Matrix4 item written in column-major form.
  */
 function multiplyByTransformMatrixColumnMajor(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]);
+    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,
@@ -1496,8 +1474,8 @@ function multiplyByTransformMatrixColumnMajor(vector, m) {
  * @param m A Matrix4 item written in row-major form.
  */
 function multiplyByTransformMatrixRowMajor(vector, m) {
-    var x = vector.x, y = vector.y, z = vector.z;
-    var w = 1 / (m[12] * x + m[13] * y + m[14] * z + m[15]);
+    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,
@@ -1515,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;
 }
 /**
@@ -1616,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));
     });
 }
@@ -1660,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);
 };
 /**
@@ -1668,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;
 }
 
@@ -1688,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({
@@ -1706,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.
@@ -1725,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);
 }
 /**
@@ -1740,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);
 }
 /**
@@ -1754,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);
 }
 /**
@@ -1768,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);
 }
 /**
@@ -1789,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);
     }
 }
@@ -1864,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 &&
@@ -1883,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);
     }
 }
@@ -1922,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,
@@ -1951,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),
@@ -1971,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
@@ -1982,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
@@ -1994,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),
@@ -2010,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),
@@ -2019,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;
 };
 /**
@@ -2043,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);
     }
@@ -2052,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);
 }
 
@@ -2083,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(),
@@ -2106,9 +2072,9 @@ function center(line) {
  * @returns A transformed line.
  */
 function transformMatrix(line, matrix) {
-    var start = multiplyByTransformMatrixColumnMajor(line.start, matrix);
-    var end = multiplyByTransformMatrixColumnMajor(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.
@@ -2143,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);
 };
 
@@ -2213,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,
@@ -2267,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.
@@ -2279,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.
@@ -2302,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;
@@ -2312,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;
     }
@@ -2328,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));
 }
 
@@ -2348,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(),
@@ -2376,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;
     }
@@ -2397,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;
 }
 
@@ -2413,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`.
@@ -2424,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);