@vertexvis/geometry 0.10.2-canary.1 → 0.10.2-canary.13

package/dist/bundle.cjs.js

@@ -25,7 +25,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;
 }
@@ -33,7 +33,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 };
@@ -44,31 +44,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;
 }
 /**
@@ -82,38 +82,56 @@ 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,
     };
+}
+/**
+ * Parses a JSON string representation of a Point and returns an object.
+ *
+ * @param json A JSON string, either in the form `[x,y]` or `{"x": 0, "y": 0}`
+ * @returns A parsed Point.
+ */
+function fromJson$4(json) {
+    var obj = JSON.parse(json);
+    if (Array.isArray(obj)) {
+        var x = obj[0], y = obj[1];
+        return create$b(x, y);
+    }
+    else {
+        var x = obj.x, y = obj.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
+  negate: negate$1,
+  scale: scale$4,
+  fromJson: fromJson$4
 });
 
 /**
@@ -123,8 +141,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;
 }
@@ -137,14 +155,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;
 }
 /**
@@ -162,9 +180,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
 });
@@ -292,7 +310,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
@@ -425,12 +443,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,
@@ -454,8 +472,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 [
@@ -523,11 +541,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 = tslib.__assign(tslib.__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) {
@@ -536,10 +554,10 @@ function lookAt(m, position, target, up) {
         else {
             z = tslib.__assign(tslib.__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 = tslib.__spreadArray([], m, true);
     /* eslint-disable prettier/prettier */
@@ -558,7 +576,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];
@@ -605,7 +623,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 = tslib.__spreadArray([], matrix, true);
     /* eslint-disable prettier/prettier */
@@ -647,7 +665,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;
 }
 
@@ -669,15 +687,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++) {
@@ -737,15 +755,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(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);
     }
 }
 /**
@@ -760,7 +778,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
@@ -777,48 +795,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 };
 }
@@ -856,7 +874,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];
@@ -868,7 +886,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];
@@ -896,7 +914,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;
 }
 /**
@@ -907,7 +925,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);
 }
@@ -927,7 +945,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.
@@ -963,7 +981,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 {
@@ -976,38 +994,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 };
 }
 /**
@@ -1019,21 +1037,21 @@ 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),
     };
 }
 
 var vector3 = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  create: create$1,
+  create: create$a,
   isValid: isValid,
   fromMatrixScale: fromMatrixScale,
   fromMatrixPosition: fromMatrixPosition,
-  fromJson: fromJson,
+  fromJson: fromJson$3,
   fromArray: fromArray,
   toArray: toArray,
   right: right,
@@ -1043,32 +1061,32 @@ 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
 });
 
 /**
  * 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 };
 };
 /**
@@ -1076,13 +1094,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 = [];
@@ -1091,47 +1109,47 @@ function union(box) {
     }
     var boxes = tslib.__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
@@ -1141,10 +1159,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);
 }
 /**
@@ -1155,10 +1173,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);
 }
 /**
@@ -1169,10 +1187,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);
 }
 /**
@@ -1186,52 +1204,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.
@@ -1250,54 +1268,82 @@ function isLandscape(rect) {
  */
 function isSquare(rect) {
     return rect.width === rect.height;
+}
+/**
+ * Pads a rectangle by the given amount, maintaining the center position.
+ *
+ * @param rect The rectangle to apply padding to.
+ * @param padding The padding to add.
+ */
+function pad(rect, padding) {
+    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.
+ *
+ * @param json A JSON string, either in the form `[x,y,width,height]` or `{"x": 0, "y": 0, "width": 10, "height": 10}`
+ * @returns A parsed Point.
+ */
+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$8(x, y, width, height);
+    }
+    else {
+        var x = obj.x, y = obj.y, width = obj.width, height = obj.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,
   isLandscape: isLandscape,
-  isSquare: isSquare
+  isSquare: isSquare,
+  pad: pad,
+  fromJson: fromJson$2
 });
 
 /**
  * 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,
@@ -1307,7 +1353,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
@@ -1326,8 +1372,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 };
 };
 /**
@@ -1337,8 +1383,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 };
 };
 /**
@@ -1349,8 +1395,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 };
 };
 /**
@@ -1374,7 +1420,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 };
 };
 /**
@@ -1388,7 +1434,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;
 };
@@ -1400,34 +1446,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
 });
@@ -1440,7 +1486,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 {
@@ -1461,7 +1507,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),
@@ -1581,7 +1627,7 @@ function isType$1(obj) {
 
 var euler = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  create: create$5,
+  create: create$6,
   fromDegrees: fromDegrees,
   fromRotationMatrix: fromRotationMatrix,
   fromJson: fromJson$1,
@@ -1594,7 +1640,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 {
@@ -1605,8 +1651,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
@@ -1616,45 +1662,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; }
@@ -1667,7 +1713,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.
@@ -1692,7 +1738,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
@@ -1701,7 +1747,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
@@ -1710,12 +1756,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,
@@ -1724,7 +1770,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];
@@ -1761,15 +1807,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
 });
 
 /**
@@ -1778,7 +1824,7 @@ 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 tslib.__assign({ normal: origin(), constant: 0 }, values);
 }
@@ -1790,7 +1836,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
@@ -1803,7 +1849,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;
@@ -1812,12 +1858,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));
     }
 }
 /**
@@ -1829,12 +1875,12 @@ 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,
   distanceToPoint: distanceToPoint,
   intersectLine: intersectLine,
   projectPoint: projectPoint
@@ -1844,7 +1890,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 tslib.__assign({ x: 0, y: 0, z: 0, w: 1 }, value);
 }
@@ -1854,14 +1900,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$2(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);
     }
 }
 /**
@@ -1989,7 +2035,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,
@@ -2001,7 +2047,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 &&
@@ -2013,13 +2059,13 @@ function isType$2(obj) {
 
 var quaternion = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  create: create$a,
-  fromJson: fromJson$2,
+  create: create$1,
+  fromJson: fromJson,
   fromAxisAngle: fromAxisAngle,
   fromMatrixRotation: fromMatrixRotation,
   fromEuler: fromEuler,
-  multiply: multiply$2,
-  isType: isType$2
+  multiply: multiply,
+  isType: isType
 });
 
 /**
@@ -2029,7 +2075,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 {
@@ -2045,7 +2091,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
@@ -2057,13 +2103,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;
     }
@@ -2084,7 +2130,7 @@ function intersectPlane(ray, plane) {
 
 var ray = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  create: create$b,
+  create: create,
   at: at,
   distanceToPlane: distanceToPlane,
   intersectPlane: intersectPlane
@@ -2105,5 +2151,5 @@ exports.Ray = ray;
 exports.Rectangle = rectangle;
 exports.Vector3 = vector3;
 exports.clamp = clamp;
-exports.lerp = lerp;
+exports.lerp = lerp$2;
 //# sourceMappingURL=bundle.cjs.js.map