@vertexvis/viewer 0.10.2-canary.7 → 0.11.0

package/dist/cjs/{bundle.esm-c457ad4d.js → bundle.esm-b79513ef.js}

@@ -143,7 +143,7 @@ function clamp(value, min, max) {
  * @param t The interpolation value between 0 and 1.
  * @returns The interpolated value between `a` and `b`.
  */
-function lerp(a, b, t) {
+function lerp$2(a, b, t) {
     t = clamp(t, 0, 1);
     return t * (b - a) + a;
 }
@@ -151,7 +151,7 @@ function lerp(a, b, t) {
 /**
  * Returns a new `Point` with the given horizontal and vertical position.
  */
-function create(x, y) {
+function create$b(x, y) {
     if (x === void 0) { x = 0; }
     if (y === void 0) { y = 0; }
     return { x: x, y: y };
@@ -162,31 +162,31 @@ function create(x, y) {
 function polar(length, radians) {
     var x = Math.cos(radians) * length;
     var y = Math.sin(radians) * length;
-    return create(x, y);
+    return create$b(x, y);
 }
 /**
  * Returns the distance between two points.
  */
-function distance(a, b) {
-    var delta = subtract(a, b);
+function distance$2(a, b) {
+    var delta = subtract$1(a, b);
     return Math.sqrt(delta.x * delta.x + delta.y * delta.y);
 }
 /**
  * Returns a new `Point` where `b` is subtracted from `a`.
  */
-function subtract(a, b) {
+function subtract$1(a, b) {
     return { x: a.x - b.x, y: a.y - b.y };
 }
 /**
  * Returns a new `Point` where `b` is added to `a`.
  */
-function add(a, b) {
+function add$1(a, b) {
     return { x: a.x + b.x, y: a.y + b.y };
 }
 /**
  * Returns `true` if the `x` and `y` positions of `a` and `b` are equal.
  */
-function isEqual(a, b) {
+function isEqual$3(a, b) {
     return a.x === b.x && a.y === b.y;
 }
 /**
@@ -200,21 +200,21 @@ function isEqual(a, b) {
  */
 function lerp$1(a, b, t) {
     return {
-        x: lerp(a.x, b.x, t),
-        y: lerp(a.y, b.y, t),
+        x: lerp$2(a.x, b.x, t),
+        y: lerp$2(a.y, b.y, t),
     };
 }
 /**
  * Returns a new `Point` where `x` and `y` are inverted.
  */
-function negate(pt) {
-    return create(-pt.x, -pt.y);
+function negate$1(pt) {
+    return create$b(-pt.x, -pt.y);
 }
 /**
  * Returns a new `Point` where `x` and `y` are multiplied by the given scale
  * factors.
  */
-function scale(pt, scaleX, scaleY) {
+function scale$4(pt, scaleX, scaleY) {
     return {
         x: pt.x * scaleX,
         y: pt.y * scaleY,
@@ -226,30 +226,30 @@ function scale(pt, scaleX, scaleY) {
  * @param json A JSON string, either in the form `[x,y]` or `{"x": 0, "y": 0}`
  * @returns A parsed Point.
  */
-function fromJson(json) {
+function fromJson$4(json) {
     var obj = JSON.parse(json);
     if (Array.isArray(obj)) {
         var x = obj[0], y = obj[1];
-        return create(x, y);
+        return create$b(x, y);
     }
     else {
         var x = obj.x, y = obj.y;
-        return create(x, y);
+        return create$b(x, y);
     }
 }
 
 var point = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  create: create,
+  create: create$b,
   polar: polar,
-  distance: distance,
-  subtract: subtract,
-  add: add,
-  isEqual: isEqual,
+  distance: distance$2,
+  subtract: subtract$1,
+  add: add$1,
+  isEqual: isEqual$3,
   lerp: lerp$1,
-  negate: negate,
-  scale: scale,
-  fromJson: fromJson
+  negate: negate$1,
+  scale: scale$4,
+  fromJson: fromJson$4
 });
 
 /**
@@ -259,8 +259,8 @@ var point = /*#__PURE__*/Object.freeze({
  * @param b The ending point.
  * @returns An angle in radians.
  */
-function fromPoints(a, b) {
-    var delta = subtract(b, a);
+function fromPoints$1(a, b) {
+    var delta = subtract$1(b, a);
     var theta = Math.atan2(delta.y, delta.x);
     return theta;
 }
@@ -273,14 +273,14 @@ function fromPoints(a, b) {
  * @deprecated Use {@link fromPoints} instead.
  */
 function fromPointsInDegrees(a, b) {
-    var delta = subtract(b, a);
+    var delta = subtract$1(b, a);
     var theta = Math.atan2(delta.y, delta.x);
-    return normalize(toDegrees(theta) - 270);
+    return normalize$1(toDegrees(theta) - 270);
 }
 /**
  * Normalizes the given angle, in degrees, to a number between 0 and 359.
  */
-function normalize(degrees) {
+function normalize$1(degrees) {
     return (degrees + 3600) % 360;
 }
 /**
@@ -298,9 +298,9 @@ function toRadians(degrees) {
 
 var angle = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  fromPoints: fromPoints,
+  fromPoints: fromPoints$1,
   fromPointsInDegrees: fromPointsInDegrees,
-  normalize: normalize,
+  normalize: normalize$1,
   toDegrees: toDegrees,
   toRadians: toRadians
 });
@@ -428,7 +428,7 @@ function makeTRS(translation, rotation, scale) {
     var t = makeTranslation(translation);
     var r = makeRotation(rotation);
     var s = makeScale(scale);
-    return multiply(multiply(t, r), s);
+    return multiply$2(multiply$2(t, r), s);
 }
 /**
  * Returns a matrix that has the basis components (upper left 3x3 matrix) set to
@@ -561,12 +561,12 @@ function makePerspective(near, far, fovY, aspect) {
  * @returns A matrix.
  */
 function makeLookAtView(position, lookAt, up) {
-    var z = normalize$1(subtract$1(position, lookAt));
-    var x = normalize$1(cross(up, z));
+    var z = normalize(subtract(position, lookAt));
+    var x = normalize(cross(up, z));
     var y = cross(z, x);
-    var dotX = -dot(x, position);
-    var dotY = -dot(y, position);
-    var dotZ = -dot(z, position);
+    var dotX = -dot$1(x, position);
+    var dotY = -dot$1(y, position);
+    var dotZ = -dot$1(z, position);
     /* eslint-disable prettier/prettier */
     return [
         x.x, y.x, z.x, 0,
@@ -590,8 +590,8 @@ function makeLookAtView(position, lookAt, up) {
  * @returns A matrix.
  */
 function makeLookAt(position, lookAt, up) {
-    var z = normalize$1(subtract$1(position, lookAt));
-    var x = normalize$1(cross(up, z));
+    var z = normalize(subtract(position, lookAt));
+    var x = normalize(cross(up, z));
     var y = cross(z, x);
     /* eslint-disable prettier/prettier */
     return [
@@ -659,11 +659,11 @@ function invert(matrix) {
  * @returns A rotation matrix.
  */
 function lookAt(m, position, target, up) {
-    var z = subtract$1(position, target);
+    var z = subtract(position, target);
     if (magnitudeSquared(z) === 0) {
         z = exports.__assign(exports.__assign({}, z), { z: 1 });
     }
-    z = normalize$1(z);
+    z = normalize(z);
     var x = cross(up, z);
     if (magnitudeSquared(x) === 0) {
         if (Math.abs(up.z) === 1) {
@@ -672,10 +672,10 @@ function lookAt(m, position, target, up) {
         else {
             z = exports.__assign(exports.__assign({}, z), { z: z.z + 0.0001 });
         }
-        z = normalize$1(z);
+        z = normalize(z);
         x = cross(up, z);
     }
-    x = normalize$1(x);
+    x = normalize(x);
     var y = cross(z, x);
     var res = __spreadArray([], m, true);
     /* eslint-disable prettier/prettier */
@@ -694,7 +694,7 @@ function lookAt(m, position, target, up) {
 /**
  * Returns a post-multiplied matrix.
  */
-function multiply(a, b) {
+function multiply$2(a, b) {
     var ae = a;
     var be = b;
     var a11 = ae[0], a12 = ae[4], a13 = ae[8], a14 = ae[12];
@@ -741,7 +741,7 @@ function transpose(matrix) {
 /**
  * Multiplies the columns of a matrix by the given vector.
  */
-function scale$1(matrix, scale) {
+function scale$3(matrix, scale) {
     var x = scale.x, y = scale.y, z = scale.z;
     var m = __spreadArray([], matrix, true);
     /* eslint-disable prettier/prettier */
@@ -783,7 +783,7 @@ function toObject(m) {
 /**
  * A type guard to check if `obj` is of type `Matrix4`.
  */
-function isType(obj) {
+function isType$2(obj) {
     return Array.isArray(obj) && obj.length === 16;
 }
 
@@ -805,15 +805,15 @@ var matrix4 = /*#__PURE__*/Object.freeze({
   makeLookAt: makeLookAt,
   invert: invert,
   lookAt: lookAt,
-  multiply: multiply,
+  multiply: multiply$2,
   transpose: transpose,
-  scale: scale$1,
+  scale: scale$3,
   position: position,
   toObject: toObject,
-  isType: isType
+  isType: isType$2
 });
 
-function create$1() {
+function create$a() {
     var _a, _b, _c, _d, _e, _f;
     var args = [];
     for (var _i = 0; _i < arguments.length; _i++) {
@@ -873,15 +873,15 @@ function fromMatrixPosition(matrix) {
  * @param json A JSON string, either in the form `[x,y,z]` or `{"x": 0, "y": 0, "z": 0}`
  * @returns A parsed Vector3.
  */
-function fromJson$1(json) {
+function fromJson$3(json) {
     var obj = JSON.parse(json);
     if (Array.isArray(obj)) {
         var x = obj[0], y = obj[1], z = obj[2];
-        return create$1(x, y, z);
+        return create$a(x, y, z);
     }
     else {
         var x = obj.x, y = obj.y, z = obj.z;
-        return create$1(x, y, z);
+        return create$a(x, y, z);
     }
 }
 /**
@@ -896,7 +896,7 @@ function fromArray(nums, offset) {
     var x = nums[offset];
     var y = nums[offset + 1];
     var z = nums[offset + 2];
-    return create$1(x, y, z);
+    return create$a(x, y, z);
 }
 /**
  * Converts a Vector3 to an array where the values of the vector will be
@@ -913,48 +913,48 @@ function toArray(_a) {
  * Returns a directional vector on the positive x axis, Vector3(1, 0, 0).
  */
 function right() {
-    return create$1(1, 0, 0);
+    return create$a(1, 0, 0);
 }
 /**
  * Returns a directional vector on the positive y axis, Vector3(0, 1, 0).
  */
 function up() {
-    return create$1(0, 1, 0);
+    return create$a(0, 1, 0);
 }
 /**
  * Returns a directional vector on the positive z axis, Vector3(0, 0, -1).
  */
 function forward() {
-    return create$1(0, 0, -1);
+    return create$a(0, 0, -1);
 }
 /**
  * Returns a directional vector on the negative x axis, Vector3(-1, 0, 0).
  */
 function left() {
-    return create$1(-1, 0, 0);
+    return create$a(-1, 0, 0);
 }
 /**
  * Returns a directional vector on the negative y axis, Vector3(0, -1, 0).
  */
 function down() {
-    return create$1(0, -1, 0);
+    return create$a(0, -1, 0);
 }
 /**
  * Returns a directional vector on the negative z axis, Vector3(0, 0, 1).
  */
 function back() {
-    return create$1(0, 0, 1);
+    return create$a(0, 0, 1);
 }
 /**
  * Returns a vector at the origin, Vector3(0, 0, 0).
  */
 function origin() {
-    return create$1(0, 0, 0);
+    return create$a(0, 0, 0);
 }
 /**
  * Returns a vector with that will have a magnitude of 1.
  */
-function normalize$1(vector) {
+function normalize(vector) {
     var length = magnitude(vector);
     return { x: vector.x / length, y: vector.y / length, z: vector.z / length };
 }
@@ -992,7 +992,7 @@ function cross(a, b) {
 /**
  * Returns a vector that is the sum of two vectors.
  */
-function add$1(a) {
+function add(a) {
     var vectors = [];
     for (var _i = 1; _i < arguments.length; _i++) {
         vectors[_i - 1] = arguments[_i];
@@ -1004,7 +1004,7 @@ function add$1(a) {
 /**
  * Returns a vector that is the difference between two vectors.
  */
-function subtract$1(a) {
+function subtract(a) {
     var vectors = [];
     for (var _i = 1; _i < arguments.length; _i++) {
         vectors[_i - 1] = arguments[_i];
@@ -1032,7 +1032,7 @@ function scale$2(scalar, vector) {
  * multiplied together and then multiplied by the cosine of the angle between
  * them.
  */
-function dot(a, b) {
+function dot$1(a, b) {
     return a.x * b.x + a.y * b.y + a.z * b.z;
 }
 /**
@@ -1043,7 +1043,7 @@ function dot(a, b) {
  * result is never greater than 180 degrees.
  */
 function angleTo(a, b) {
-    var theta = dot(a, b) / (magnitude(a) * magnitude(b));
+    var theta = dot$1(a, b) / (magnitude(a) * magnitude(b));
     // Clamp to avoid numerical problems.
     return Math.acos(theta);
 }
@@ -1063,7 +1063,7 @@ function angleTo(a, b) {
  * ```
  */
 function project(vector, onNormal) {
-    return scale$2(dot(onNormal, vector) / magnitude(onNormal), onNormal);
+    return scale$2(dot$1(onNormal, vector) / magnitude(onNormal), onNormal);
 }
 /**
  * Returns a vector that is rotated about an origin point.
@@ -1099,7 +1099,7 @@ function rotateAboutAxis(angle, point, axisDirection, axisPosition) {
 /**
  * Returns a vector that is multiplied with a matrix.
  */
-function transformMatrix(vector, m) {
+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 {
@@ -1112,38 +1112,38 @@ function transformMatrix(vector, m) {
  * Euclidean distance between two vectors
  */
 function distance$1(a, b) {
-    return Math.sqrt(distanceSquared(a, b));
+    return Math.sqrt(distanceSquared$1(a, b));
 }
 /**
  * Returns the squared distance between two vectors. If you're just comparing
  * distances, this is slightly more efficient than `distanceTo`.
  */
-function distanceSquared(a, b) {
-    var _a = subtract$1(a, b), dx = _a.x, dy = _a.y, dz = _a.z;
+function distanceSquared$1(a, b) {
+    var _a = subtract(a, b), dx = _a.x, dy = _a.y, dz = _a.z;
     return dx * dx + dy * dy + dz * dz;
 }
 /**
  * Returns `true` if two vectors have the same values.
  */
-function isEqual$1(a, b) {
+function isEqual$2(a, b) {
     return a.x === b.x && a.y === b.y && a.z === b.z;
 }
 /**
  * Returns a vector that contains the largest components of `a` and `b`.
  */
 function max(a, b) {
-    return create$1(Math.max(a.x, b.x), Math.max(a.y, b.y), Math.max(a.z, b.z));
+    return create$a(Math.max(a.x, b.x), Math.max(a.y, b.y), Math.max(a.z, b.z));
 }
 /**
  * Returns a vector that contains the smallest components of `a` and `b`.
  */
 function min(a, b) {
-    return create$1(Math.min(a.x, b.x), Math.min(a.y, b.y), Math.min(a.z, b.z));
+    return create$a(Math.min(a.x, b.x), Math.min(a.y, b.y), Math.min(a.z, b.z));
 }
 /**
  * Returns a vector that each of its component negated.
  */
-function negate$1(vector) {
+function negate(vector) {
     return { x: -vector.x, y: -vector.y, z: -vector.z };
 }
 /**
@@ -1155,21 +1155,32 @@ function negate$1(vector) {
  * @param t A value between 0 and 1.
  * @returns A point between `a` and `b`.
  */
-function lerp$2(a, b, t) {
+function lerp(a, b, t) {
     return {
-        x: lerp(a.x, b.x, t),
-        y: lerp(a.y, b.y, t),
-        z: lerp(a.z, b.z, t),
+        x: lerp$2(a.x, b.x, t),
+        y: lerp$2(a.y, b.y, t),
+        z: lerp$2(a.z, b.z, t),
     };
+}
+/**
+ * Maps a normalized device coordinate (NDC) space to world space coordinates.
+ *
+ * @param ndc A point in normalized device coordinates.
+ * @param worldMatrix A camera's world matrix.
+ * @param projectionMatrixInverse A camera's inverse projection matrix.
+ * @returns A point in world space coordinates.
+ */
+function transformNdcToWorldSpace(ndc, worldMatrix, projectionMatrixInverse) {
+    return transformMatrix$1(transformMatrix$1(ndc, projectionMatrixInverse), worldMatrix);
 }
 
 var vector3 = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  create: create$1,
+  create: create$a,
   isValid: isValid,
   fromMatrixScale: fromMatrixScale,
   fromMatrixPosition: fromMatrixPosition,
-  fromJson: fromJson$1,
+  fromJson: fromJson$3,
   fromArray: fromArray,
   toArray: toArray,
   right: right,
@@ -1179,32 +1190,33 @@ var vector3 = /*#__PURE__*/Object.freeze({
   down: down,
   back: back,
   origin: origin,
-  normalize: normalize$1,
+  normalize: normalize,
   magnitude: magnitude,
   magnitudeSquared: magnitudeSquared,
   cross: cross,
-  add: add$1,
-  subtract: subtract$1,
+  add: add,
+  subtract: subtract,
   multiply: multiply$1,
   scale: scale$2,
-  dot: dot,
+  dot: dot$1,
   angleTo: angleTo,
   project: project,
   rotateAboutAxis: rotateAboutAxis,
-  transformMatrix: transformMatrix,
+  transformMatrix: transformMatrix$1,
   distance: distance$1,
-  distanceSquared: distanceSquared,
-  isEqual: isEqual$1,
+  distanceSquared: distanceSquared$1,
+  isEqual: isEqual$2,
   max: max,
   min: min,
-  negate: negate$1,
-  lerp: lerp$2
+  negate: negate,
+  lerp: lerp,
+  transformNdcToWorldSpace: transformNdcToWorldSpace
 });
 
 /**
  * Returns a `BoundingBox` with the given min and max points.
  */
-var create$2 = function (min, max) {
+var create$9 = function (min, max) {
     return { min: min, max: max };
 };
 /**
@@ -1212,13 +1224,13 @@ var create$2 = function (min, max) {
  * are contained by the bounding box.
  */
 var fromVectors = function (vectors) {
-    return union.apply(void 0, vectors.map(function (v) { return create$2(v, v); }));
+    return union.apply(void 0, vectors.map(function (v) { return create$9(v, v); }));
 };
 /**
  * Returns the center point of the given `BoundingBox`.
  */
-var center = function (boundingBox) {
-    return scale$2(0.5, add$1(boundingBox.min, boundingBox.max));
+var center$3 = function (boundingBox) {
+    return scale$2(0.5, add(boundingBox.min, boundingBox.max));
 };
 function union(box) {
     var rest = [];
@@ -1227,47 +1239,47 @@ function union(box) {
     }
     var boxes = __spreadArray([box], rest, true);
     return boxes.reduce(function (a, b) {
-        return create$2(min(a.min, b.min), max(a.max, b.max));
+        return create$9(min(a.min, b.min), max(a.max, b.max));
     });
 }
 /* eslint-enable padding-line-between-statements */
 
 var boundingBox = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  create: create$2,
+  create: create$9,
   fromVectors: fromVectors,
-  center: center,
+  center: center$3,
   union: union
 });
 
 /**
  * Returns a new `Rectangle` with the given position and size.
  */
-function create$3(x, y, width, height) {
+function create$8(x, y, width, height) {
     return { x: x, y: y, width: width, height: height };
 }
 /**
  * Returns a new `Rectangle` at the origin point and given size.
  */
 function fromDimensions(dimensions) {
-    return create$3(0, 0, dimensions.width, dimensions.height);
+    return create$8(0, 0, dimensions.width, dimensions.height);
 }
 /**
  * Returns a new `Rectangle` with the given position and size.
  */
 function fromPointAndDimensions(point, dimensions) {
-    return create$3(point.x, point.y, dimensions.width, dimensions.height);
+    return create$8(point.x, point.y, dimensions.width, dimensions.height);
 }
 /**
  * Returns a new `Rectangle` with the given top-left and bottom-right positions.
  * The returned rectangle will always returns a positive width and height.
  */
-function fromPoints$1(topLeftPt, bottomRightPt) {
+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);
-    return create$3(minX, minY, maxX - minX, maxY - minY);
+    return create$8(minX, minY, maxX - minX, maxY - minY);
 }
 /**
  * Returns a rectangle where the longest length of `rect` will be equal to the
@@ -1277,10 +1289,10 @@ function fromPoints$1(topLeftPt, bottomRightPt) {
  *
  * @see {@link cropFit}
  */
-function containFit(to, rect) {
+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(center$1(to), center$2(dimensions$1));
+    var position = subtract$1(center$2(to), center$1(dimensions$1));
     return fromPointAndDimensions(position, dimensions$1);
 }
 /**
@@ -1291,10 +1303,10 @@ function containFit(to, rect) {
  *
  * @see {@link containFit}
  */
-function cropFit(to, rect) {
+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(center$1(to), center$2(dimensions$1));
+    var position = subtract$1(center$2(to), center$1(dimensions$1));
     return fromPointAndDimensions(position, dimensions$1);
 }
 /**
@@ -1305,10 +1317,10 @@ function cropFit(to, rect) {
  * @param to - the maximum area this rectangle can have
  * @param rect - the rectangle to scale to fit the specified area
  */
-function scaleFit(to, rect) {
-    var scale = Math.min(Math.sqrt(to / area(rect)), 1);
+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(center$1(rect), center$2(dimensions$1));
+    var position = subtract$1(center$2(rect), center$1(dimensions$1));
     return fromPointAndDimensions(position, dimensions$1);
 }
 /**
@@ -1322,52 +1334,52 @@ function scaleFit(to, rect) {
  * @param scaleY The vertical scale factor.
  * @returns A scaled rectangle.
  */
-function scale$3(rect, scaleOrScaleX, scaleY) {
+function scale$1(rect, scaleOrScaleX, scaleY) {
     if (scaleY == null) {
-        return scale$3(rect, scaleOrScaleX, scaleOrScaleX);
+        return scale$1(rect, scaleOrScaleX, scaleOrScaleX);
     }
     else {
         var x = rect.x, y = rect.y, width = rect.width, height = rect.height;
         var scaleX = scaleOrScaleX;
-        return create$3(x * scaleX, y * scaleY, width * scaleX, height * scaleY);
+        return create$8(x * scaleX, y * scaleY, width * scaleX, height * scaleY);
     }
 }
 /**
  * Returns true if two rectangles are equal in position and size.
  */
-function isEqual$2(a, b) {
-    return isEqual(a, b) && isEqual$3(a, b);
+function isEqual$1(a, b) {
+    return isEqual$3(a, b) && isEqual(a, b);
 }
 /**
  * Returns a rectangle that has its position shifted by a given offset. The
  * size of the rectangle is unchanged.
  */
 function offset(delta, rect) {
-    return fromPointAndDimensions(add(topLeft(rect), delta), rect);
+    return fromPointAndDimensions(add$1(topLeft(rect), delta), rect);
 }
 /**
  * Returns the area of the rectangle.
  */
-function area(rect) {
+function area$1(rect) {
     return rect.width * rect.height;
 }
 /**
  * Returns the center point of the rectangle.
  */
-function center$1(rect) {
+function center$2(rect) {
     return { x: rect.x + rect.width / 2, y: rect.y + rect.height / 2 };
 }
 /**
  * Returns the top-left position of the rectangle, as a point.
  */
 function topLeft(rect) {
-    return create(rect.x, rect.y);
+    return create$b(rect.x, rect.y);
 }
 /**
  * Returns the bottom-right position of the rectangle, as a point.
  */
 function bottomRight(rect) {
-    return create(rect.x + rect.width, rect.y + rect.height);
+    return create$b(rect.x + rect.width, rect.y + rect.height);
 }
 /**
  * Returns `true` if the given rectangle has a portrait aspect ratio.
@@ -1394,7 +1406,7 @@ function isSquare(rect) {
  * @param padding The padding to add.
  */
 function pad(rect, padding) {
-    return create$3(rect.x - padding, rect.y - padding, rect.width + padding * 2, rect.height + padding * 2);
+    return create$8(rect.x - padding, rect.y - padding, rect.width + padding * 2, rect.height + padding * 2);
 }
 /**
  * Parses a JSON string representation of a Rectangle and returns an object.
@@ -1406,28 +1418,28 @@ function fromJson$2(json) {
     var obj = JSON.parse(json);
     if (Array.isArray(obj)) {
         var x = obj[0], y = obj[1], width = obj[2], height = obj[3];
-        return create$3(x, y, width, height);
+        return create$8(x, y, width, height);
     }
     else {
         var x = obj.x, y = obj.y, width = obj.width, height = obj.height;
-        return create$3(x, y, width, height);
+        return create$8(x, y, width, height);
     }
 }
 
 var rectangle = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  create: create$3,
+  create: create$8,
   fromDimensions: fromDimensions,
   fromPointAndDimensions: fromPointAndDimensions,
-  fromPoints: fromPoints$1,
-  containFit: containFit,
-  cropFit: cropFit,
-  scaleFit: scaleFit,
-  scale: scale$3,
-  isEqual: isEqual$2,
+  fromPoints: fromPoints,
+  containFit: containFit$1,
+  cropFit: cropFit$1,
+  scaleFit: scaleFit$1,
+  scale: scale$1,
+  isEqual: isEqual$1,
   offset: offset,
-  area: area,
-  center: center$1,
+  area: area$1,
+  center: center$2,
   topLeft: topLeft,
   bottomRight: bottomRight,
   isPortrait: isPortrait,
@@ -1441,27 +1453,27 @@ var rectangle = /*#__PURE__*/Object.freeze({
  * Returns a `Dimensions` with the given width and height.
  *
  */
-var create$4 = function (width, height) {
+var create$7 = function (width, height) {
     return { width: width, height: height };
 };
 /**
  * Returns a `Dimensions` with the same width and height.
  */
 var square = function (size) {
-    return create$4(size, size);
+    return create$7(size, size);
 };
 /**
  * Returns `true` if two dimensions have the same width and height. Otherwise
  * `false`.
  */
-var isEqual$3 = function (a, b) {
+var isEqual = function (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$4 = function (scaleX, scaleY, dimensions) {
+var scale = function (scaleX, scaleY, dimensions) {
     return {
         width: dimensions.width * scaleX,
         height: dimensions.height * scaleY,
@@ -1471,7 +1483,7 @@ var scale$4 = function (scaleX, scaleY, dimensions) {
  * Returns a dimension where each length is scaled by `scaleFactor`.
  */
 var proportionalScale = function (scaleFactor, dimensions) {
-    return scale$4(scaleFactor, scaleFactor, dimensions);
+    return scale(scaleFactor, scaleFactor, dimensions);
 };
 /**
  * Returns a `Dimensions` where the lengths of `dimensions` are trimmed to fit
@@ -1490,8 +1502,8 @@ var trim = function (to, dimensions) {
  *
  * @see #cropFit()
  */
-var containFit$1 = function (to, dimensions) {
-    var _a = containFit(toRectangle(to), toRectangle(dimensions)), width = _a.width, height = _a.height;
+var containFit = function (to, dimensions) {
+    var _a = containFit$1(toRectangle(to), toRectangle(dimensions)), width = _a.width, height = _a.height;
     return { width: width, height: height };
 };
 /**
@@ -1501,8 +1513,8 @@ var containFit$1 = function (to, dimensions) {
  *
  * @see #containFit()
  */
-var cropFit$1 = function (to, dimensions) {
-    var _a = cropFit(toRectangle(to), toRectangle(dimensions)), width = _a.width, height = _a.height;
+var cropFit = function (to, dimensions) {
+    var _a = cropFit$1(toRectangle(to), toRectangle(dimensions)), width = _a.width, height = _a.height;
     return { width: width, height: height };
 };
 /**
@@ -1513,8 +1525,8 @@ var cropFit$1 = 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$1 = function (to, dimensions) {
-    var _a = scaleFit(to, toRectangle(dimensions)), width = _a.width, height = _a.height;
+var scaleFit = function (to, dimensions) {
+    var _a = scaleFit$1(to, toRectangle(dimensions)), width = _a.width, height = _a.height;
     return { width: width, height: height };
 };
 /**
@@ -1538,7 +1550,7 @@ var floor = function (dimensions) {
 /**
  * Returns the center point of the given `dimensions`.
  */
-var center$2 = function (dimensions) {
+var center$1 = function (dimensions) {
     return { x: dimensions.width / 2, y: dimensions.height / 2 };
 };
 /**
@@ -1552,7 +1564,7 @@ var aspectRatio = function (_a) {
 /**
  * Returns the area of the given `dimensions`.
  */
-var area$1 = function (_a) {
+var area = function (_a) {
     var width = _a.width, height = _a.height;
     return width * height;
 };
@@ -1564,34 +1576,34 @@ var area$1 = function (_a) {
  */
 var fitToRatio = function (ratio, dimensions) {
     if (dimensions.width >= dimensions.height * ratio) {
-        return create$4(dimensions.height * ratio, dimensions.height);
+        return create$7(dimensions.height * ratio, dimensions.height);
     }
-    return create$4(dimensions.width, dimensions.width / ratio);
+    return create$7(dimensions.width, dimensions.width / ratio);
 };
 /**
  * Converts a dimension to a rectangle, with an optional position.
  */
 function toRectangle(dimensions, position) {
-    if (position === void 0) { position = create(); }
+    if (position === void 0) { position = create$b(); }
     return fromPointAndDimensions(position, dimensions);
 }
 
 var dimensions = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  create: create$4,
+  create: create$7,
   square: square,
-  isEqual: isEqual$3,
-  scale: scale$4,
+  isEqual: isEqual,
+  scale: scale,
   proportionalScale: proportionalScale,
   trim: trim,
-  containFit: containFit$1,
-  cropFit: cropFit$1,
-  scaleFit: scaleFit$1,
+  containFit: containFit,
+  cropFit: cropFit,
+  scaleFit: scaleFit,
   round: round,
   floor: floor,
-  center: center$2,
+  center: center$1,
   aspectRatio: aspectRatio,
-  area: area$1,
+  area: area,
   fitToRatio: fitToRatio,
   toRectangle: toRectangle
 });
@@ -1604,7 +1616,7 @@ var dimensions = /*#__PURE__*/Object.freeze({
  * @param value The values to populate the euler angle with.
  * @returns A euler angle.
  */
-function create$5(value) {
+function create$6(value) {
     var _a, _b, _c, _d;
     if (value === void 0) { value = {}; }
     return {
@@ -1625,7 +1637,7 @@ function create$5(value) {
 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;
-    return create$5({
+    return create$6({
         x: toRadians(x),
         y: toRadians(y),
         z: toRadians(z),
@@ -1719,7 +1731,7 @@ function fromRotationMatrix(matrix, order) {
  * @param json A JSON object.
  * @returns A euler angle.
  */
-function fromJson$3(json) {
+function fromJson$1(json) {
     var 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;
@@ -1745,10 +1757,10 @@ function isType$1(obj) {
 
 var euler = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  create: create$5,
+  create: create$6,
   fromDegrees: fromDegrees,
   fromRotationMatrix: fromRotationMatrix,
-  fromJson: fromJson$3,
+  fromJson: fromJson$1,
   isType: isType$1
 });
 
@@ -1758,7 +1770,7 @@ var euler = /*#__PURE__*/Object.freeze({
  *
  * @param values The values to assign to the line.
  */
-function create$6(values) {
+function create$5(values) {
     var _a, _b;
     if (values === void 0) { values = {}; }
     return {
@@ -1769,8 +1781,8 @@ function create$6(values) {
 /**
  * Returns the point that is halfway between start and end.
  */
-function center$3(line) {
-    return lerp$2(line.start, line.end, 0.5);
+function center(line) {
+    return lerp(line.start, line.end, 0.5);
 }
 /**
  * Returns a line where the start and end points are transformed with the given
@@ -1780,45 +1792,45 @@ function center$3(line) {
  * @param matrix The matrix to apply.
  * @returns A transformed line.
  */
-function transformMatrix$1(line, matrix) {
-    var start = transformMatrix(line.start, matrix);
-    var end = transformMatrix(line.end, matrix);
+function transformMatrix(line, matrix) {
+    var start = transformMatrix$1(line.start, matrix);
+    var end = transformMatrix$1(line.end, matrix);
     return { start: start, end: end };
 }
 /**
  * Euclidean distance between the start and end points of the line.
  */
-function distance$2(line) {
+function distance(line) {
     return distance$1(line.start, line.end);
 }
 /**
  * Returns the squared distance between a line's start and end point. If you're
  * just comparing distances, this is slightly more efficient than `distanceTo`.
  */
-function distanceSquared$1(line) {
-    return distanceSquared(line.start, line.end);
+function distanceSquared(line) {
+    return distanceSquared$1(line.start, line.end);
 }
 /**
  * Returns a vector describing the direction of the line from start to end.
  */
 function direction(line) {
-    return subtract$1(line.end, line.start);
+    return subtract(line.end, line.start);
 }
 
 var line3 = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  create: create$6,
-  center: center$3,
-  transformMatrix: transformMatrix$1,
-  distance: distance$2,
-  distanceSquared: distanceSquared$1,
+  create: create$5,
+  center: center,
+  transformMatrix: transformMatrix,
+  distance: distance,
+  distanceSquared: distanceSquared,
   direction: direction
 });
 
 /**
  * Creates a new matrix. If arguments are undefined, returns an identity matrix.
  */
-var create$7 = function (a, b, c, d, tx, ty) {
+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; }
@@ -1831,7 +1843,7 @@ var create$7 = function (a, b, c, d, tx, ty) {
  * Returns an identity matrix.
  */
 var identity = function () {
-    return create$7();
+    return create$4();
 };
 /**
  * Creates a matrix that is translated by the given `tx` and `ty` values.
@@ -1856,7 +1868,7 @@ var rotate = function (degrees, matrix) {
     var b = matrix.b * cos + matrix.d * sin;
     var c = matrix.a * -sin + matrix.c * cos;
     var d = matrix.b * -sin + matrix.d * cos;
-    return create$7(a, b, c, d, matrix.tx, matrix.ty);
+    return create$4(a, b, c, d, matrix.tx, matrix.ty);
 };
 /**
  * Translates the given matrix along the horizontal and vertical axis by the
@@ -1865,7 +1877,7 @@ var rotate = function (degrees, matrix) {
 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;
-    return create$7(matrix.a, matrix.b, matrix.c, matrix.d, newTx, newTy);
+    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
@@ -1874,12 +1886,12 @@ var translate = function (dx, dy, matrix) {
 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;
-    return create(x, y);
+    return create$b(x, y);
 };
 
 var matrix = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  create: create$7,
+  create: create$4,
   identity: identity,
   translation: translation,
   rotation: rotation,
@@ -1888,7 +1900,7 @@ var matrix = /*#__PURE__*/Object.freeze({
   transformPoint: transformPoint
 });
 
-function create$8() {
+function create$3() {
     var args = [];
     for (var _i = 0; _i < arguments.length; _i++) {
         args[_i] = arguments[_i];
@@ -1925,15 +1937,15 @@ function determinant(matrix) {
 /**
  * Returns the dot product of the two vectors represented in this matrix.
  */
-function dot$1(matrix) {
+function dot(matrix) {
     return matrix.a * matrix.c + matrix.b * matrix.d;
 }
 
 var matrix2 = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  create: create$8,
+  create: create$3,
   determinant: determinant,
-  dot: dot$1
+  dot: dot
 });
 
 /**
@@ -1942,10 +1954,21 @@ var matrix2 = /*#__PURE__*/Object.freeze({
  * @param values Values to assign to the plane.
  * @returns A new plane.
  */
-function create$9(values) {
+function create$2(values) {
     if (values === void 0) { values = {}; }
     return exports.__assign({ normal: origin(), constant: 0 }, values);
 }
+/**
+ * Creates a plane from a normal and an arbitrary point on a plane.
+ *
+ * @param normal A normal.
+ * @param point A point on the plane.
+ * @returns A new plane.
+ */
+function fromNormalAndCoplanarPoint(normal, point) {
+    var constant = -dot$1(point, normal);
+    return create$2({ normal: normal, constant: constant });
+}
 /**
  * Returns the perpendicular distance from the plane to the given point.
  *
@@ -1954,7 +1977,7 @@ function create$9(values) {
  * @returns A distance.
  */
 function distanceToPoint(plane, point) {
-    return dot(plane.normal, point) + plane.constant;
+    return dot$1(plane.normal, point) + plane.constant;
 }
 /**
  * Returns the point where the line intersects with this plane. If the line does
@@ -1967,7 +1990,7 @@ function distanceToPoint(plane, point) {
  */
 function intersectLine(plane, line) {
     var direction$1 = direction(line);
-    var denominator = dot(plane.normal, direction$1);
+    var denominator = dot$1(plane.normal, direction$1);
     if (denominator === 0) {
         if (distanceToPoint(plane, line.start) === 0) {
             return line.start;
@@ -1976,12 +1999,12 @@ function intersectLine(plane, line) {
             return undefined;
         }
     }
-    var t = -(dot(line.start, plane.normal) + plane.constant) / denominator;
+    var t = -(dot$1(line.start, plane.normal) + plane.constant) / denominator;
     if (t < 0 || t > 1) {
         return undefined;
     }
     else {
-        return add$1(line.start, scale$2(t, direction$1));
+        return add(line.start, scale$2(t, direction$1));
     }
 }
 /**
@@ -1993,12 +2016,13 @@ function intersectLine(plane, line) {
  */
 function projectPoint(plane, point) {
     var d = distanceToPoint(plane, point);
-    return add$1(point, scale$2(-d, plane.normal));
+    return add(point, scale$2(-d, plane.normal));
 }
 
 var plane = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  create: create$9,
+  create: create$2,
+  fromNormalAndCoplanarPoint: fromNormalAndCoplanarPoint,
   distanceToPoint: distanceToPoint,
   intersectLine: intersectLine,
   projectPoint: projectPoint
@@ -2008,7 +2032,7 @@ var plane = /*#__PURE__*/Object.freeze({
  * Returns a new quaternion. If `value` is undefined, then `{x: 0, y: 0, z: 0,
  * w: 1}` is returned.
  */
-function create$a(value) {
+function create$1(value) {
     if (value === void 0) { value = {}; }
     return exports.__assign({ x: 0, y: 0, z: 0, w: 1 }, value);
 }
@@ -2018,14 +2042,14 @@ function create$a(value) {
  * @param json A JSON string either in the form of `[x, y, z, w]` or `{"x": 0, "y": 0, "z": 0, "w": 0}`.
  * @returns A parsed `Quaternion`.
  */
-function fromJson$4(json) {
+function fromJson(json) {
     var obj = JSON.parse(json);
     if (Array.isArray(obj)) {
         var x = obj[0], y = obj[1], z = obj[2], w = obj[3];
-        return create$a({ x: x, y: y, z: z, w: w });
+        return create$1({ x: x, y: y, z: z, w: w });
     }
     else {
-        return create$a(obj);
+        return create$1(obj);
     }
 }
 /**
@@ -2153,7 +2177,7 @@ function fromEuler(euler) {
 /**
  * Multiplies `a` x `b` and returns a new quaternion with the result.
  */
-function multiply$2(a, b) {
+function multiply(a, b) {
     // http://www.euclideanspace.com/maths/algebra/realNormedAlgebra/quaternions/code/index.htm
     return {
         x: a.x * b.w + a.w * b.x + a.y * b.z - a.z * b.y,
@@ -2165,7 +2189,7 @@ function multiply$2(a, b) {
 /**
  * Type guard that checks if the given type is a Quaternion.
  */
-function isType$2(obj) {
+function isType(obj) {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     var o = obj;
     return (o != null &&
@@ -2177,13 +2201,13 @@ function isType$2(obj) {
 
 var quaternion = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  create: create$a,
-  fromJson: fromJson$4,
+  create: create$1,
+  fromJson: fromJson,
   fromAxisAngle: fromAxisAngle,
   fromMatrixRotation: fromMatrixRotation,
   fromEuler: fromEuler,
-  multiply: multiply$2,
-  isType: isType$2
+  multiply: multiply,
+  isType: isType
 });
 
 /**
@@ -2193,7 +2217,7 @@ var quaternion = /*#__PURE__*/Object.freeze({
  * @param value The values of the ray.
  * @returns A new ray.
  */
-function create$b(value) {
+function create(value) {
     var _a, _b;
     if (value === void 0) { value = {}; }
     return {
@@ -2209,7 +2233,7 @@ function create$b(value) {
  * @returns A point on the ray.
  */
 function at(ray, distance) {
-    return add$1(scale$2(distance, ray.direction), ray.origin);
+    return add(scale$2(distance, ray.direction), ray.origin);
 }
 /**
  * Computes the distance of the `ray`s origin to the given `plane`. Returns a
@@ -2221,13 +2245,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(plane$1.normal, ray.direction);
+    var 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(ray.origin, plane$1.normal) + plane$1.constant) / d;
+        var t = -(dot$1(ray.origin, plane$1.normal) + plane$1.constant) / d;
         // Checks if ray intersects plane.
         return t >= 0 ? t : undefined;
     }
@@ -2248,7 +2272,7 @@ function intersectPlane(ray, plane) {
 
 var ray = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  create: create$b,
+  create: create,
   at: at,
   distanceToPlane: distanceToPlane,
   intersectPlane: intersectPlane