@loaders.gl/i3s 4.3.0-alpha.7 → 4.3.0-alpha.8

package/dist/dist.dev.js

@@ -4335,52 +4335,6 @@ var __exports__ = (() => {
   var matches = typeof process !== "undefined" && process.version && /v([0-9]*)/.exec(process.version);
   var nodeVersion = matches && parseFloat(matches[1]) || 0;
 
-  // ../../node_modules/@babel/runtime/helpers/esm/typeof.js
-  function _typeof(obj) {
-    "@babel/helpers - typeof";
-    return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(obj2) {
-      return typeof obj2;
-    } : function(obj2) {
-      return obj2 && "function" == typeof Symbol && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
-    }, _typeof(obj);
-  }
-
-  // ../../node_modules/@babel/runtime/helpers/esm/toPrimitive.js
-  function _toPrimitive(input, hint) {
-    if (_typeof(input) !== "object" || input === null)
-      return input;
-    var prim = input[Symbol.toPrimitive];
-    if (prim !== void 0) {
-      var res = prim.call(input, hint || "default");
-      if (_typeof(res) !== "object")
-        return res;
-      throw new TypeError("@@toPrimitive must return a primitive value.");
-    }
-    return (hint === "string" ? String : Number)(input);
-  }
-
-  // ../../node_modules/@babel/runtime/helpers/esm/toPropertyKey.js
-  function _toPropertyKey(arg) {
-    var key = _toPrimitive(arg, "string");
-    return _typeof(key) === "symbol" ? key : String(key);
-  }
-
-  // ../../node_modules/@babel/runtime/helpers/esm/defineProperty.js
-  function _defineProperty(obj, key, value) {
-    key = _toPropertyKey(key);
-    if (key in obj) {
-      Object.defineProperty(obj, key, {
-        value,
-        enumerable: true,
-        configurable: true,
-        writable: true
-      });
-    } else {
-      obj[key] = value;
-    }
-    return obj;
-  }
-
   // ../loader-utils/src/lib/module-utils/js-module-utils.ts
   function registerJSModules(modules) {
     globalThis.loaders ||= {};
@@ -4814,17 +4768,11 @@ var __exports__ = (() => {
     printRowMajor: true,
     _cartographicRadians: false
   };
-  globalThis.mathgl = globalThis.mathgl || {
-    config: {
-      ...DEFAULT_CONFIG
-    }
-  };
+  globalThis.mathgl = globalThis.mathgl || { config: { ...DEFAULT_CONFIG } };
   var config = globalThis.mathgl.config;
-  function formatValue(value, {
-    precision = config.precision
-  } = {}) {
+  function formatValue(value, { precision = config.precision } = {}) {
     value = round(value);
-    return "".concat(parseFloat(value.toPrecision(precision)));
+    return `${parseFloat(value.toPrecision(precision))}`;
   }
   function isArray(value) {
     return Array.isArray(value) || ArrayBuffer.isView(value) && !(value instanceof DataView);
@@ -4895,28 +4843,12 @@ var __exports__ = (() => {
   }
 
   // ../../node_modules/@math.gl/core/dist/classes/base/math-array.js
-  function _extendableBuiltin(cls) {
-    function ExtendableBuiltin() {
-      var instance = Reflect.construct(cls, Array.from(arguments));
-      Object.setPrototypeOf(instance, Object.getPrototypeOf(this));
-      return instance;
-    }
-    ExtendableBuiltin.prototype = Object.create(cls.prototype, {
-      constructor: {
-        value: cls,
-        enumerable: false,
-        writable: true,
-        configurable: true
-      }
-    });
-    if (Object.setPrototypeOf) {
-      Object.setPrototypeOf(ExtendableBuiltin, cls);
-    } else {
-      ExtendableBuiltin.__proto__ = cls;
-    }
-    return ExtendableBuiltin;
-  }
-  var MathArray = class extends _extendableBuiltin(Array) {
+  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);
     }
@@ -4936,7 +4868,10 @@ var __exports__ = (() => {
       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) {
@@ -4947,18 +4882,20 @@ var __exports__ = (() => {
     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) {
         string += (i > 0 ? ", " : "") + formatValue(this[i], opts);
       }
-      return "".concat(opts.printTypes ? this.constructor.name : "", "[").concat(string, "]");
+      return `${opts.printTypes ? this.constructor.name : ""}[${string}]`;
     }
     equals(array) {
       if (!array || this.length !== array.length) {
@@ -4982,6 +4919,8 @@ var __exports__ = (() => {
       }
       return true;
     }
+    // Modifiers
+    /** Negates all values in this object */
     negate() {
       for (let i = 0; i < this.ELEMENTS; ++i) {
         this[i] = -this[i];
@@ -4999,12 +4938,14 @@ var __exports__ = (() => {
       }
       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]);
@@ -5045,18 +4986,25 @@ var __exports__ = (() => {
       }
       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: ".concat(this.constructor.name, " some fields set to invalid numbers'"));
+        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) {
@@ -5064,39 +5012,48 @@ var __exports__ = (() => {
       }
       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(min2, max2) {
       for (let i = 0; i < this.ELEMENTS; ++i) {
         this[i] = Math.min(Math.max(this[i], min2), max2);
       }
       return this.check();
     }
+    /** @deprecated */
     get elements() {
       return this;
     }
@@ -5116,13 +5073,13 @@ var __exports__ = (() => {
   }
   function checkNumber(value) {
     if (!Number.isFinite(value)) {
-      throw new Error("Invalid number ".concat(JSON.stringify(value)));
+      throw new Error(`Invalid number ${JSON.stringify(value)}`);
     }
     return value;
   }
   function checkVector(v, length4, callerName = "") {
     if (config.debug && !validateVector(v, length4)) {
-      throw new Error("math.gl: ".concat(callerName, " some fields set to invalid numbers'"));
+      throw new Error(`math.gl: ${callerName} some fields set to invalid numbers'`);
     }
     return v;
   }
@@ -5130,12 +5087,13 @@ var __exports__ = (() => {
   // ../../node_modules/@math.gl/core/dist/lib/assert.js
   function assert3(condition, message) {
     if (!condition) {
-      throw new Error("math.gl assertion ".concat(message));
+      throw new Error(`math.gl assertion ${message}`);
     }
   }
 
   // ../../node_modules/@math.gl/core/dist/classes/base/vector.js
   var Vector = class extends MathArray {
+    // ACCESSORS
     get x() {
       return this[0];
     }
@@ -5148,12 +5106,24 @@ var __exports__ = (() => {
     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 length4 = 0;
       for (let i = 0; i < this.ELEMENTS; ++i) {
@@ -5161,6 +5131,9 @@ var __exports__ = (() => {
       }
       return length4;
     }
+    /**
+     * Returns the squared length of the vector from the origin to the point described by this vector
+     */
     magnitudeSquared() {
       return this.lengthSquared();
     }
@@ -5182,6 +5155,7 @@ var __exports__ = (() => {
       }
       return checkNumber(product);
     }
+    // MODIFIERS
     normalize() {
       const length4 = this.magnitude();
       if (length4 !== 0) {
@@ -5207,6 +5181,7 @@ var __exports__ = (() => {
       }
       return this.check();
     }
+    // THREE.js compatibility
     lengthSq() {
       return this.lengthSquared();
     }
@@ -5724,7 +5699,7 @@ var __exports__ = (() => {
     return out;
   }
   function str(a) {
-    return "vec3(".concat(a[0], ", ").concat(a[1], ", ").concat(a[2], ")");
+    return `vec3(${a[0]}, ${a[1]}, ${a[2]})`;
   }
   function exactEquals(a, b) {
     return a[0] === b[0] && a[1] === b[1] && a[2] === b[2];
@@ -5785,6 +5760,12 @@ var __exports__ = (() => {
       }
       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)) {
@@ -5829,6 +5810,7 @@ var __exports__ = (() => {
       object.z = this[2];
       return object;
     }
+    // Getters/setters
     get ELEMENTS() {
       return 3;
     }
@@ -5838,41 +5820,38 @@ var __exports__ = (() => {
     set z(value) {
       this[2] = checkNumber(value);
     }
+    // ACCESSORS
     angle(vector) {
       return angle(this, vector);
     }
+    // MODIFIERS
     cross(vector) {
       cross(this, this, vector);
       return this.check();
     }
-    rotateX({
-      radians: radians2,
-      origin = ORIGIN
-    }) {
+    rotateX({ radians: radians2, origin = ORIGIN }) {
       rotateX(this, this, origin, radians2);
       return this.check();
     }
-    rotateY({
-      radians: radians2,
-      origin = ORIGIN
-    }) {
+    rotateY({ radians: radians2, origin = ORIGIN }) {
       rotateY(this, this, origin, radians2);
       return this.check();
     }
-    rotateZ({
-      radians: radians2,
-      origin = ORIGIN
-    }) {
+    rotateZ({ radians: radians2, origin = ORIGIN }) {
       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();
@@ -5952,6 +5931,8 @@ var __exports__ = (() => {
       object.w = this[3];
       return object;
     }
+    // Getters/setters
+    /* eslint-disable no-multi-spaces, brace-style, no-return-assign */
     get ELEMENTS() {
       return 4;
     }
@@ -5983,6 +5964,7 @@ var __exports__ = (() => {
       transformQuat(this, this, quaternion);
       return this.check();
     }
+    // three.js compatibility
     applyMatrix4(m) {
       m.transform(this, this);
       return this;
@@ -5991,19 +5973,29 @@ var __exports__ = (() => {
 
   // ../../node_modules/@math.gl/core/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) {
         string += "row-major:";
         for (let row = 0; row < this.RANK; ++row) {
           for (let col = 0; col < this.RANK; ++col) {
-            string += " ".concat(this[col * this.RANK + row]);
+            string += ` ${this[col * this.RANK + row]}`;
           }
         }
       } else {
         string += "column-major:";
         for (let i = 0; i < this.ELEMENTS; ++i) {
-          string += " ".concat(this[i]);
+          string += ` ${this[i]}`;
         }
       }
       string += "]";
@@ -6012,9 +6004,11 @@ var __exports__ = (() => {
     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;
@@ -6287,16 +6281,30 @@ var __exports__ = (() => {
       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;
@@ -6309,6 +6317,10 @@ var __exports__ = (() => {
       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;
@@ -6321,17 +6333,21 @@ var __exports__ = (() => {
       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) {
       multiply2(this, a, this);
       return this.check();
@@ -6356,6 +6372,7 @@ var __exports__ = (() => {
       translate(this, this, vec);
       return this.check();
     }
+    // Transforms
     transform(vector, result) {
       let out;
       switch (vector.length) {
@@ -6374,12 +6391,15 @@ var __exports__ = (() => {
       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);
     }
@@ -7750,7 +7770,7 @@ var __exports__ = (() => {
     return out;
   }
   function str2(a) {
-    return "mat4(".concat(a[0], ", ").concat(a[1], ", ").concat(a[2], ", ").concat(a[3], ", ").concat(a[4], ", ").concat(a[5], ", ").concat(a[6], ", ").concat(a[7], ", ").concat(a[8], ", ").concat(a[9], ", ").concat(a[10], ", ").concat(a[11], ", ").concat(a[12], ", ").concat(a[13], ", ").concat(a[14], ", ").concat(a[15], ")");
+    return `mat4(${a[0]}, ${a[1]}, ${a[2]}, ${a[3]}, ${a[4]}, ${a[5]}, ${a[6]}, ${a[7]}, ${a[8]}, ${a[9]}, ${a[10]}, ${a[11]}, ${a[12]}, ${a[13]}, ${a[14]}, ${a[15]})`;
   }
   function frob(a) {
     return Math.sqrt(a[0] * a[0] + a[1] * a[1] + a[2] * a[2] + a[3] * a[3] + a[4] * a[4] + a[5] * a[5] + a[6] * a[6] + a[7] * a[7] + a[8] * a[8] + a[9] * a[9] + a[10] * a[10] + a[11] * a[11] + a[12] * a[12] + a[13] * a[13] + a[14] * a[14] + a[15] * a[15]);
@@ -8068,6 +8088,7 @@ var __exports__ = (() => {
       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;
@@ -8087,6 +8108,8 @@ var __exports__ = (() => {
       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;
@@ -8125,25 +8148,41 @@ var __exports__ = (() => {
       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;
+      const { left, right, bottom, top, near = DEFAULT_NEAR, far = DEFAULT_FAR } = view;
       if (far === Infinity) {
         computeInfinitePerspectiveOffCenter(this, left, right, bottom, top, near);
       } else {
@@ -8151,35 +8190,47 @@ var __exports__ = (() => {
       }
       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;
+      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;
+      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;
+      const { fovy = DEFAULT_FOVY, aspect = DEFAULT_ASPECT, focalDistance = 1, near = DEFAULT_NEAR, far = DEFAULT_FAR } = view;
       checkRadians(fovy);
       const halfY = fovy / 2;
       const top = focalDistance * Math.tan(halfY);
@@ -8193,32 +8244,53 @@ var __exports__ = (() => {
         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;
+      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];
@@ -8244,6 +8316,12 @@ var __exports__ = (() => {
       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];
@@ -8262,6 +8340,7 @@ var __exports__ = (() => {
       result[8] = this[10] * inverseScale2;
       return result;
     }
+    // Modifiers
     transpose() {
       transpose2(this, this);
       return this.check();
@@ -8270,6 +8349,7 @@ var __exports__ = (() => {
       invert2(this, this);
       return this.check();
     }
+    // Operations
     multiplyLeft(a) {
       multiply3(this, a, this);
       return this.check();
@@ -8278,33 +8358,68 @@ var __exports__ = (() => {
       multiply3(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) {
       rotate2(this, this, radians2, axis);
       return this.check();
     }
+    /**
+     *
+     * @param factor
+     * @returns self
+     */
     scale(factor) {
       scale3(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);
@@ -8313,10 +8428,14 @@ var __exports__ = (() => {
       }
       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: length4
-      } = vector;
+      const { length: length4 } = vector;
       let out;
       switch (length4) {
         case 2:
@@ -8331,6 +8450,12 @@ var __exports__ = (() => {
       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) {
@@ -8346,15 +8471,19 @@ var __exports__ = (() => {
       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);
     }
@@ -8681,6 +8810,13 @@ var __exports__ = (() => {
       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();
@@ -8689,13 +8825,21 @@ var __exports__ = (() => {
       setAxisAngle(this, axis, rad);
       return this.check();
     }
+    /** Set a quat to the identity quaternion */
     identity() {
       identity2(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;
     }
@@ -8723,35 +8867,72 @@ var __exports__ = (() => {
     set w(value) {
       this[3] = checkNumber(value);
     }
+    // Calculates the length of a quat
     len() {
       return length3(this);
     }
+    // Calculates the squared length of a quat
     lengthSquared() {
       return squaredLength3(this);
     }
+    // Calculates the dot product of two quat's
+    // @return {Number}
     dot(a) {
       return dot3(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) {
       add4(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);
@@ -8759,6 +8940,7 @@ var __exports__ = (() => {
       lerp3(this, a, b, t);
       return this.check();
     }
+    // Multiplies two quat's
     multiplyRight(a) {
       multiply4(this, this, a);
       return this.check();
@@ -8767,6 +8949,7 @@ var __exports__ = (() => {
       multiply4(this, a, this);
       return this.check();
     }
+    // Normalize a quat
     normalize() {
       const length4 = this.len();
       const l = length4 > 0 ? 1 / length4 : 0;
@@ -8779,22 +8962,27 @@ var __exports__ = (() => {
       }
       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) {
       scale5(this, this, b);
       return this.check();
     }
+    // Performs a spherical linear interpolation between two quat
     slerp(arg0, arg1, arg2) {
       let start;
       let target;
@@ -8824,6 +9012,7 @@ var __exports__ = (() => {
       transformQuat2(result, vector, this);
       return checkVector(result, 4);
     }
+    // THREE.js Math API compatibility
     lengthSq() {
       return this.lengthSquared();
     }
@@ -8959,11 +9148,20 @@ var __exports__ = (() => {
   var WGS84_RADIUS_Z = 6356752314245179e-9;
   var WGS84_CONSTANTS = {
     radii: [WGS84_RADIUS_X, WGS84_RADIUS_Y, WGS84_RADIUS_Z],
-    radiiSquared: [WGS84_RADIUS_X * WGS84_RADIUS_X, WGS84_RADIUS_Y * WGS84_RADIUS_Y, WGS84_RADIUS_Z * WGS84_RADIUS_Z],
+    radiiSquared: [
+      WGS84_RADIUS_X * WGS84_RADIUS_X,
+      WGS84_RADIUS_Y * WGS84_RADIUS_Y,
+      WGS84_RADIUS_Z * WGS84_RADIUS_Z
+    ],
     oneOverRadii: [1 / WGS84_RADIUS_X, 1 / WGS84_RADIUS_Y, 1 / WGS84_RADIUS_Z],
-    oneOverRadiiSquared: [1 / (WGS84_RADIUS_X * WGS84_RADIUS_X), 1 / (WGS84_RADIUS_Y * WGS84_RADIUS_Y), 1 / (WGS84_RADIUS_Z * WGS84_RADIUS_Z)],
+    oneOverRadiiSquared: [
+      1 / (WGS84_RADIUS_X * WGS84_RADIUS_X),
+      1 / (WGS84_RADIUS_Y * WGS84_RADIUS_Y),
+      1 / (WGS84_RADIUS_Z * WGS84_RADIUS_Z)
+    ],
     maximumRadius: Math.max(WGS84_RADIUS_X, WGS84_RADIUS_Y, WGS84_RADIUS_Z),
     centerToleranceSquared: 0.1
+    // EPSILON1;
   };
 
   // ../../node_modules/@math.gl/geospatial/dist/type-utils.js
@@ -9093,19 +9291,11 @@ var __exports__ = (() => {
         thirdAxisVector.scale(sign);
       }
     } else {
-      const {
-        up,
-        east,
-        north
-      } = scratchAxisVectors;
+      const { up, east, north } = scratchAxisVectors;
       east.set(-origin.y, origin.x, 0).normalize();
       ellipsoid.geodeticSurfaceNormal(origin, up);
       north.copy(up).cross(east);
-      const {
-        down,
-        west,
-        south
-      } = scratchAxisVectors;
+      const { down, west, south } = scratchAxisVectors;
       down.copy(up).scale(-1);
       west.copy(east).scale(-1);
       south.copy(north).scale(-1);
@@ -9137,11 +9327,7 @@ var __exports__ = (() => {
   var scaleToGeodeticSurfaceIntersection = new Vector3();
   var scaleToGeodeticSurfaceGradient = new Vector3();
   function scaleToGeodeticSurface(cartesian, ellipsoid, result = []) {
-    const {
-      oneOverRadii,
-      oneOverRadiiSquared,
-      centerToleranceSquared
-    } = ellipsoid;
+    const { oneOverRadii, oneOverRadiiSquared, centerToleranceSquared } = ellipsoid;
     scratchVector4.from(cartesian);
     const positionX = scratchVector4.x;
     const positionY = scratchVector4.y;
@@ -9201,15 +9387,7 @@ var __exports__ = (() => {
   var scratchCartesian = new Vector3();
   var Ellipsoid = class {
     constructor(x = 0, y = 0, z = 0) {
-      _defineProperty(this, "radii", void 0);
-      _defineProperty(this, "radiiSquared", void 0);
-      _defineProperty(this, "radiiToTheFourth", void 0);
-      _defineProperty(this, "oneOverRadii", void 0);
-      _defineProperty(this, "oneOverRadiiSquared", void 0);
-      _defineProperty(this, "minimumRadius", void 0);
-      _defineProperty(this, "maximumRadius", void 0);
-      _defineProperty(this, "centerToleranceSquared", math_utils_exports.EPSILON1);
-      _defineProperty(this, "squaredXOverSquaredZ", void 0);
+      this.centerToleranceSquared = math_utils_exports.EPSILON1;
       assert3(x >= 0);
       assert3(y >= 0);
       assert3(z >= 0);
@@ -9225,9 +9403,11 @@ var __exports__ = (() => {
       }
       Object.freeze(this);
     }
+    /** Compares this Ellipsoid against the provided Ellipsoid componentwise */
     equals(right) {
       return this === right || Boolean(right && this.radii.equals(right.radii));
     }
+    /** Creates a string representing this Ellipsoid in the format '(radii.x, radii.y, radii.z)'. */
     toString() {
       return this.radii.toString();
     }
@@ -9260,6 +9440,8 @@ var __exports__ = (() => {
     eastNorthUpToFixedFrame(origin, result = new Matrix4()) {
       return localFrameToFixedFrame(this, "east", "north", "up", origin, result);
     }
+    // Computes a 4x4 transformation matrix from a reference frame centered at
+    // the provided origin to the ellipsoid's fixed reference frame.
     localFrameToFixedFrame(firstAxis, secondAxis, thirdAxis, origin, result = new Matrix4()) {
       return localFrameToFixedFrame(this, firstAxis, secondAxis, thirdAxis, origin, result);
     }
@@ -9277,9 +9459,14 @@ var __exports__ = (() => {
     geodeticSurfaceNormal(cartesian, result = [0, 0, 0]) {
       return scratchVector5.from(cartesian).scale(this.oneOverRadiiSquared).normalize().to(result);
     }
+    /** Scales the provided Cartesian position along the geodetic surface normal
+     * so that it is on the surface of this ellipsoid.  If the position is
+     * at the center of the ellipsoid, this function returns undefined. */
     scaleToGeodeticSurface(cartesian, result) {
       return scaleToGeodeticSurface(cartesian, this, result);
     }
+    /** Scales the provided Cartesian position along the geocentric surface normal
+     * so that it is on the surface of this ellipsoid. */
     scaleToGeocentricSurface(cartesian, result = [0, 0, 0]) {
       scratchPosition.from(cartesian);
       const positionX = scratchPosition.x;
@@ -9289,12 +9476,17 @@ var __exports__ = (() => {
       const beta = 1 / Math.sqrt(positionX * positionX * oneOverRadiiSquared.x + positionY * positionY * oneOverRadiiSquared.y + positionZ * positionZ * oneOverRadiiSquared.z);
       return scratchPosition.multiplyScalar(beta).to(result);
     }
+    /** Transforms a Cartesian X, Y, Z position to the ellipsoid-scaled space by multiplying
+     * its components by the result of `Ellipsoid#oneOverRadii` */
     transformPositionToScaledSpace(position, result = [0, 0, 0]) {
       return scratchPosition.from(position).scale(this.oneOverRadii).to(result);
     }
+    /** Transforms a Cartesian X, Y, Z position from the ellipsoid-scaled space by multiplying
+     * its components by the result of `Ellipsoid#radii`. */
     transformPositionFromScaledSpace(position, result = [0, 0, 0]) {
       return scratchPosition.from(position).scale(this.radii).to(result);
     }
+    /** Computes a point which is the intersection of the surface normal with the z-axis. */
     getSurfaceNormalIntersectionWithZAxis(position, buffer = 0, result = [0, 0, 0]) {
       assert3(equals(this.radii.x, this.radii.y, math_utils_exports.EPSILON15));
       assert3(this.radii.z > 0);
@@ -9306,7 +9498,7 @@ var __exports__ = (() => {
       return scratchPosition.set(0, 0, z).to(result);
     }
   };
-  _defineProperty(Ellipsoid, "WGS84", new Ellipsoid(WGS84_RADIUS_X, WGS84_RADIUS_Y, WGS84_RADIUS_Z));
+  Ellipsoid.WGS84 = new Ellipsoid(WGS84_RADIUS_X, WGS84_RADIUS_Y, WGS84_RADIUS_Z);
 
   // ../images/src/lib/utils/version.ts
   var VERSION2 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
@@ -12085,8 +12277,11 @@ var __exports__ = (() => {
   // ../../node_modules/@math.gl/culling/dist/constants.js
   var INTERSECTION = {
     OUTSIDE: -1,
+    // Represents that an object is not contained within the frustum.
     INTERSECTING: 0,
+    // Represents that an object intersects one of the frustum's planes.
     INSIDE: 1
+    // Represents that an object is fully within the frustum.
   };
 
   // ../../node_modules/@math.gl/culling/dist/lib/bounding-volumes/axis-aligned-bounding-box.js
@@ -12097,30 +12292,37 @@ var __exports__ = (() => {
   var scratchVector8 = new Vector3();
   var scratchVector22 = new Vector3();
   var BoundingSphere = class {
+    /** Creates a bounding sphere */
     constructor(center = [0, 0, 0], radius = 0) {
-      _defineProperty(this, "center", void 0);
-      _defineProperty(this, "radius", void 0);
       this.radius = -0;
       this.center = new Vector3();
       this.fromCenterRadius(center, radius);
     }
+    /** Sets the bounding sphere from `center` and `radius`. */
     fromCenterRadius(center, radius) {
       this.center.from(center);
       this.radius = radius;
       return this;
     }
+    /**
+     * Computes a bounding sphere from the corner points of an axis-aligned bounding box.  The sphere
+     * tightly and fully encompasses the box.
+     */
     fromCornerPoints(corner, oppositeCorner) {
       oppositeCorner = scratchVector8.from(oppositeCorner);
       this.center = new Vector3().from(corner).add(oppositeCorner).scale(0.5);
       this.radius = this.center.distance(oppositeCorner);
       return this;
     }
+    /** Compares the provided BoundingSphere component wise */
     equals(right) {
       return this === right || Boolean(right) && this.center.equals(right.center) && this.radius === right.radius;
     }
+    /** Duplicates a BoundingSphere instance. */
     clone() {
       return new BoundingSphere(this.center, this.radius);
     }
+    /** Computes a bounding sphere that contains both the left and right bounding spheres. */
     union(boundingSphere) {
       const leftCenter = this.center;
       const leftRadius = this.radius;
@@ -12140,6 +12342,7 @@ var __exports__ = (() => {
       this.radius = halfDistanceBetweenTangentPoints;
       return this;
     }
+    /** Computes a bounding sphere by enlarging the provided sphere to contain the provided point. */
     expand(point) {
       const scratchPoint = scratchVector8.from(point);
       const radius = scratchPoint.subtract(this.center).magnitude();
@@ -12148,21 +12351,31 @@ var __exports__ = (() => {
       }
       return this;
     }
+    // BoundingVolume interface
+    /**
+     * Applies a 4x4 affine transformation matrix to a bounding sphere.
+     * @param sphere The bounding sphere to apply the transformation to.
+     * @param transform The transformation matrix to apply to the bounding sphere.
+     * @returns self.
+     */
     transform(transform) {
       this.center.transform(transform);
       const scale6 = mat4_exports.getScaling(scratchVector8, transform);
       this.radius = Math.max(scale6[0], Math.max(scale6[1], scale6[2])) * this.radius;
       return this;
     }
+    /** Computes the estimated distance squared from the closest point on a bounding sphere to a point. */
     distanceSquaredTo(point) {
       const d = this.distanceTo(point);
       return d * d;
     }
+    /** Computes the estimated distance from the closest point on a bounding sphere to a point. */
     distanceTo(point) {
       const scratchPoint = scratchVector8.from(point);
       const delta = scratchPoint.subtract(this.center);
       return Math.max(0, delta.len() - this.radius);
     }
+    /** Determines which side of a plane a sphere is located. */
     intersectPlane(plane) {
       const center = this.center;
       const radius = this.radius;
@@ -12199,17 +12412,17 @@ var __exports__ = (() => {
   };
   var OrientedBoundingBox = class {
     constructor(center = [0, 0, 0], halfAxes = [0, 0, 0, 0, 0, 0, 0, 0, 0]) {
-      _defineProperty(this, "center", void 0);
-      _defineProperty(this, "halfAxes", void 0);
       this.center = new Vector3().from(center);
       this.halfAxes = new Matrix3(halfAxes);
     }
+    /** Returns an array with three halfSizes for the bounding box */
     get halfSize() {
       const xAxis = this.halfAxes.getColumn(0);
       const yAxis = this.halfAxes.getColumn(1);
       const zAxis = this.halfAxes.getColumn(2);
       return [new Vector3(xAxis).len(), new Vector3(yAxis).len(), new Vector3(zAxis).len()];
     }
+    /** Returns a quaternion describing the orientation of the bounding box */
     get quaternion() {
       const xAxis = this.halfAxes.getColumn(0);
       const yAxis = this.halfAxes.getColumn(1);
@@ -12219,6 +12432,9 @@ var __exports__ = (() => {
       const normZAxis = new Vector3(zAxis).normalize();
       return new Quaternion().fromMatrix3(new Matrix3([...normXAxis, ...normYAxis, ...normZAxis]));
     }
+    /**
+     * Create OrientedBoundingBox from quaternion based OBB,
+     */
     fromCenterHalfSizeQuaternion(center, halfSize, quaternion) {
       const quaternionObject = new Quaternion(quaternion);
       const directionsMatrix = new Matrix3().fromQuaternion(quaternionObject);
@@ -12235,12 +12451,15 @@ var __exports__ = (() => {
       this.halfAxes = directionsMatrix;
       return this;
     }
+    /** Duplicates a OrientedBoundingBox instance. */
     clone() {
       return new OrientedBoundingBox(this.center, this.halfAxes);
     }
+    /** Compares the provided OrientedBoundingBox component wise and returns */
     equals(right) {
       return this === right || Boolean(right) && this.center.equals(right.center) && this.halfAxes.equals(right.halfAxes);
     }
+    /** Computes a tight-fitting bounding sphere enclosing the provided oriented bounding box. */
     getBoundingSphere(result = new BoundingSphere()) {
       const halfAxes = this.halfAxes;
       const u = halfAxes.getColumn(0, scratchVectorU);
@@ -12251,6 +12470,7 @@ var __exports__ = (() => {
       result.radius = cornerVector.magnitude();
       return result;
     }
+    /** Determines which side of a plane the oriented bounding box is located. */
     intersectPlane(plane) {
       const center = this.center;
       const normal = plane.normal;
@@ -12267,9 +12487,15 @@ var __exports__ = (() => {
       }
       return INTERSECTION.INTERSECTING;
     }
+    /** Computes the estimated distance from the closest point on a bounding box to a point. */
     distanceTo(point) {
       return Math.sqrt(this.distanceSquaredTo(point));
     }
+    /**
+     * Computes the estimated distance squared from the closest point
+     * on a bounding box to a point.
+     * See Geometric Tools for Computer Graphics 10.4.2
+     */
     distanceSquaredTo(point) {
       const offset = scratchOffset.from(point).subtract(this.center);
       const halfAxes = this.halfAxes;
@@ -12298,6 +12524,21 @@ var __exports__ = (() => {
       }
       return distanceSquared;
     }
+    /**
+     * The distances calculated by the vector from the center of the bounding box
+     * to position projected onto direction.
+     *
+     * - If you imagine the infinite number of planes with normal direction,
+     *   this computes the smallest distance to the closest and farthest planes
+     *   from `position` that intersect the bounding box.
+     *
+     * @param position The position to calculate the distance from.
+     * @param direction The direction from position.
+     * @param result An Interval (array of length 2) to store the nearest and farthest distances.
+     * @returns Interval (array of length 2) with nearest and farthest distances
+     *   on the bounding box from position in direction.
+     */
+    // eslint-disable-next-line max-statements
     computePlaneDistances(position, direction, result = [-0, -0]) {
       let minDist = Number.POSITIVE_INFINITY;
       let maxDist = Number.NEGATIVE_INFINITY;
@@ -12350,6 +12591,11 @@ var __exports__ = (() => {
       result[1] = maxDist;
       return result;
     }
+    /**
+     * Applies a 4x4 affine transformation matrix to a bounding sphere.
+     * @param transform The transformation matrix to apply to the bounding sphere.
+     * @returns itself, i.e. the modified BoundingVolume.
+     */
     transform(transformation) {
       this.center.transformAsPoint(transformation);
       const xAxis = this.halfAxes.getColumn(0, scratchVectorU);
@@ -12371,18 +12617,18 @@ var __exports__ = (() => {
   var scratchNormal3 = new Vector3();
   var Plane = class {
     constructor(normal = [0, 0, 1], distance2 = 0) {
-      _defineProperty(this, "normal", void 0);
-      _defineProperty(this, "distance", void 0);
       this.normal = new Vector3();
       this.distance = -0;
       this.fromNormalDistance(normal, distance2);
     }
+    /** Creates a plane from a normal and a distance from the origin. */
     fromNormalDistance(normal, distance2) {
       assert3(Number.isFinite(distance2));
       this.normal.from(normal).normalize();
       this.distance = distance2;
       return this;
     }
+    /** Creates a plane from a normal and a point on the plane. */
     fromPointNormal(point, normal) {
       point = scratchPosition2.from(point);
       this.normal.from(normal).normalize();
@@ -12390,21 +12636,28 @@ var __exports__ = (() => {
       this.distance = distance2;
       return this;
     }
+    /** Creates a plane from the general equation */
     fromCoefficients(a, b, c, d) {
       this.normal.set(a, b, c);
       assert3(equals(this.normal.len(), 1));
       this.distance = d;
       return this;
     }
+    /** Duplicates a Plane instance. */
     clone() {
       return new Plane(this.normal, this.distance);
     }
+    /** Compares the provided Planes by normal and distance */
     equals(right) {
       return equals(this.distance, right.distance) && equals(this.normal, right.normal);
     }
+    /** Computes the signed shortest distance of a point to a plane.
+     * The sign of the distance determines which side of the plane the point is on.
+     */
     getPointDistance(point) {
       return this.normal.dot(point) + this.distance;
     }
+    /** Transforms the plane by the given transformation matrix. */
     transform(matrix4) {
       const normal = scratchNormal3.copy(this.normal).transformAsVector(matrix4).normalize();
       const point = this.normal.scale(-this.distance).transform(matrix4);
@@ -12423,10 +12676,17 @@ var __exports__ = (() => {
   var scratchPlaneCenter = new Vector3();
   var scratchPlaneNormal = new Vector3();
   var CullingVolume = class {
+    /**
+     * Create a new `CullingVolume` bounded by an array of clipping planed
+     * @param planes Array of clipping planes.
+     * */
     constructor(planes = []) {
-      _defineProperty(this, "planes", void 0);
       this.planes = planes;
     }
+    /**
+     * Constructs a culling volume from a bounding sphere. Creates six planes that create a box containing the sphere.
+     * The planes are aligned to the x, y, and z axes in world coordinates.
+     */
     fromBoundingSphere(boundingSphere) {
       this.planes.length = 2 * faces.length;
       const center = boundingSphere.center;
@@ -12450,6 +12710,7 @@ var __exports__ = (() => {
       }
       return this;
     }
+    /** Determines whether a bounding volume intersects the culling volume. */
     computeVisibility(boundingVolume) {
       let intersect = INTERSECTION.INSIDE;
       for (const plane of this.planes) {
@@ -12465,6 +12726,14 @@ var __exports__ = (() => {
       }
       return intersect;
     }
+    /**
+     * Determines whether a bounding volume intersects the culling volume.
+     *
+     * @param parentPlaneMask A bit mask from the boundingVolume's parent's check against the same culling
+     *   volume, such that if (planeMask & (1 << planeIndex) === 0), for k < 31, then
+     *   the parent (and therefore this) volume is completely inside plane[planeIndex]
+     *   and that plane check can be skipped.
+     */
     computeVisibilityWithPlaneMask(boundingVolume, parentPlaneMask) {
       assert3(Number.isFinite(parentPlaneMask), "parentPlaneMask is required.");
       if (parentPlaneMask === CullingVolume.MASK_OUTSIDE || parentPlaneMask === CullingVolume.MASK_INSIDE) {
@@ -12488,9 +12757,9 @@ var __exports__ = (() => {
       return mask;
     }
   };
-  _defineProperty(CullingVolume, "MASK_OUTSIDE", 4294967295);
-  _defineProperty(CullingVolume, "MASK_INSIDE", 0);
-  _defineProperty(CullingVolume, "MASK_INDETERMINATE", 2147483647);
+  CullingVolume.MASK_OUTSIDE = 4294967295;
+  CullingVolume.MASK_INSIDE = 0;
+  CullingVolume.MASK_INDETERMINATE = 2147483647;
 
   // ../../node_modules/@math.gl/culling/dist/lib/perspective-off-center-frustum.js
   var scratchPlaneUpVector = new Vector3();