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

package/dist/i3s-content-worker.js

@@ -118,7 +118,7 @@
   var navigator_ = globalThis.navigator || {};
 
   // ../../node_modules/@probe.gl/log/node_modules/@probe.gl/env/dist/utils/globals.js
-  var VERSION = true ? "4.3.0-alpha.6" : "untranspiled source";
+  var VERSION = true ? "4.3.0-alpha.7" : "untranspiled source";
   var isBrowser3 = isBrowser2();
 
   // ../../node_modules/@probe.gl/log/dist/utils/local-storage.js
@@ -616,7 +616,7 @@
   });
 
   // ../loader-utils/src/lib/log-utils/log.ts
-  var VERSION2 = true ? "4.3.0-alpha.6" : "latest";
+  var VERSION2 = true ? "4.3.0-alpha.7" : "latest";
   var version = VERSION2[0] >= "0" && VERSION2[0] <= "9" ? `v${VERSION2}` : "";
   function createLog() {
     const log2 = new Log({ id: "loaders.gl" });
@@ -674,7 +674,7 @@
         );
         globalThis._loadersgl_.version = NPM_TAG;
       } else {
-        globalThis._loadersgl_.version = "4.3.0-alpha.6";
+        globalThis._loadersgl_.version = "4.3.0-alpha.7";
       }
     }
     return globalThis._loadersgl_.version;
@@ -2747,17 +2747,11 @@
     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);
@@ -2828,28 +2822,12 @@
   }
 
   // ../../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);
     }
@@ -2869,7 +2847,10 @@
       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) {
@@ -2880,18 +2861,20 @@
     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) {
@@ -2915,6 +2898,8 @@
       }
       return true;
     }
+    // Modifiers
+    /** Negates all values in this object */
     negate() {
       for (let i = 0; i < this.ELEMENTS; ++i) {
         this[i] = -this[i];
@@ -2932,12 +2917,14 @@
       }
       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]);
@@ -2978,18 +2965,25 @@
       }
       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) {
@@ -2997,39 +2991,48 @@
       }
       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;
     }
@@ -3049,13 +3052,13 @@
   }
   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, length2, callerName = "") {
     if (config.debug && !validateVector(v, length2)) {
-      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;
   }
@@ -3063,12 +3066,13 @@
   // ../../node_modules/@math.gl/core/dist/lib/assert.js
   function assert4(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];
     }
@@ -3081,12 +3085,24 @@
     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 length2 = 0;
       for (let i = 0; i < this.ELEMENTS; ++i) {
@@ -3094,6 +3110,9 @@
       }
       return length2;
     }
+    /**
+     * Returns the squared length of the vector from the origin to the point described by this vector
+     */
     magnitudeSquared() {
       return this.lengthSquared();
     }
@@ -3115,6 +3134,7 @@
       }
       return checkNumber(product);
     }
+    // MODIFIERS
     normalize() {
       const length2 = this.magnitude();
       if (length2 !== 0) {
@@ -3140,6 +3160,7 @@
       }
       return this.check();
     }
+    // THREE.js compatibility
     lengthSq() {
       return this.lengthSquared();
     }
@@ -3631,7 +3652,7 @@
     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];
@@ -3692,6 +3713,12 @@
       }
       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)) {
@@ -3736,6 +3763,7 @@
       object.z = this[2];
       return object;
     }
+    // Getters/setters
     get ELEMENTS() {
       return 3;
     }
@@ -3745,41 +3773,38 @@
     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();
@@ -3800,19 +3825,29 @@
 
   // ../../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 += "]";
@@ -3821,9 +3856,11 @@
     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;
@@ -4589,6 +4626,7 @@
       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;
@@ -4608,6 +4646,8 @@
       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;
@@ -4646,25 +4686,41 @@
       result[15] = this[15];
       return result;
     }
+    // Constructors
+    /** Set to identity matrix */
     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 4x4 matrix from the given quaternion
+     * @param quaternion Quaternion to create matrix from
+     * @returns self
+     */
     fromQuaternion(quaternion) {
       fromQuat(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 {
@@ -4672,35 +4728,47 @@
       }
       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);
@@ -4714,32 +4782,53 @@
         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 determinant(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];
@@ -4765,6 +4854,12 @@
       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];
@@ -4783,6 +4878,7 @@
       result[8] = this[10] * inverseScale2;
       return result;
     }
+    // Modifiers
     transpose() {
       transpose(this, this);
       return this.check();
@@ -4791,6 +4887,7 @@
       invert(this, this);
       return this.check();
     }
+    // Operations
     multiplyLeft(a) {
       multiply2(this, a, this);
       return this.check();
@@ -4799,33 +4896,68 @@
       multiply2(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) {
       rotate(this, this, radians2, axis);
       return this.check();
     }
+    /**
+     *
+     * @param factor
+     * @returns self
+     */
     scale(factor) {
       scale2(this, this, Array.isArray(factor) ? factor : [factor, factor, factor]);
       return this.check();
     }
+    /**
+     *
+     * @param vec
+     * @returns self
+     */
     translate(vector) {
       translate(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);
@@ -4834,10 +4966,14 @@
       }
       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: length2
-      } = vector;
+      const { length: length2 } = vector;
       let out;
       switch (length2) {
         case 2:
@@ -4852,6 +4988,12 @@
       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) {
@@ -4867,15 +5009,19 @@
       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);
     }
@@ -4990,11 +5136,20 @@
   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
@@ -5124,19 +5279,11 @@
         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);
@@ -5168,11 +5315,7 @@
   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;
@@ -5232,15 +5375,7 @@
   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;
       assert4(x >= 0);
       assert4(y >= 0);
       assert4(z >= 0);
@@ -5256,9 +5391,11 @@
       }
       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();
     }
@@ -5291,6 +5428,8 @@
     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);
     }
@@ -5308,9 +5447,14 @@
     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;
@@ -5320,12 +5464,17 @@
       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]) {
       assert4(equals(this.radii.x, this.radii.y, math_utils_exports.EPSILON15));
       assert4(this.radii.z > 0);
@@ -5337,10 +5486,10 @@
       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 VERSION4 = true ? "4.3.0-alpha.6" : "latest";
+  var VERSION4 = true ? "4.3.0-alpha.7" : "latest";
 
   // ../images/src/lib/category-api/image-type.ts
   var parseImageNode = globalThis.loaders?.parseImageNode;
@@ -5748,7 +5897,7 @@
   };
 
   // ../draco/src/lib/utils/version.ts
-  var VERSION5 = true ? "4.3.0-alpha.6" : "latest";
+  var VERSION5 = true ? "4.3.0-alpha.7" : "latest";
 
   // ../draco/src/draco-loader.ts
   var DracoLoader = {
@@ -6364,7 +6513,7 @@
   }
 
   // ../textures/src/lib/utils/version.ts
-  var VERSION6 = true ? "4.3.0-alpha.6" : "latest";
+  var VERSION6 = true ? "4.3.0-alpha.7" : "latest";
 
   // ../textures/src/lib/parsers/basis-module-loader.ts
   var BASIS_EXTERNAL_LIBRARIES = {
@@ -8050,7 +8199,7 @@
   }
 
   // src/i3s-content-loader.ts
-  var VERSION7 = true ? "4.3.0-alpha.6" : "latest";
+  var VERSION7 = true ? "4.3.0-alpha.7" : "latest";
   var I3SContentLoader = {
     dataType: null,
     batchType: null,