@vertexvis/viewer 0.10.2-canary.7 → 0.11.0

package/dist/esm/{bundle.esm-590d2273.js → bundle.esm-d891316f.js}

@@ -141,7 +141,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;
 }
@@ -149,7 +149,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 };
@@ -160,31 +160,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;
 }
 /**
@@ -198,21 +198,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,
@@ -224,30 +224,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
 });
 
 /**
@@ -257,8 +257,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;
 }
@@ -271,14 +271,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;
 }
 /**
@@ -296,9 +296,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
 });
@@ -426,7 +426,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
@@ -559,12 +559,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,
@@ -588,8 +588,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 [
@@ -657,11 +657,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 = __assign(__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) {
@@ -670,10 +670,10 @@ function lookAt(m, position, target, up) {
         else {
             z = __assign(__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 */
@@ -692,7 +692,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];
@@ -739,7 +739,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 */
@@ -781,7 +781,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;
 }
 
@@ -803,15 +803,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++) {
@@ -871,15 +871,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);
     }
 }
 /**
@@ -894,7 +894,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
@@ -911,48 +911,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 };
 }
@@ -990,7 +990,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];
@@ -1002,7 +1002,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];
@@ -1030,7 +1030,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;
 }
 /**
@@ -1041,7 +1041,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);
 }
@@ -1061,7 +1061,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.
@@ -1097,7 +1097,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 {
@@ -1110,38 +1110,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 };
 }
 /**
@@ -1153,21 +1153,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,
@@ -1177,32 +1188,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 };
 };
 /**
@@ -1210,13 +1222,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 = [];
@@ -1225,47 +1237,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
@@ -1275,10 +1287,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);
 }
 /**
@@ -1289,10 +1301,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);
 }
 /**
@@ -1303,10 +1315,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);
 }
 /**
@@ -1320,52 +1332,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.
@@ -1392,7 +1404,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.
@@ -1404,28 +1416,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,
@@ -1439,27 +1451,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,
@@ -1469,7 +1481,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
@@ -1488,8 +1500,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 };
 };
 /**
@@ -1499,8 +1511,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 };
 };
 /**
@@ -1511,8 +1523,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 };
 };
 /**
@@ -1536,7 +1548,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 };
 };
 /**
@@ -1550,7 +1562,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;
 };
@@ -1562,34 +1574,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
 });
@@ -1602,7 +1614,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 {
@@ -1623,7 +1635,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),
@@ -1717,7 +1729,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;
@@ -1743,10 +1755,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
 });
 
@@ -1756,7 +1768,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 {
@@ -1767,8 +1779,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
@@ -1778,45 +1790,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; }
@@ -1829,7 +1841,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.
@@ -1854,7 +1866,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
@@ -1863,7 +1875,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
@@ -1872,12 +1884,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,
@@ -1886,7 +1898,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];
@@ -1923,15 +1935,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
 });
 
 /**
@@ -1940,10 +1952,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 __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.
  *
@@ -1952,7 +1975,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
@@ -1965,7 +1988,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;
@@ -1974,12 +1997,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));
     }
 }
 /**
@@ -1991,12 +2014,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
@@ -2006,7 +2030,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 __assign({ x: 0, y: 0, z: 0, w: 1 }, value);
 }
@@ -2016,14 +2040,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);
     }
 }
 /**
@@ -2151,7 +2175,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,
@@ -2163,7 +2187,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 &&
@@ -2175,13 +2199,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
 });
 
 /**
@@ -2191,7 +2215,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 {
@@ -2207,7 +2231,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
@@ -2219,13 +2243,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;
     }
@@ -2246,10 +2270,10 @@ function intersectPlane(ray, plane) {
 
 var ray = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  create: create$b,
+  create: create,
   at: at,
   distanceToPlane: distanceToPlane,
   intersectPlane: intersectPlane
 });
 
-export { __extends as _, __awaiter as a, __generator as b, __assign as c, __spreadArray as d, boundingBox as e, dimensions as f, rectangle as g, plane as h, angle as i, __read as j, __rest as k, matrix2 as l, matrix4 as m, matrix as n, line3 as o, point as p, quaternion as q, ray as r, euler as s, vector3 as v };
+export { __extends as _, __awaiter as a, __generator as b, __assign as c, __spreadArray as d, boundingBox as e, dimensions as f, rectangle as g, plane as h, __read as i, __rest as j, angle as k, matrix2 as l, matrix4 as m, matrix as n, line3 as o, point as p, quaternion as q, ray as r, euler as s, vector3 as v };