@math.gl/core 4.1.0-alpha.9 → 4.1.0

package/dist/index.cjs

@@ -220,6 +220,11 @@ function map(value, func, result) {
 
 // dist/classes/base/math-array.js
 var MathArray = class extends Array {
+  // Common methods
+  /**
+   * Clone the current object
+   * @returns a new copy of this object
+   */
   clone() {
     return new this.constructor().copy(this);
   }
@@ -239,7 +244,10 @@ var MathArray = class extends Array {
     return targetObject;
   }
   from(arrayOrObject) {
-    return Array.isArray(arrayOrObject) ? this.copy(arrayOrObject) : this.fromObject(arrayOrObject);
+    return Array.isArray(arrayOrObject) ? this.copy(arrayOrObject) : (
+      // @ts-ignore
+      this.fromObject(arrayOrObject)
+    );
   }
   to(arrayOrObject) {
     if (arrayOrObject === this) {
@@ -250,12 +258,14 @@ var MathArray = class extends Array {
   toTarget(target) {
     return target ? this.to(target) : this;
   }
+  /** @deprecated */
   toFloat32Array() {
     return new Float32Array(this);
   }
   toString() {
     return this.formatString(config);
   }
+  /** Formats string according to options */
   formatString(opts) {
     let string = "";
     for (let i = 0; i < this.ELEMENTS; ++i) {
@@ -285,6 +295,8 @@ var MathArray = class extends Array {
     }
     return true;
   }
+  // Modifiers
+  /** Negates all values in this object */
   negate() {
     for (let i = 0; i < this.ELEMENTS; ++i) {
       this[i] = -this[i];
@@ -302,12 +314,14 @@ var MathArray = class extends Array {
     }
     return this.check();
   }
+  /** Minimal */
   min(vector) {
     for (let i = 0; i < this.ELEMENTS; ++i) {
       this[i] = Math.min(vector[i], this[i]);
     }
     return this.check();
   }
+  /** Maximal */
   max(vector) {
     for (let i = 0; i < this.ELEMENTS; ++i) {
       this[i] = Math.max(vector[i], this[i]);
@@ -348,18 +362,25 @@ var MathArray = class extends Array {
     }
     return this.check();
   }
+  /**
+   * Multiplies all elements by `scale`
+   * Note: `Matrix4.multiplyByScalar` only scales its 3x3 "minor"
+   */
   multiplyByScalar(scalar) {
     for (let i = 0; i < this.ELEMENTS; ++i) {
       this[i] *= scalar;
     }
     return this.check();
   }
+  // Debug checks
+  /** Throws an error if array length is incorrect or contains illegal values */
   check() {
     if (config.debug && !this.validate()) {
       throw new Error(`math.gl: ${this.constructor.name} some fields set to invalid numbers'`);
     }
     return this;
   }
+  /** Returns false if the array length is incorrect or contains illegal values */
   validate() {
     let valid = this.length === this.ELEMENTS;
     for (let i = 0; i < this.ELEMENTS; ++i) {
@@ -367,39 +388,48 @@ var MathArray = class extends Array {
     }
     return valid;
   }
+  // three.js compatibility
+  /** @deprecated */
   sub(a) {
     return this.subtract(a);
   }
+  /** @deprecated */
   setScalar(a) {
     for (let i = 0; i < this.ELEMENTS; ++i) {
       this[i] = a;
     }
     return this.check();
   }
+  /** @deprecated */
   addScalar(a) {
     for (let i = 0; i < this.ELEMENTS; ++i) {
       this[i] += a;
     }
     return this.check();
   }
+  /** @deprecated */
   subScalar(a) {
     return this.addScalar(-a);
   }
+  /** @deprecated */
   multiplyScalar(scalar) {
     for (let i = 0; i < this.ELEMENTS; ++i) {
       this[i] *= scalar;
     }
     return this.check();
   }
+  /** @deprecated */
   divideScalar(a) {
     return this.multiplyByScalar(1 / a);
   }
+  /** @deprecated */
   clampScalar(min4, max4) {
     for (let i = 0; i < this.ELEMENTS; ++i) {
       this[i] = Math.min(Math.max(this[i], min4), max4);
     }
     return this.check();
   }
+  /** @deprecated */
   get elements() {
     return this;
   }
@@ -439,6 +469,7 @@ function assert(condition, message) {
 
 // dist/classes/base/vector.js
 var Vector = class extends MathArray {
+  // ACCESSORS
   get x() {
     return this[0];
   }
@@ -451,12 +482,24 @@ var Vector = class extends MathArray {
   set y(value) {
     this[1] = checkNumber(value);
   }
+  /**
+   * Returns the length of the vector from the origin to the point described by this vector
+   *
+   * @note `length` is a reserved word for Arrays, so `v.length()` will return number of elements
+   * Instead we provide `len` and `magnitude`
+   */
   len() {
     return Math.sqrt(this.lengthSquared());
   }
+  /**
+   * Returns the length of the vector from the origin to the point described by this vector
+   */
   magnitude() {
     return this.len();
   }
+  /**
+   * Returns the squared length of the vector from the origin to the point described by this vector
+   */
   lengthSquared() {
     let length5 = 0;
     for (let i = 0; i < this.ELEMENTS; ++i) {
@@ -464,6 +507,9 @@ var Vector = class extends MathArray {
     }
     return length5;
   }
+  /**
+   * Returns the squared length of the vector from the origin to the point described by this vector
+   */
   magnitudeSquared() {
     return this.lengthSquared();
   }
@@ -485,6 +531,7 @@ var Vector = class extends MathArray {
     }
     return checkNumber(product);
   }
+  // MODIFIERS
   normalize() {
     const length5 = this.magnitude();
     if (length5 !== 0) {
@@ -510,6 +557,7 @@ var Vector = class extends MathArray {
     }
     return this.check();
   }
+  // THREE.js compatibility
   lengthSq() {
     return this.lengthSquared();
   }
@@ -900,6 +948,7 @@ function vec4_transformMat3(out, a, m) {
 
 // dist/classes/vector2.js
 var Vector2 = class extends Vector {
+  // Creates a new, empty vec2
   constructor(x = 0, y = 0) {
     super(2);
     if (isArray(x) && arguments.length === 1) {
@@ -937,22 +986,47 @@ var Vector2 = class extends Vector {
     object.y = this[1];
     return object;
   }
+  // Getters/setters
   get ELEMENTS() {
     return 2;
   }
+  /**
+   * Returns angle from x axis
+   * @returns
+   */
   horizontalAngle() {
     return Math.atan2(this.y, this.x);
   }
+  /**
+   * Returns angle from y axis
+   * @returns
+   */
   verticalAngle() {
     return Math.atan2(this.x, this.y);
   }
+  // Transforms
+  /**
+   * Transforms as point
+   * @param matrix4
+   * @returns
+   */
   transform(matrix4) {
     return this.transformAsPoint(matrix4);
   }
+  /**
+   * transforms as point (4th component is implicitly 1)
+   * @param matrix4
+   * @returns
+   */
   transformAsPoint(matrix4) {
     transformMat4(this, this, matrix4);
     return this.check();
   }
+  /**
+   * transforms as vector (4th component is implicitly 0, ignores translation. slightly faster)
+   * @param matrix4
+   * @returns
+   */
   transformAsVector(matrix4) {
     vec2_transformMat4AsVector(this, this, matrix4);
     return this.check();
@@ -1409,6 +1483,12 @@ var Vector3 = class extends Vector {
     }
     return ZERO;
   }
+  /**
+   * @class
+   * @param x
+   * @param y
+   * @param z
+   */
   constructor(x = 0, y = 0, z = 0) {
     super(-0, -0, -0);
     if (arguments.length === 1 && isArray(x)) {
@@ -1453,6 +1533,7 @@ var Vector3 = class extends Vector {
     object.z = this[2];
     return object;
   }
+  // Getters/setters
   get ELEMENTS() {
     return 3;
   }
@@ -1462,9 +1543,11 @@ var Vector3 = class extends Vector {
   set z(value) {
     this[2] = checkNumber(value);
   }
+  // ACCESSORS
   angle(vector) {
     return angle2(this, vector);
   }
+  // MODIFIERS
   cross(vector) {
     cross2(this, this, vector);
     return this.check();
@@ -1481,13 +1564,17 @@ var Vector3 = class extends Vector {
     rotateZ(this, this, origin, radians2);
     return this.check();
   }
+  // Transforms
+  // transforms as point (4th component is implicitly 1)
   transform(matrix4) {
     return this.transformAsPoint(matrix4);
   }
+  // transforms as point (4th component is implicitly 1)
   transformAsPoint(matrix4) {
     transformMat42(this, this, matrix4);
     return this.check();
   }
+  // transforms as vector  (4th component is implicitly 0, ignores translation. slightly faster)
   transformAsVector(matrix4) {
     vec3_transformMat4AsVector(this, this, matrix4);
     return this.check();
@@ -1567,6 +1654,8 @@ var Vector4 = class extends Vector {
     object.w = this[3];
     return object;
   }
+  // Getters/setters
+  /* eslint-disable no-multi-spaces, brace-style, no-return-assign */
   get ELEMENTS() {
     return 4;
   }
@@ -1598,6 +1687,7 @@ var Vector4 = class extends Vector {
     transformQuat(this, this, quaternion);
     return this.check();
   }
+  // three.js compatibility
   applyMatrix4(m) {
     m.transform(this, this);
     return this;
@@ -1606,6 +1696,16 @@ var Vector4 = class extends Vector {
 
 // dist/classes/base/matrix.js
 var Matrix = class extends MathArray {
+  // fromObject(object) {
+  //   const array = object.elements;
+  //   return this.fromRowMajor(array);
+  // }
+  // toObject(object) {
+  //   const array = object.elements;
+  //   this.toRowMajor(array);
+  //   return object;
+  // }
+  // TODO better override formatString?
   toString() {
     let string = "[";
     if (config.printRowMajor) {
@@ -1627,9 +1727,11 @@ var Matrix = class extends MathArray {
   getElementIndex(row, col) {
     return col * this.RANK + row;
   }
+  // By default assumes row major indices
   getElement(row, col) {
     return this[col * this.RANK + row];
   }
+  // By default assumes row major indices
   setElement(row, col, value) {
     this[col * this.RANK + row] = checkNumber(value);
     return this;
@@ -2219,16 +2321,30 @@ var Matrix3 = class extends Matrix {
     this[8] = array[8];
     return this.check();
   }
+  // Constructors
   identity() {
     return this.copy(IDENTITY_MATRIX);
   }
+  /**
+   *
+   * @param object
+   * @returns self
+   */
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
   fromObject(object) {
     return this.check();
   }
+  /** Calculates a 3x3 matrix from the given quaternion
+   * q quat  Quaternion to create matrix from
+   */
   fromQuaternion(q) {
     fromQuat(this, q);
     return this.check();
   }
+  /**
+   * accepts column major order, stores in column major order
+   */
+  // eslint-disable-next-line max-params
   set(m00, m10, m20, m01, m11, m21, m02, m12, m22) {
     this[0] = m00;
     this[1] = m10;
@@ -2241,6 +2357,10 @@ var Matrix3 = class extends Matrix {
     this[8] = m22;
     return this.check();
   }
+  /**
+   * accepts row major order, stores as column major
+   */
+  // eslint-disable-next-line max-params
   setRowMajor(m00, m01, m02, m10, m11, m12, m20, m21, m22) {
     this[0] = m00;
     this[1] = m10;
@@ -2253,17 +2373,21 @@ var Matrix3 = class extends Matrix {
     this[8] = m22;
     return this.check();
   }
+  // Accessors
   determinant() {
     return determinant(this);
   }
+  // Modifiers
   transpose() {
     transpose(this, this);
     return this.check();
   }
+  /** Invert a matrix. Note that this can fail if the matrix is not invertible */
   invert() {
     invert(this, this);
     return this.check();
   }
+  // Operations
   multiplyLeft(a) {
     multiply3(this, a, this);
     return this.check();
@@ -2288,6 +2412,7 @@ var Matrix3 = class extends Matrix {
     translate(this, this, vec);
     return this.check();
   }
+  // Transforms
   transform(vector, result) {
     let out;
     switch (vector.length) {
@@ -2306,12 +2431,15 @@ var Matrix3 = class extends Matrix {
     checkVector(out, vector.length);
     return out;
   }
+  /** @deprecated */
   transformVector(vector, result) {
     return this.transform(vector, result);
   }
+  /** @deprecated */
   transformVector2(vector, result) {
     return this.transform(vector, result);
   }
+  /** @deprecated */
   transformVector3(vector, result) {
     return this.transform(vector, result);
   }
@@ -4238,6 +4366,7 @@ var Matrix4 = class extends Matrix {
     this[15] = array[15];
     return this.check();
   }
+  // eslint-disable-next-line max-params
   set(m00, m10, m20, m30, m01, m11, m21, m31, m02, m12, m22, m32, m03, m13, m23, m33) {
     this[0] = m00;
     this[1] = m10;
@@ -4257,6 +4386,8 @@ var Matrix4 = class extends Matrix {
     this[15] = m33;
     return this.check();
   }
+  // accepts row major order, stores as column major
+  // eslint-disable-next-line max-params
   setRowMajor(m00, m01, m02, m03, m10, m11, m12, m13, m20, m21, m22, m23, m30, m31, m32, m33) {
     this[0] = m00;
     this[1] = m10;
@@ -4295,16 +4426,39 @@ var Matrix4 = class extends Matrix {
     result[15] = this[15];
     return result;
   }
+  // Constructors
+  /** Set to identity matrix */
   identity() {
     return this.copy(IDENTITY_MATRIX2);
   }
+  /**
+   *
+   * @param object
+   * @returns self
+   */
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
   fromObject(object) {
     return this.check();
   }
+  /**
+   * Calculates a 4x4 matrix from the given quaternion
+   * @param quaternion Quaternion to create matrix from
+   * @returns self
+   */
   fromQuaternion(quaternion) {
     fromQuat3(this, quaternion);
     return this.check();
   }
+  /**
+   * Generates a frustum matrix with the given bounds
+   * @param view.left - Left bound of the frustum
+   * @param view.right - Right bound of the frustum
+   * @param view.bottom - Bottom bound of the frustum
+   * @param view.top - Top bound of the frustum
+   * @param view.near - Near bound of the frustum
+   * @param view.far - Far bound of the frustum. Can be set to Infinity.
+   * @returns self
+   */
   frustum(view) {
     const { left, right, bottom, top, near = DEFAULT_NEAR, far = DEFAULT_FAR } = view;
     if (far === Infinity) {
@@ -4314,16 +4468,45 @@ var Matrix4 = class extends Matrix {
     }
     return this.check();
   }
+  /**
+   * Generates a look-at matrix with the given eye position, focal point,
+   * and up axis
+   * @param view.eye - (vector) Position of the viewer
+   * @param view.center - (vector) Point the viewer is looking at
+   * @param view.up - (vector) Up axis
+   * @returns self
+   */
   lookAt(view) {
     const { eye, center = [0, 0, 0], up = [0, 1, 0] } = view;
     lookAt(this, eye, center, up);
     return this.check();
   }
+  /**
+   * Generates a orthogonal projection matrix with the given bounds
+   * from "traditional" view space parameters
+   * @param view.left - Left bound of the frustum
+   * @param view.right number  Right bound of the frustum
+   * @param view.bottom - Bottom bound of the frustum
+   * @param view.top number  Top bound of the frustum
+   * @param view.near - Near bound of the frustum
+   * @param view.far number  Far bound of the frustum
+   * @returns self
+   */
   ortho(view) {
     const { left, right, bottom, top, near = DEFAULT_NEAR, far = DEFAULT_FAR } = view;
     ortho(this, left, right, bottom, top, near, far);
     return this.check();
   }
+  /**
+   * Generates an orthogonal projection matrix with the same parameters
+   * as a perspective matrix (plus focalDistance)
+   * @param view.fovy Vertical field of view in radians
+   * @param view.aspect Aspect ratio. Typically viewport width / viewport height
+   * @param view.focalDistance Distance in the view frustum used for extent calculations
+   * @param view.near Near bound of the frustum
+   * @param view.far Far bound of the frustum
+   * @returns self
+   */
   orthographic(view) {
     const { fovy = DEFAULT_FOVY, aspect = DEFAULT_ASPECT, focalDistance = 1, near = DEFAULT_NEAR, far = DEFAULT_FAR } = view;
     checkRadians(fovy);
@@ -4339,27 +4522,53 @@ var Matrix4 = class extends Matrix {
       far
     });
   }
+  /**
+   * Generates a perspective projection matrix with the given bounds
+   * @param view.fovy Vertical field of view in radians
+   * @param view.aspect Aspect ratio. typically viewport width/height
+   * @param view.near Near bound of the frustum
+   * @param view.far Far bound of the frustum
+   * @returns self
+   */
   perspective(view) {
     const { fovy = 45 * Math.PI / 180, aspect = 1, near = 0.1, far = 500 } = view;
     checkRadians(fovy);
     perspective(this, fovy, aspect, near, far);
     return this.check();
   }
+  // Accessors
   determinant() {
     return determinant2(this);
   }
+  /**
+   * Extracts the non-uniform scale assuming the matrix is an affine transformation.
+   * The scales are the "lengths" of the column vectors in the upper-left 3x3 matrix.
+   * @param result
+   * @returns self
+   */
   getScale(result = [-0, -0, -0]) {
     result[0] = Math.sqrt(this[0] * this[0] + this[1] * this[1] + this[2] * this[2]);
     result[1] = Math.sqrt(this[4] * this[4] + this[5] * this[5] + this[6] * this[6]);
     result[2] = Math.sqrt(this[8] * this[8] + this[9] * this[9] + this[10] * this[10]);
     return result;
   }
+  /**
+   * Gets the translation portion, assuming the matrix is a affine transformation matrix.
+   * @param result
+   * @returns self
+   */
   getTranslation(result = [-0, -0, -0]) {
     result[0] = this[12];
     result[1] = this[13];
     result[2] = this[14];
     return result;
   }
+  /**
+   * Gets upper left 3x3 pure rotation matrix (non-scaling), assume affine transformation matrix
+   * @param result
+   * @param scaleResult
+   * @returns self
+   */
   getRotation(result, scaleResult) {
     result = result || [-0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0];
     scaleResult = scaleResult || [-0, -0, -0];
@@ -4385,6 +4594,12 @@ var Matrix4 = class extends Matrix {
     result[15] = 1;
     return result;
   }
+  /**
+   *
+   * @param result
+   * @param scaleResult
+   * @returns self
+   */
   getRotationMatrix3(result, scaleResult) {
     result = result || [-0, -0, -0, -0, -0, -0, -0, -0, -0];
     scaleResult = scaleResult || [-0, -0, -0];
@@ -4403,6 +4618,7 @@ var Matrix4 = class extends Matrix {
     result[8] = this[10] * inverseScale2;
     return result;
   }
+  // Modifiers
   transpose() {
     transpose2(this, this);
     return this.check();
@@ -4411,6 +4627,7 @@ var Matrix4 = class extends Matrix {
     invert2(this, this);
     return this.check();
   }
+  // Operations
   multiplyLeft(a) {
     multiply4(this, a, this);
     return this.check();
@@ -4419,33 +4636,68 @@ var Matrix4 = class extends Matrix {
     multiply4(this, this, a);
     return this.check();
   }
+  // Rotates a matrix by the given angle around the X axis
   rotateX(radians2) {
     rotateX2(this, this, radians2);
     return this.check();
   }
+  // Rotates a matrix by the given angle around the Y axis.
   rotateY(radians2) {
     rotateY2(this, this, radians2);
     return this.check();
   }
+  /**
+   * Rotates a matrix by the given angle around the Z axis.
+   * @param radians
+   * @returns self
+   */
   rotateZ(radians2) {
     rotateZ2(this, this, radians2);
     return this.check();
   }
+  /**
+   *
+   * @param param0
+   * @returns self
+   */
   rotateXYZ(angleXYZ) {
     return this.rotateX(angleXYZ[0]).rotateY(angleXYZ[1]).rotateZ(angleXYZ[2]);
   }
+  /**
+   *
+   * @param radians
+   * @param axis
+   * @returns self
+   */
   rotateAxis(radians2, axis) {
     rotate3(this, this, radians2, axis);
     return this.check();
   }
+  /**
+   *
+   * @param factor
+   * @returns self
+   */
   scale(factor) {
     scale4(this, this, Array.isArray(factor) ? factor : [factor, factor, factor]);
     return this.check();
   }
+  /**
+   *
+   * @param vec
+   * @returns self
+   */
   translate(vector) {
     translate2(this, this, vector);
     return this.check();
   }
+  // Transforms
+  /**
+   * Transforms any 2, 3 or 4 element vector. 2 and 3 elements are treated as points
+   * @param vector
+   * @param result
+   * @returns self
+   */
   transform(vector, result) {
     if (vector.length === 4) {
       result = transformMat43(result || [-0, -0, -0, -0], vector, this);
@@ -4454,6 +4706,12 @@ var Matrix4 = class extends Matrix {
     }
     return this.transformAsPoint(vector, result);
   }
+  /**
+   * Transforms any 2 or 3 element array as point (w implicitly 1)
+   * @param vector
+   * @param result
+   * @returns self
+   */
   transformAsPoint(vector, result) {
     const { length: length5 } = vector;
     let out;
@@ -4470,6 +4728,12 @@ var Matrix4 = class extends Matrix {
     checkVector(out, vector.length);
     return out;
   }
+  /**
+   * Transforms any 2 or 3 element array as vector (w implicitly 0)
+   * @param vector
+   * @param result
+   * @returns self
+   */
   transformAsVector(vector, result) {
     let out;
     switch (vector.length) {
@@ -4485,15 +4749,19 @@ var Matrix4 = class extends Matrix {
     checkVector(out, vector.length);
     return out;
   }
+  /** @deprecated */
   transformPoint(vector, result) {
     return this.transformAsPoint(vector, result);
   }
+  /** @deprecated */
   transformVector(vector, result) {
     return this.transformAsPoint(vector, result);
   }
+  /** @deprecated */
   transformDirection(vector, result) {
     return this.transformAsVector(vector, result);
   }
+  // three.js math API compatibility
   makeRotationX(radians2) {
     return this.identity().rotateX(radians2);
   }
@@ -4925,6 +5193,13 @@ var Quaternion = class extends MathArray {
     this[3] = object.w;
     return this.check();
   }
+  /**
+   * Creates a quaternion from the given 3x3 rotation matrix.
+   * NOTE: The resultant quaternion is not normalized, so you should
+   * be sure to renormalize the quaternion yourself where necessary.
+   * @param m
+   * @returns
+   */
   fromMatrix3(m) {
     fromMat3(this, m);
     return this.check();
@@ -4933,13 +5208,21 @@ var Quaternion = class extends MathArray {
     setAxisAngle(this, axis, rad);
     return this.check();
   }
+  /** Set a quat to the identity quaternion */
   identity() {
     identity3(this);
     return this.check();
   }
+  // Set the components of a quat to the given values
+  // set(i, j, k, l) {
+  //   quat_set(this, i, j, k, l);
+  //   return this.check();
+  // }
+  // Sets a quat from the given angle and rotation axis, then returns it.
   setAxisAngle(axis, rad) {
     return this.fromAxisRotation(axis, rad);
   }
+  // Getters/setters
   get ELEMENTS() {
     return 4;
   }
@@ -4967,35 +5250,72 @@ var Quaternion = class extends MathArray {
   set w(value) {
     this[3] = checkNumber(value);
   }
+  // Calculates the length of a quat
   len() {
     return length4(this);
   }
+  // Calculates the squared length of a quat
   lengthSquared() {
     return squaredLength4(this);
   }
+  // Calculates the dot product of two quat's
+  // @return {Number}
   dot(a) {
     return dot4(this, a);
   }
+  // Gets the rotation axis and angle for a given quaternion.
+  // If a quaternion is created with setAxisAngle, this method will
+  // return the same values as providied in the original parameter
+  // list OR functionally equivalent values.
+  // Example: The quaternion formed by axis [0, 0, 1] and angle -90
+  // is the same as the quaternion formed by [0, 0, 1] and 270.
+  // This method favors the latter.
+  // @return {{[x,y,z], Number}}
+  // getAxisAngle() {
+  //   const axis = [];
+  // //   const angle = quat_getAxisAngle(axis, this);
+  //   return {axis, angle};
+  // }
+  // MODIFIERS
+  // Sets a quaternion to represent the shortest rotation from one vector
+  // to another. Both vectors are assumed to be unit length.
   rotationTo(vectorA, vectorB) {
     rotationTo(this, vectorA, vectorB);
     return this.check();
   }
+  // Sets the specified quaternion with values corresponding to the given axes.
+  // Each axis is a vec3 and is expected to be unit length and perpendicular
+  // to all other specified axes.
+  // setAxes() {
+  //   Number
+  // }
+  // Performs a spherical linear interpolation with two control points
+  // sqlerp() {
+  //   Number;
+  // }
+  // Adds two quat's
   add(a) {
     add6(this, this, a);
     return this.check();
   }
+  // Calculates the W component of a quat from the X, Y, and Z components.
+  // Any existing W component will be ignored.
   calculateW() {
     calculateW(this, this);
     return this.check();
   }
+  // Calculates the conjugate of a quat If the quaternion is normalized,
+  // this function is faster than quat_invert and produces the same result.
   conjugate() {
     conjugate(this, this);
     return this.check();
   }
+  // Calculates the inverse of a quat
   invert() {
     invert3(this, this);
     return this.check();
   }
+  // Performs a linear interpolation between two quat's
   lerp(a, b, t) {
     if (t === void 0) {
       return this.lerp(this, a, b);
@@ -5003,6 +5323,7 @@ var Quaternion = class extends MathArray {
     lerp5(this, a, b, t);
     return this.check();
   }
+  // Multiplies two quat's
   multiplyRight(a) {
     multiply6(this, this, a);
     return this.check();
@@ -5011,6 +5332,7 @@ var Quaternion = class extends MathArray {
     multiply6(this, a, this);
     return this.check();
   }
+  // Normalize a quat
   normalize() {
     const length5 = this.len();
     const l = length5 > 0 ? 1 / length5 : 0;
@@ -5023,22 +5345,27 @@ var Quaternion = class extends MathArray {
     }
     return this.check();
   }
+  // Rotates a quaternion by the given angle about the X axis
   rotateX(rad) {
     rotateX3(this, this, rad);
     return this.check();
   }
+  // Rotates a quaternion by the given angle about the Y axis
   rotateY(rad) {
     rotateY3(this, this, rad);
     return this.check();
   }
+  // Rotates a quaternion by the given angle about the Z axis
   rotateZ(rad) {
     rotateZ3(this, this, rad);
     return this.check();
   }
+  // Scales a quat by a scalar number
   scale(b) {
     scale6(this, this, b);
     return this.check();
   }
+  // Performs a spherical linear interpolation between two quat
   slerp(arg0, arg1, arg2) {
     let start;
     let target;
@@ -5068,6 +5395,7 @@ var Quaternion = class extends MathArray {
     transformQuat2(result, vector, this);
     return checkVector(result, 4);
   }
+  // THREE.js Math API compatibility
   lengthSq() {
     return this.lengthSquared();
   }
@@ -5086,6 +5414,27 @@ var Quaternion = class extends MathArray {
 var EPSILON2 = 1e-6;
 var EARTH_RADIUS_METERS = 6371e3;
 var SphericalCoordinates = class {
+  // bearing: number;
+  // pitch: number;
+  // altitude: number;
+  // lnglatZ coordinates
+  // longitude: number;
+  // latitude: number;
+  // lng: number;
+  // lat: number;
+  // z: number;
+  /**
+   * Creates a new SphericalCoordinates object
+   * @param options
+   * @param [options.phi] =0 - rotation around X (latitude)
+   * @param [options.theta] =0 - rotation around Y (longitude)
+   * @param [options.radius] =1 - Distance from center
+   * @param [options.bearing]
+   * @param [options.pitch]
+   * @param [options.altitude]
+   * @param [options.radiusScale] =1
+   */
+  // eslint-disable-next-line complexity
   constructor({ phi = 0, theta = 0, radius = 1, bearing, pitch, altitude, radiusScale = EARTH_RADIUS_METERS } = {}) {
     this.phi = phi;
     this.theta = theta;
@@ -5112,6 +5461,8 @@ var SphericalCoordinates = class {
   exactEquals(other) {
     return this.radius === other.radius && this.theta === other.theta && this.phi === other.phi;
   }
+  /* eslint-disable brace-style */
+  // Cartographic (bearing 0 north, pitch 0 look from above)
   get bearing() {
     return 180 - degrees(this.phi);
   }
@@ -5124,6 +5475,10 @@ var SphericalCoordinates = class {
   set pitch(v) {
     this.theta = radians(v);
   }
+  // get pitch() { return 90 - degrees(this.phi); }
+  // set pitch(v) { this.phi = radians(v) + Math.PI / 2; }
+  // get altitude() { return this.radius - 1; } // relative altitude
+  // lnglatZ coordinates
   get longitude() {
     return degrees(this.phi);
   }
@@ -5139,6 +5494,7 @@ var SphericalCoordinates = class {
   get z() {
     return (this.radius - 1) * this.radiusScale;
   }
+  /* eslint-enable brace-style */
   set(radius, phi, theta) {
     this.radius = radius;
     this.phi = phi;
@@ -5171,6 +5527,7 @@ var SphericalCoordinates = class {
   toVector3() {
     return new Vector3(0, 0, this.radius).rotateX({ radians: this.theta }).rotateZ({ radians: this.phi });
   }
+  // restrict phi to be betwee EPS and PI-EPS
   makeSafe() {
     this.phi = Math.max(EPSILON2, Math.min(Math.PI - EPSILON2, this.phi));
     return this;
@@ -5196,6 +5553,7 @@ var RotationOrder;
   RotationOrder2[RotationOrder2["XYZ"] = 5] = "XYZ";
 })(RotationOrder || (RotationOrder = {}));
 var Euler = class extends MathArray {
+  // Constants
   static get ZYX() {
     return RotationOrder.ZYX;
   }
@@ -5229,6 +5587,13 @@ var Euler = class extends MathArray {
   get ELEMENTS() {
     return 4;
   }
+  /**
+   * @class
+   * @param {Number | Number[]} x
+   * @param {Number=} [y]
+   * @param {Number=} [z]
+   * @param {Number=} [order]
+   */
   constructor(x = 0, y = 0, z = 0, order = Euler.DefaultOrder) {
     super(-0, -0, -0, -0);
     if (arguments.length > 0 && Array.isArray(arguments[0])) {
@@ -5252,9 +5617,15 @@ var Euler = class extends MathArray {
     const yaw = Math.atan2(t1, t0);
     return this.set(roll, pitch, yaw, Euler.RollPitchYaw);
   }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
   fromObject(object) {
     throw new Error("not implemented");
   }
+  // fromQuaternion(q, order) {
+  //   this._fromRotationMat[-0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0];
+  //   return this.check();
+  // }
+  // If copied array does contain fourth element, preserves currently set order
   copy(array) {
     this[0] = array[0];
     this[1] = array[1];
@@ -5262,6 +5633,8 @@ var Euler = class extends MathArray {
     this[3] = Number.isFinite(array[3]) || this.order;
     return this.check();
   }
+  // Sets the three angles, and optionally sets the rotation order
+  // If order is not specified, preserves currently set order
   set(x = 0, y = 0, z = 0, order) {
     this[0] = x;
     this[1] = y;
@@ -5272,12 +5645,14 @@ var Euler = class extends MathArray {
   validate() {
     return validateOrder(this[3]) && Number.isFinite(this[0]) && Number.isFinite(this[1]) && Number.isFinite(this[2]);
   }
+  // Does not copy the orientation element
   toArray(array = [], offset = 0) {
     array[offset] = this[0];
     array[offset + 1] = this[1];
     array[offset + 2] = this[2];
     return array;
   }
+  // Copies the orientation element
   toArray4(array = [], offset = 0) {
     array[offset] = this[0];
     array[offset + 1] = this[1];
@@ -5291,6 +5666,8 @@ var Euler = class extends MathArray {
     result[2] = this[2];
     return result;
   }
+  /* eslint-disable no-multi-spaces, brace-style, no-return-assign */
+  // x, y, z angle notation (note: only corresponds to axis in XYZ orientation)
   get x() {
     return this[0];
   }
@@ -5309,6 +5686,7 @@ var Euler = class extends MathArray {
   set z(value) {
     this[2] = checkNumber(value);
   }
+  // alpha, beta, gamma angle notation
   get alpha() {
     return this[0];
   }
@@ -5327,6 +5705,7 @@ var Euler = class extends MathArray {
   set gamma(value) {
     this[2] = checkNumber(value);
   }
+  // phi, theta, psi angle notation
   get phi() {
     return this[0];
   }
@@ -5345,6 +5724,7 @@ var Euler = class extends MathArray {
   set psi(value) {
     this[2] = checkNumber(value);
   }
+  // roll, pitch, yaw angle notation
   get roll() {
     return this[0];
   }
@@ -5363,15 +5743,18 @@ var Euler = class extends MathArray {
   set yaw(value) {
     this[2] = checkNumber(value);
   }
+  // rotation order, in all three angle notations
   get order() {
     return this[3];
   }
   set order(value) {
     this[3] = checkOrder(value);
   }
+  // Constructors
   fromVector3(v, order) {
     return this.set(v[0], v[1], v[2], Number.isFinite(order) ? order : this[3]);
   }
+  // TODO - with and without 4th element
   fromArray(array, offset = 0) {
     this[0] = array[0 + offset];
     this[1] = array[1 + offset];
@@ -5381,6 +5764,7 @@ var Euler = class extends MathArray {
     }
     return this.check();
   }
+  // Common ZYX rotation order
   fromRollPitchYaw(roll, pitch, yaw) {
     return this.set(roll, pitch, yaw, RotationOrder.ZYX);
   }
@@ -5388,9 +5772,11 @@ var Euler = class extends MathArray {
     this._fromRotationMatrix(m, order);
     return this.check();
   }
+  // ACCESSORS
   getRotationMatrix(m) {
     return this._getRotationMatrix(m);
   }
+  // TODO - move to Quaternion
   getQuaternion() {
     const q = new Quaternion();
     switch (this[3]) {
@@ -5410,6 +5796,14 @@ var Euler = class extends MathArray {
         throw new Error(ERR_UNKNOWN_ORDER);
     }
   }
+  // INTERNAL METHODS
+  // Conversion from Euler to rotation matrix and from matrix to Euler
+  // Adapted from three.js under MIT license
+  // // WARNING: this discards revolution information -bhouston
+  // reorder(newOrder) {
+  //   const q = new Quaternion().setFromEuler(this);
+  //   return this.setFromQuaternion(q, newOrder);
+  /* eslint-disable complexity, max-statements, one-var */
   _fromRotationMatrix(m, order = Euler.DefaultOrder) {
     const m11 = m[0], m12 = m[4], m13 = m[8];
     const m21 = m[1], m22 = m[5], m23 = m[9];
@@ -5683,17 +6077,29 @@ var Pose = class {
     const cw = Math.cos(this.yaw);
     return new Matrix4().setRowMajor(
       cw * cp,
+      // 0,0
       -sw * cr + cw * sp * sr,
+      // 0,1
       sw * sr + cw * sp * cr,
+      // 0,2
       this.x,
+      // 0,3
       sw * cp,
+      // 1,0
       cw * cr + sw * sp * sr,
+      // 1,1
       -cw * sr + sw * sp * cr,
+      // 1,2
       this.y,
+      // 1,3
       -sp,
+      // 2,0
       cp * sr,
+      // 2,1
       cp * cr,
+      // 2,2
       this.z,
+      // 2,3
       0,
       0,
       0,