@loaders.gl/tiles 4.0.0-alpha.5 → 4.0.0-alpha.6

package/dist/dist.min.js

@@ -25,11 +25,8 @@
   });
 
   // ../../node_modules/@math.gl/core/dist/esm/lib/common.js
-  function round(value) {
-    return Math.round(value / config.EPSILON) * config.EPSILON;
-  }
   function formatValue(value, {
-    precision = config.precision || 4
+    precision = config.precision
   } = {}) {
     value = round(value);
     return "".concat(parseFloat(value.toPrecision(precision)));
@@ -37,19 +34,6 @@
   function isArray(value) {
     return Array.isArray(value) || ArrayBuffer.isView(value) && !(value instanceof DataView);
   }
-  function duplicateArray(array) {
-    return array.clone ? array.clone() : new Array(array.length);
-  }
-  function map(value, func, result) {
-    if (isArray(value)) {
-      result = result || duplicateArray(value);
-      for (let i = 0; i < result.length && i < value.length; ++i) {
-        result[i] = func(value[i], i, result);
-      }
-      return result;
-    }
-    return func(value);
-  }
   function toRadians(degrees2) {
     return radians(degrees2);
   }
@@ -88,7 +72,7 @@
       if (b && b.equals) {
         return b.equals(a);
       }
-      if (Number.isFinite(a) && Number.isFinite(b)) {
+      if (typeof a === "number" && typeof b === "number") {
         return Math.abs(a - b) <= config.EPSILON * Math.max(1, Math.abs(a), Math.abs(b));
       }
       return false;
@@ -96,18 +80,36 @@
       config.EPSILON = oldEpsilon;
     }
   }
+  function round(value) {
+    return Math.round(value / config.EPSILON) * config.EPSILON;
+  }
+  function duplicateArray(array) {
+    return array.clone ? array.clone() : new Array(array.length);
+  }
+  function map(value, func, result) {
+    if (isArray(value)) {
+      const array = value;
+      result = result || duplicateArray(array);
+      for (let i = 0; i < result.length && i < array.length; ++i) {
+        result[i] = func(value[i], i, result);
+      }
+      return result;
+    }
+    return func(value);
+  }
   var RADIANS_TO_DEGREES, DEGREES_TO_RADIANS, config;
   var init_common = __esm({
     "../../node_modules/@math.gl/core/dist/esm/lib/common.js"() {
       RADIANS_TO_DEGREES = 1 / Math.PI * 180;
       DEGREES_TO_RADIANS = 1 / 180 * Math.PI;
-      config = {};
-      config.EPSILON = 1e-12;
-      config.debug = false;
-      config.precision = 4;
-      config.printTypes = false;
-      config.printDegrees = false;
-      config.printRowMajor = true;
+      config = {
+        EPSILON: 1e-12,
+        debug: false,
+        precision: 4,
+        printTypes: false,
+        printDegrees: false,
+        printRowMajor: true
+      };
     }
   });
 
@@ -137,24 +139,25 @@
   var init_math_array = __esm({
     "../../node_modules/@math.gl/core/dist/esm/classes/base/math-array.js"() {
       init_common();
-      init_assert();
       MathArray = class extends _extendableBuiltin(Array) {
-        get ELEMENTS() {
-          assert(false);
-          return 0;
-        }
         clone() {
           return new this.constructor().copy(this);
         }
-        from(arrayOrObject) {
-          return Array.isArray(arrayOrObject) ? this.copy(arrayOrObject) : this.fromObject(arrayOrObject);
-        }
         fromArray(array, offset = 0) {
           for (let i = 0; i < this.ELEMENTS; ++i) {
             this[i] = array[i + offset];
           }
           return this.check();
         }
+        toArray(targetArray = [], offset = 0) {
+          for (let i = 0; i < this.ELEMENTS; ++i) {
+            targetArray[offset + i] = this[i];
+          }
+          return targetArray;
+        }
+        from(arrayOrObject) {
+          return Array.isArray(arrayOrObject) ? this.copy(arrayOrObject) : this.fromObject(arrayOrObject);
+        }
         to(arrayOrObject) {
           if (arrayOrObject === this) {
             return this;
@@ -164,12 +167,6 @@
         toTarget(target) {
           return target ? this.to(target) : this;
         }
-        toArray(array = [], offset = 0) {
-          for (let i = 0; i < this.ELEMENTS; ++i) {
-            array[offset + i] = this[i];
-          }
-          return array;
-        }
         toFloat32Array() {
           return new Float32Array(this);
         }
@@ -213,9 +210,7 @@
         }
         lerp(a, b, t) {
           if (t === void 0) {
-            t = b;
-            b = a;
-            a = this;
+            return this.lerp(this, a, b);
           }
           for (let i = 0; i < this.ELEMENTS; ++i) {
             const ai = a[i];
@@ -258,14 +253,36 @@
           return this.check();
         }
         scale(scale5) {
-          if (Array.isArray(scale5)) {
-            return this.multiply(scale5);
+          if (typeof scale5 === "number") {
+            for (let i = 0; i < this.ELEMENTS; ++i) {
+              this[i] *= scale5;
+            }
+          } else {
+            for (let i = 0; i < this.ELEMENTS && i < scale5.length; ++i) {
+              this[i] *= scale5[i];
+            }
           }
+          return this.check();
+        }
+        multiplyByScalar(scalar) {
           for (let i = 0; i < this.ELEMENTS; ++i) {
-            this[i] *= scale5;
+            this[i] *= scalar;
           }
           return this.check();
         }
+        check() {
+          if (config.debug && !this.validate()) {
+            throw new Error("math.gl: ".concat(this.constructor.name, " some fields set to invalid numbers'"));
+          }
+          return this;
+        }
+        validate() {
+          let valid = this.length === this.ELEMENTS;
+          for (let i = 0; i < this.ELEMENTS; ++i) {
+            valid = valid && Number.isFinite(this[i]);
+          }
+          return valid;
+        }
         sub(a) {
           return this.subtract(a);
         }
@@ -291,7 +308,7 @@
           return this.check();
         }
         divideScalar(a) {
-          return this.scale(1 / a);
+          return this.multiplyByScalar(1 / a);
         }
         clampScalar(min, max) {
           for (let i = 0; i < this.ELEMENTS; ++i) {
@@ -299,25 +316,9 @@
           }
           return this.check();
         }
-        multiplyByScalar(scalar) {
-          return this.scale(scalar);
-        }
         get elements() {
           return this;
         }
-        check() {
-          if (config.debug && !this.validate()) {
-            throw new Error("math.gl: ".concat(this.constructor.name, " some fields set to invalid numbers'"));
-          }
-          return this;
-        }
-        validate() {
-          let valid = this.length === this.ELEMENTS;
-          for (let i = 0; i < this.ELEMENTS; ++i) {
-            valid = valid && Number.isFinite(this[i]);
-          }
-          return valid;
-        }
       };
     }
   });
@@ -346,17 +347,9 @@
     }
     return v;
   }
-  function deprecated(method, version) {
-    if (!map2[method]) {
-      map2[method] = true;
-      console.warn("".concat(method, " has been removed in version ").concat(version, ", see upgrade guide for more information"));
-    }
-  }
-  var map2;
   var init_validators = __esm({
     "../../node_modules/@math.gl/core/dist/esm/lib/validators.js"() {
       init_common();
-      map2 = {};
     }
   });
 
@@ -368,14 +361,6 @@
       init_validators();
       init_assert();
       Vector = class extends MathArray {
-        get ELEMENTS() {
-          assert(false);
-          return 0;
-        }
-        copy(vector) {
-          assert(false);
-          return this;
-        }
         get x() {
           return this[0];
         }
@@ -580,6 +565,15 @@
     out[2] = a[2];
     return out;
   }
+  function vec4_transformMat2(out, a, m) {
+    const x = a[0];
+    const y = a[1];
+    out[0] = m[0] * x + m[2] * y;
+    out[1] = m[1] * x + m[3] * y;
+    out[2] = a[2];
+    out[3] = a[3];
+    return out;
+  }
   function vec4_transformMat3(out, a, m) {
     const x = a[0];
     const y = a[1];
@@ -754,7 +748,7 @@
   });
 
   // ../../node_modules/@math.gl/core/dist/esm/classes/vector3.js
-  var ORIGIN, constants, Vector3;
+  var ORIGIN, ZERO, Vector3;
   var init_vector3 = __esm({
     "../../node_modules/@math.gl/core/dist/esm/classes/vector3.js"() {
       init_vector();
@@ -763,10 +757,13 @@
       init_vec3();
       init_gl_matrix_extras();
       ORIGIN = [0, 0, 0];
-      constants = {};
       Vector3 = class extends Vector {
         static get ZERO() {
-          return constants.ZERO = constants.ZERO || Object.freeze(new Vector3(0, 0, 0, 0));
+          if (!ZERO) {
+            ZERO = new Vector3(0, 0, 0);
+            Object.freeze(ZERO);
+          }
+          return ZERO;
         }
         constructor(x = 0, y = 0, z = 0) {
           super(-0, -0, -0);
@@ -876,6 +873,113 @@
     }
   });
 
+  // ../../node_modules/@math.gl/core/dist/esm/classes/vector4.js
+  var ZERO2, Vector4;
+  var init_vector4 = __esm({
+    "../../node_modules/@math.gl/core/dist/esm/classes/vector4.js"() {
+      init_vector();
+      init_common();
+      init_validators();
+      init_vec3();
+      init_gl_matrix_extras();
+      Vector4 = class extends Vector {
+        static get ZERO() {
+          if (!ZERO2) {
+            ZERO2 = new Vector4(0, 0, 0, 0);
+            Object.freeze(ZERO2);
+          }
+          return ZERO2;
+        }
+        constructor(x = 0, y = 0, z = 0, w = 0) {
+          super(-0, -0, -0, -0);
+          if (isArray(x) && arguments.length === 1) {
+            this.copy(x);
+          } else {
+            if (config.debug) {
+              checkNumber(x);
+              checkNumber(y);
+              checkNumber(z);
+              checkNumber(w);
+            }
+            this[0] = x;
+            this[1] = y;
+            this[2] = z;
+            this[3] = w;
+          }
+        }
+        set(x, y, z, w) {
+          this[0] = x;
+          this[1] = y;
+          this[2] = z;
+          this[3] = w;
+          return this.check();
+        }
+        copy(array) {
+          this[0] = array[0];
+          this[1] = array[1];
+          this[2] = array[2];
+          this[3] = array[3];
+          return this.check();
+        }
+        fromObject(object) {
+          if (config.debug) {
+            checkNumber(object.x);
+            checkNumber(object.y);
+            checkNumber(object.z);
+            checkNumber(object.w);
+          }
+          this[0] = object.x;
+          this[1] = object.y;
+          this[2] = object.z;
+          this[3] = object.w;
+          return this;
+        }
+        toObject(object) {
+          object.x = this[0];
+          object.y = this[1];
+          object.z = this[2];
+          object.w = this[3];
+          return object;
+        }
+        get ELEMENTS() {
+          return 4;
+        }
+        get z() {
+          return this[2];
+        }
+        set z(value) {
+          this[2] = checkNumber(value);
+        }
+        get w() {
+          return this[3];
+        }
+        set w(value) {
+          this[3] = checkNumber(value);
+        }
+        transform(matrix4) {
+          transformMat42(this, this, matrix4);
+          return this.check();
+        }
+        transformByMatrix3(matrix3) {
+          vec4_transformMat3(this, this, matrix3);
+          return this.check();
+        }
+        transformByMatrix2(matrix2) {
+          vec4_transformMat2(this, this, matrix2);
+          return this.check();
+        }
+        transformByQuaternion(quaternion) {
+          transformQuat(this, this, quaternion);
+          return this.check();
+        }
+        applyMatrix4(m) {
+          m.transform(this, this);
+          return this;
+        }
+      };
+    }
+  });
+
   // ../../node_modules/@math.gl/core/dist/esm/classes/base/matrix.js
   var Matrix;
   var init_matrix = __esm({
@@ -883,16 +987,7 @@
       init_math_array();
       init_validators();
       init_common();
-      init_assert();
       Matrix = class extends MathArray {
-        get ELEMENTS() {
-          assert(false);
-          return 0;
-        }
-        get RANK() {
-          assert(false);
-          return 0;
-        }
         toString() {
           let string = "[";
           if (config.printRowMajor) {
@@ -1095,7 +1190,21 @@
   });
 
   // ../../node_modules/@math.gl/core/dist/esm/classes/matrix3.js
-  var IDENTITY, ZERO, INDICES, constants2, Matrix3;
+  function getZeroMatrix() {
+    if (!ZERO_MATRIX3) {
+      ZERO_MATRIX3 = new Matrix3([0, 0, 0, 0, 0, 0, 0, 0, 0]);
+      Object.freeze(ZERO_MATRIX3);
+    }
+    return ZERO_MATRIX3;
+  }
+  function getIdentityMatrix() {
+    if (!IDENTITY_MATRIX3) {
+      IDENTITY_MATRIX3 = new Matrix3();
+      Object.freeze(IDENTITY_MATRIX3);
+    }
+    return IDENTITY_MATRIX3;
+  }
+  var INDICES, IDENTITY_MATRIX, Matrix3, ZERO_MATRIX3, IDENTITY_MATRIX3;
   var init_matrix3 = __esm({
     "../../node_modules/@math.gl/core/dist/esm/classes/matrix3.js"() {
       init_matrix();
@@ -1104,28 +1213,24 @@
       init_mat3();
       init_vec2();
       init_vec3();
-      IDENTITY = Object.freeze([1, 0, 0, 0, 1, 0, 0, 0, 1]);
-      ZERO = Object.freeze([0, 0, 0, 0, 0, 0, 0, 0, 0]);
-      INDICES = Object.freeze({
-        COL0ROW0: 0,
-        COL0ROW1: 1,
-        COL0ROW2: 2,
-        COL1ROW0: 3,
-        COL1ROW1: 4,
-        COL1ROW2: 5,
-        COL2ROW0: 6,
-        COL2ROW1: 7,
-        COL2ROW2: 8
-      });
-      constants2 = {};
+      (function(INDICES3) {
+        INDICES3[INDICES3["COL0ROW0"] = 0] = "COL0ROW0";
+        INDICES3[INDICES3["COL0ROW1"] = 1] = "COL0ROW1";
+        INDICES3[INDICES3["COL0ROW2"] = 2] = "COL0ROW2";
+        INDICES3[INDICES3["COL1ROW0"] = 3] = "COL1ROW0";
+        INDICES3[INDICES3["COL1ROW1"] = 4] = "COL1ROW1";
+        INDICES3[INDICES3["COL1ROW2"] = 5] = "COL1ROW2";
+        INDICES3[INDICES3["COL2ROW0"] = 6] = "COL2ROW0";
+        INDICES3[INDICES3["COL2ROW1"] = 7] = "COL2ROW1";
+        INDICES3[INDICES3["COL2ROW2"] = 8] = "COL2ROW2";
+      })(INDICES || (INDICES = {}));
+      IDENTITY_MATRIX = Object.freeze([1, 0, 0, 0, 1, 0, 0, 0, 1]);
       Matrix3 = class extends Matrix {
         static get IDENTITY() {
-          constants2.IDENTITY = constants2.IDENTITY || Object.freeze(new Matrix3(IDENTITY));
-          return constants2.IDENTITY;
+          return getIdentityMatrix();
         }
         static get ZERO() {
-          constants2.ZERO = constants2.ZERO || Object.freeze(new Matrix3(ZERO));
-          return constants2.ZERO;
+          return getZeroMatrix();
         }
         get ELEMENTS() {
           return 9;
@@ -1136,10 +1241,12 @@
         get INDICES() {
           return INDICES;
         }
-        constructor(array) {
+        constructor(array, ...args) {
           super(-0, -0, -0, -0, -0, -0, -0, -0, -0);
           if (arguments.length === 1 && Array.isArray(array)) {
             this.copy(array);
+          } else if (args.length > 0) {
+            this.copy([array, ...args]);
           } else {
             this.identity();
           }
@@ -1156,6 +1263,16 @@
           this[8] = array[8];
           return this.check();
         }
+        identity() {
+          return this.copy(IDENTITY_MATRIX);
+        }
+        fromObject(object) {
+          return this.check();
+        }
+        fromQuaternion(q) {
+          fromQuat(this, q);
+          return this.check();
+        }
         set(m00, m10, m20, m01, m11, m21, m02, m12, m22) {
           this[0] = m00;
           this[1] = m10;
@@ -1183,13 +1300,6 @@
         determinant() {
           return determinant(this);
         }
-        identity() {
-          return this.copy(IDENTITY);
-        }
-        fromQuaternion(q) {
-          fromQuat(this, q);
-          return this.check();
-        }
         transpose() {
           transpose(this, this);
           return this.check();
@@ -1214,7 +1324,7 @@
           if (Array.isArray(factor)) {
             scale(this, this, factor);
           } else {
-            scale(this, this, [factor, factor, factor]);
+            scale(this, this, [factor, factor]);
           }
           return this.check();
         }
@@ -1223,32 +1333,30 @@
           return this.check();
         }
         transform(vector, result) {
+          let out;
           switch (vector.length) {
             case 2:
-              result = transformMat3(result || [-0, -0], vector, this);
+              out = transformMat3(result || [-0, -0], vector, this);
               break;
             case 3:
-              result = transformMat32(result || [-0, -0, -0], vector, this);
+              out = transformMat32(result || [-0, -0, -0], vector, this);
               break;
             case 4:
-              result = vec4_transformMat3(result || [-0, -0, -0, -0], vector, this);
+              out = vec4_transformMat3(result || [-0, -0, -0, -0], vector, this);
               break;
             default:
               throw new Error("Illegal vector");
           }
-          checkVector(result, vector.length);
-          return result;
+          checkVector(out, vector.length);
+          return out;
         }
         transformVector(vector, result) {
-          deprecated("Matrix3.transformVector");
           return this.transform(vector, result);
         }
         transformVector2(vector, result) {
-          deprecated("Matrix3.transformVector");
           return this.transform(vector, result);
         }
         transformVector3(vector, result) {
-          deprecated("Matrix3.transformVector");
           return this.transform(vector, result);
         }
       };
@@ -1692,7 +1800,7 @@
     out[15] = 0;
     return out;
   }
-  function perspective(out, fovy, aspect, near, far) {
+  function perspectiveNO(out, fovy, aspect, near, far) {
     var f = 1 / Math.tan(fovy / 2), nf;
     out[0] = f / aspect;
     out[1] = 0;
@@ -1718,7 +1826,7 @@
     }
     return out;
   }
-  function ortho(out, left, right, bottom, top, near, far) {
+  function orthoNO(out, left, right, bottom, top, near, far) {
     var lr = 1 / (left - right);
     var bt = 1 / (bottom - top);
     var nf = 1 / (near - far);
@@ -1807,9 +1915,12 @@
     out[15] = 1;
     return out;
   }
+  var perspective, ortho;
   var init_mat4 = __esm({
     "../../node_modules/gl-matrix/esm/mat4.js"() {
       init_common2();
+      perspective = perspectiveNO;
+      ortho = orthoNO;
     }
   });
 
@@ -1939,48 +2050,90 @@
   });
 
   // ../../node_modules/@math.gl/core/dist/esm/classes/matrix4.js
-  var IDENTITY2, ZERO2, INDICES2, constants3, Matrix4;
+  function getZeroMatrix2() {
+    if (!ZERO3) {
+      ZERO3 = new Matrix4([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]);
+      Object.freeze(ZERO3);
+    }
+    return ZERO3;
+  }
+  function getIdentityMatrix2() {
+    if (!IDENTITY) {
+      IDENTITY = new Matrix4();
+      Object.freeze(IDENTITY);
+    }
+    return IDENTITY;
+  }
+  function checkRadians(possiblyDegrees) {
+    if (possiblyDegrees > Math.PI * 2) {
+      throw Error("expected radians");
+    }
+  }
+  function computeInfinitePerspectiveOffCenter(result, left, right, bottom, top, near) {
+    const column0Row0 = 2 * near / (right - left);
+    const column1Row1 = 2 * near / (top - bottom);
+    const column2Row0 = (right + left) / (right - left);
+    const column2Row1 = (top + bottom) / (top - bottom);
+    const column2Row2 = -1;
+    const column2Row3 = -1;
+    const column3Row2 = -2 * near;
+    result[0] = column0Row0;
+    result[1] = 0;
+    result[2] = 0;
+    result[3] = 0;
+    result[4] = 0;
+    result[5] = column1Row1;
+    result[6] = 0;
+    result[7] = 0;
+    result[8] = column2Row0;
+    result[9] = column2Row1;
+    result[10] = column2Row2;
+    result[11] = column2Row3;
+    result[12] = 0;
+    result[13] = 0;
+    result[14] = column3Row2;
+    result[15] = 0;
+    return result;
+  }
+  var INDICES2, DEFAULT_FOVY, DEFAULT_ASPECT, DEFAULT_NEAR, DEFAULT_FAR, IDENTITY_MATRIX2, Matrix4, ZERO3, IDENTITY;
   var init_matrix4 = __esm({
     "../../node_modules/@math.gl/core/dist/esm/classes/matrix4.js"() {
-      init_validators();
       init_matrix();
+      init_validators();
       init_gl_matrix_extras();
       init_mat4();
       init_vec2();
       init_vec3();
       init_vec4();
-      IDENTITY2 = Object.freeze([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]);
-      ZERO2 = Object.freeze([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]);
-      INDICES2 = Object.freeze({
-        COL0ROW0: 0,
-        COL0ROW1: 1,
-        COL0ROW2: 2,
-        COL0ROW3: 3,
-        COL1ROW0: 4,
-        COL1ROW1: 5,
-        COL1ROW2: 6,
-        COL1ROW3: 7,
-        COL2ROW0: 8,
-        COL2ROW1: 9,
-        COL2ROW2: 10,
-        COL2ROW3: 11,
-        COL3ROW0: 12,
-        COL3ROW1: 13,
-        COL3ROW2: 14,
-        COL3ROW3: 15
-      });
-      constants3 = {};
+      (function(INDICES3) {
+        INDICES3[INDICES3["COL0ROW0"] = 0] = "COL0ROW0";
+        INDICES3[INDICES3["COL0ROW1"] = 1] = "COL0ROW1";
+        INDICES3[INDICES3["COL0ROW2"] = 2] = "COL0ROW2";
+        INDICES3[INDICES3["COL0ROW3"] = 3] = "COL0ROW3";
+        INDICES3[INDICES3["COL1ROW0"] = 4] = "COL1ROW0";
+        INDICES3[INDICES3["COL1ROW1"] = 5] = "COL1ROW1";
+        INDICES3[INDICES3["COL1ROW2"] = 6] = "COL1ROW2";
+        INDICES3[INDICES3["COL1ROW3"] = 7] = "COL1ROW3";
+        INDICES3[INDICES3["COL2ROW0"] = 8] = "COL2ROW0";
+        INDICES3[INDICES3["COL2ROW1"] = 9] = "COL2ROW1";
+        INDICES3[INDICES3["COL2ROW2"] = 10] = "COL2ROW2";
+        INDICES3[INDICES3["COL2ROW3"] = 11] = "COL2ROW3";
+        INDICES3[INDICES3["COL3ROW0"] = 12] = "COL3ROW0";
+        INDICES3[INDICES3["COL3ROW1"] = 13] = "COL3ROW1";
+        INDICES3[INDICES3["COL3ROW2"] = 14] = "COL3ROW2";
+        INDICES3[INDICES3["COL3ROW3"] = 15] = "COL3ROW3";
+      })(INDICES2 || (INDICES2 = {}));
+      DEFAULT_FOVY = 45 * Math.PI / 180;
+      DEFAULT_ASPECT = 1;
+      DEFAULT_NEAR = 0.1;
+      DEFAULT_FAR = 500;
+      IDENTITY_MATRIX2 = Object.freeze([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]);
       Matrix4 = class extends Matrix {
         static get IDENTITY() {
-          constants3.IDENTITY = constants3.IDENTITY || Object.freeze(new Matrix4(IDENTITY2));
-          return constants3.IDENTITY;
+          return getIdentityMatrix2();
         }
         static get ZERO() {
-          constants3.ZERO = constants3.ZERO || Object.freeze(new Matrix4(ZERO2));
-          return constants3.ZERO;
-        }
-        get INDICES() {
-          return INDICES2;
+          return getZeroMatrix2();
         }
         get ELEMENTS() {
           return 16;
@@ -1988,6 +2141,9 @@
         get RANK() {
           return 4;
         }
+        get INDICES() {
+          return INDICES2;
+        }
         constructor(array) {
           super(-0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0);
           if (arguments.length === 1 && Array.isArray(array)) {
@@ -2073,91 +2229,65 @@
           return result;
         }
         identity() {
-          return this.copy(IDENTITY2);
+          return this.copy(IDENTITY_MATRIX2);
         }
-        fromQuaternion(q) {
-          fromQuat2(this, q);
+        fromObject(object) {
           return this.check();
         }
-        frustum({
-          left,
-          right,
-          bottom,
-          top,
-          near,
-          far
-        }) {
+        fromQuaternion(quaternion) {
+          fromQuat2(this, quaternion);
+          return this.check();
+        }
+        frustum(view) {
+          const {
+            left,
+            right,
+            bottom,
+            top,
+            near = DEFAULT_NEAR,
+            far = DEFAULT_FAR
+          } = view;
           if (far === Infinity) {
-            Matrix4._computeInfinitePerspectiveOffCenter(this, left, right, bottom, top, near);
+            computeInfinitePerspectiveOffCenter(this, left, right, bottom, top, near);
           } else {
             frustum(this, left, right, bottom, top, near, far);
           }
           return this.check();
         }
-        static _computeInfinitePerspectiveOffCenter(result, left, right, bottom, top, near) {
-          const column0Row0 = 2 * near / (right - left);
-          const column1Row1 = 2 * near / (top - bottom);
-          const column2Row0 = (right + left) / (right - left);
-          const column2Row1 = (top + bottom) / (top - bottom);
-          const column2Row2 = -1;
-          const column2Row3 = -1;
-          const column3Row2 = -2 * near;
-          result[0] = column0Row0;
-          result[1] = 0;
-          result[2] = 0;
-          result[3] = 0;
-          result[4] = 0;
-          result[5] = column1Row1;
-          result[6] = 0;
-          result[7] = 0;
-          result[8] = column2Row0;
-          result[9] = column2Row1;
-          result[10] = column2Row2;
-          result[11] = column2Row3;
-          result[12] = 0;
-          result[13] = 0;
-          result[14] = column3Row2;
-          result[15] = 0;
-          return result;
-        }
-        lookAt(eye, center, up) {
-          if (arguments.length === 1) {
-            ({
-              eye,
-              center,
-              up
-            } = eye);
-          }
-          center = center || [0, 0, 0];
-          up = up || [0, 1, 0];
+        lookAt(view) {
+          const {
+            eye,
+            center = [0, 0, 0],
+            up = [0, 1, 0]
+          } = view;
           lookAt(this, eye, center, up);
           return this.check();
         }
-        ortho({
-          left,
-          right,
-          bottom,
-          top,
-          near = 0.1,
-          far = 500
-        }) {
+        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();
         }
-        orthographic({
-          fovy = 45 * Math.PI / 180,
-          aspect = 1,
-          focalDistance = 1,
-          near = 0.1,
-          far = 500
-        }) {
-          if (fovy > Math.PI * 2) {
-            throw Error("radians");
-          }
+        orthographic(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);
           const right = top * aspect;
-          return new Matrix4().ortho({
+          return this.ortho({
             left: -right,
             right,
             bottom: -top,
@@ -2166,17 +2296,14 @@
             far
           });
         }
-        perspective({
-          fovy = void 0,
-          fov = 45 * Math.PI / 180,
-          aspect = 1,
-          near = 0.1,
-          far = 500
-        } = {}) {
-          fovy = fovy || fov;
-          if (fovy > Math.PI * 2) {
-            throw Error("radians");
-          }
+        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();
         }
@@ -2195,8 +2322,10 @@
           result[2] = this[14];
           return result;
         }
-        getRotation(result = [-0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0], scaleResult = null) {
-          const scale5 = this.getScale(scaleResult || [-0, -0, -0]);
+        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];
+          const scale5 = this.getScale(scaleResult);
           const inverseScale0 = 1 / scale5[0];
           const inverseScale1 = 1 / scale5[1];
           const inverseScale2 = 1 / scale5[2];
@@ -2218,8 +2347,10 @@
           result[15] = 1;
           return result;
         }
-        getRotationMatrix3(result = [-0, -0, -0, -0, -0, -0, -0, -0, -0], scaleResult = null) {
-          const scale5 = this.getScale(scaleResult || [-0, -0, -0]);
+        getRotationMatrix3(result, scaleResult) {
+          result = result || [-0, -0, -0, -0, -0, -0, -0, -0, -0];
+          scaleResult = scaleResult || [-0, -0, -0];
+          const scale5 = this.getScale(scaleResult);
           const inverseScale0 = 1 / scale5[0];
           const inverseScale1 = 1 / scale5[1];
           const inverseScale2 = 1 / scale5[2];
@@ -2262,23 +2393,19 @@
           rotateZ2(this, this, radians2);
           return this.check();
         }
-        rotateXYZ([rx, ry, rz]) {
-          return this.rotateX(rx).rotateY(ry).rotateZ(rz);
+        rotateXYZ(angleXYZ) {
+          return this.rotateX(angleXYZ[0]).rotateY(angleXYZ[1]).rotateZ(angleXYZ[2]);
         }
         rotateAxis(radians2, axis) {
           rotate2(this, this, radians2, axis);
           return this.check();
         }
         scale(factor) {
-          if (Array.isArray(factor)) {
-            scale2(this, this, factor);
-          } else {
-            scale2(this, this, [factor, factor, factor]);
-          }
+          scale2(this, this, Array.isArray(factor) ? factor : [factor, factor, factor]);
           return this.check();
         }
-        translate(vec) {
-          translate2(this, this, vec);
+        translate(vector) {
+          translate2(this, this, vector);
           return this.check();
         }
         transform(vector, result) {
@@ -2293,51 +2420,50 @@
           const {
             length: length4
           } = vector;
+          let out;
           switch (length4) {
             case 2:
-              result = transformMat4(result || [-0, -0], vector, this);
+              out = transformMat4(result || [-0, -0], vector, this);
               break;
             case 3:
-              result = transformMat42(result || [-0, -0, -0], vector, this);
+              out = transformMat42(result || [-0, -0, -0], vector, this);
               break;
             default:
               throw new Error("Illegal vector");
           }
-          checkVector(result, vector.length);
-          return result;
+          checkVector(out, vector.length);
+          return out;
         }
         transformAsVector(vector, result) {
+          let out;
           switch (vector.length) {
             case 2:
-              result = vec2_transformMat4AsVector(result || [-0, -0], vector, this);
+              out = vec2_transformMat4AsVector(result || [-0, -0], vector, this);
               break;
             case 3:
-              result = vec3_transformMat4AsVector(result || [-0, -0, -0], vector, this);
+              out = vec3_transformMat4AsVector(result || [-0, -0, -0], vector, this);
               break;
             default:
               throw new Error("Illegal vector");
-          }
-          checkVector(result, vector.length);
-          return result;
-        }
-        makeRotationX(radians2) {
-          return this.identity().rotateX(radians2);
-        }
-        makeTranslation(x, y, z) {
-          return this.identity().translate([x, y, z]);
+          }
+          checkVector(out, vector.length);
+          return out;
         }
         transformPoint(vector, result) {
-          deprecated("Matrix4.transformPoint", "3.0");
           return this.transformAsPoint(vector, result);
         }
         transformVector(vector, result) {
-          deprecated("Matrix4.transformVector", "3.0");
           return this.transformAsPoint(vector, result);
         }
         transformDirection(vector, result) {
-          deprecated("Matrix4.transformDirection", "3.0");
           return this.transformAsVector(vector, result);
         }
+        makeRotationX(radians2) {
+          return this.identity().rotateX(radians2);
+        }
+        makeTranslation(x, y, z) {
+          return this.identity().translate([x, y, z]);
+        }
       };
     }
   });
@@ -2564,7 +2690,7 @@
     "../../node_modules/@math.gl/core/dist/esm/classes/quaternion.js"() {
       init_math_array();
       init_validators();
-      init_assert();
+      init_vector4();
       init_quat();
       init_vec4();
       IDENTITY_QUATERNION = [0, 0, 0, 1];
@@ -2591,18 +2717,25 @@
           this[3] = w;
           return this.check();
         }
-        fromMatrix3(m) {
-          fromMat3(this, m);
+        fromObject(object) {
+          this[0] = object.x;
+          this[1] = object.y;
+          this[2] = object.z;
+          this[3] = object.w;
           return this.check();
         }
-        identity() {
-          identity2(this);
+        fromMatrix3(m) {
+          fromMat3(this, m);
           return this.check();
         }
         fromAxisRotation(axis, rad) {
           setAxisAngle(this, axis, rad);
           return this.check();
         }
+        identity() {
+          identity2(this);
+          return this.check();
+        }
         setAxisAngle(axis, rad) {
           return this.fromAxisRotation(axis, rad);
         }
@@ -2639,20 +2772,14 @@
         lengthSquared() {
           return squaredLength2(this);
         }
-        dot(a, b) {
-          if (b !== void 0) {
-            throw new Error("Quaternion.dot only takes one argument");
-          }
+        dot(a) {
           return dot3(this, a);
         }
         rotationTo(vectorA, vectorB) {
           rotationTo(this, vectorA, vectorB);
           return this.check();
         }
-        add(a, b) {
-          if (b !== void 0) {
-            throw new Error("Quaternion.add only takes one argument");
-          }
+        add(a) {
           add2(this, this, a);
           return this.check();
         }
@@ -2669,16 +2796,17 @@
           return this.check();
         }
         lerp(a, b, t) {
+          if (t === void 0) {
+            return this.lerp(this, a, b);
+          }
           lerp2(this, a, b, t);
           return this.check();
         }
-        multiplyRight(a, b) {
-          assert(!b);
+        multiplyRight(a) {
           multiply3(this, this, a);
           return this.check();
         }
-        multiplyLeft(a, b) {
-          assert(!b);
+        multiplyLeft(a) {
           multiply3(this, a, this);
           return this.check();
         }
@@ -2710,25 +2838,32 @@
           scale4(this, this, b);
           return this.check();
         }
-        slerp(start, target, ratio) {
+        slerp(arg0, arg1, arg2) {
+          let start;
+          let target;
+          let ratio;
           switch (arguments.length) {
             case 1:
               ({
                 start = IDENTITY_QUATERNION,
                 target,
                 ratio
-              } = arguments[0]);
+              } = arg0);
               break;
             case 2:
-              [target, ratio] = arguments;
               start = this;
+              target = arg0;
+              ratio = arg1;
               break;
             default:
+              start = arg0;
+              target = arg1;
+              ratio = arg2;
           }
           slerp(this, start, target, ratio);
           return this.check();
         }
-        transformVector4(vector, result = vector) {
+        transformVector4(vector, result = new Vector4()) {
           transformQuat2(result, vector, this);
           return checkVector(result, 4);
         }
@@ -2738,16 +2873,82 @@
         setFromAxisAngle(axis, rad) {
           return this.setAxisAngle(axis, rad);
         }
-        premultiply(a, b) {
-          return this.multiplyLeft(a, b);
+        premultiply(a) {
+          return this.multiplyLeft(a);
         }
-        multiply(a, b) {
-          return this.multiplyRight(a, b);
+        multiply(a) {
+          return this.multiplyRight(a);
         }
       };
     }
   });
 
+  // ../../node_modules/@babel/runtime/helpers/esm/typeof.js
+  function _typeof(obj) {
+    "@babel/helpers - typeof";
+    return _typeof = typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? function(obj2) {
+      return typeof obj2;
+    } : function(obj2) {
+      return obj2 && typeof Symbol == "function" && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
+    }, _typeof(obj);
+  }
+  var init_typeof = __esm({
+    "../../node_modules/@babel/runtime/helpers/esm/typeof.js"() {
+    }
+  });
+
+  // ../../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);
+  }
+  var init_toPrimitive = __esm({
+    "../../node_modules/@babel/runtime/helpers/esm/toPrimitive.js"() {
+      init_typeof();
+    }
+  });
+
+  // ../../node_modules/@babel/runtime/helpers/esm/toPropertyKey.js
+  function _toPropertyKey(arg) {
+    var key = _toPrimitive(arg, "string");
+    return _typeof(key) === "symbol" ? key : String(key);
+  }
+  var init_toPropertyKey = __esm({
+    "../../node_modules/@babel/runtime/helpers/esm/toPropertyKey.js"() {
+      init_typeof();
+      init_toPrimitive();
+    }
+  });
+
+  // ../../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;
+  }
+  var init_defineProperty = __esm({
+    "../../node_modules/@babel/runtime/helpers/esm/defineProperty.js"() {
+      init_toPropertyKey();
+    }
+  });
+
   // ../../node_modules/@math.gl/core/dist/esm/lib/math-utils.js
   var math_utils_default;
   var init_math_utils = __esm({
@@ -2782,26 +2983,15 @@
   });
 
   // ../../node_modules/@math.gl/core/dist/esm/index.js
-  var globals, global_;
   var init_esm = __esm({
     "../../node_modules/@math.gl/core/dist/esm/index.js"() {
-      init_common();
       init_vector3();
       init_matrix3();
       init_matrix4();
       init_quaternion();
-      init_common();
       init_math_utils();
       init_assert();
-      globals = {
-        self: typeof self !== "undefined" && self,
-        window: typeof window !== "undefined" && window,
-        global: typeof global !== "undefined" && global
-      };
-      global_ = globals.global || globals.self || globals.window;
-      global_.mathgl = {
-        config
-      };
+      init_common();
     }
   });
 
@@ -2824,65 +3014,67 @@
   });
 
   // ../../node_modules/@math.gl/geospatial/dist/esm/type-utils.js
-  function fromCartographic(cartographic, result, map3 = noop) {
-    if (isArray(cartographic)) {
-      result[0] = map3(cartographic[0]);
-      result[1] = map3(cartographic[1]);
-      result[2] = cartographic[2];
-    } else if ("longitude" in cartographic) {
-      result[0] = map3(cartographic.longitude);
-      result[1] = map3(cartographic.latitude);
+  function identity3(x) {
+    return x;
+  }
+  function fromCartographic(cartographic, result = [], map2 = identity3) {
+    if ("longitude" in cartographic) {
+      result[0] = map2(cartographic.longitude);
+      result[1] = map2(cartographic.latitude);
       result[2] = cartographic.height;
-    } else {
-      result[0] = map3(cartographic.x);
-      result[1] = map3(cartographic.y);
+    } else if ("x" in cartographic) {
+      result[0] = map2(cartographic.x);
+      result[1] = map2(cartographic.y);
       result[2] = cartographic.z;
+    } else {
+      result[0] = map2(cartographic[0]);
+      result[1] = map2(cartographic[1]);
+      result[2] = cartographic[2];
     }
     return result;
   }
-  function fromCartographicToRadians(cartographic, vector = scratchVector) {
-    return fromCartographic(cartographic, vector, config._cartographicRadians ? noop : toRadians);
+  function fromCartographicToRadians(cartographic, vector = []) {
+    return fromCartographic(cartographic, vector, config._cartographicRadians ? identity3 : toRadians);
   }
-  function toCartographic(vector, cartographic, map3 = noop) {
-    if (isArray(cartographic)) {
-      cartographic[0] = map3(vector[0]);
-      cartographic[1] = map3(vector[1]);
-      cartographic[2] = vector[2];
-    } else if ("longitude" in cartographic) {
-      cartographic.longitude = map3(vector[0]);
-      cartographic.latitude = map3(vector[1]);
+  function toCartographic(vector, cartographic, map2 = identity3) {
+    if ("longitude" in cartographic) {
+      cartographic.longitude = map2(vector[0]);
+      cartographic.latitude = map2(vector[1]);
       cartographic.height = vector[2];
-    } else {
-      cartographic.x = map3(vector[0]);
-      cartographic.y = map3(vector[1]);
+    } else if ("x" in cartographic) {
+      cartographic.x = map2(vector[0]);
+      cartographic.y = map2(vector[1]);
       cartographic.z = vector[2];
+    } else {
+      cartographic[0] = map2(vector[0]);
+      cartographic[1] = map2(vector[1]);
+      cartographic[2] = vector[2];
     }
     return cartographic;
   }
   function toCartographicFromRadians(vector, cartographic) {
-    return toCartographic(vector, cartographic, config._cartographicRadians ? noop : toDegrees);
+    return toCartographic(vector, cartographic, config._cartographicRadians ? identity3 : toDegrees);
   }
-  var noop, scratchVector;
+  var scratchVector;
   var init_type_utils = __esm({
     "../../node_modules/@math.gl/geospatial/dist/esm/type-utils.js"() {
       init_esm();
       init_constants();
-      noop = (x) => x;
       scratchVector = new Vector3();
     }
   });
 
   // ../../node_modules/@math.gl/geospatial/dist/esm/ellipsoid/helpers/scale-to-geodetic-surface.js
-  function scaleToGeodeticSurface(cartesian, ellipsoid, result = new Vector3()) {
+  function scaleToGeodeticSurface(cartesian, ellipsoid, result = []) {
     const {
       oneOverRadii,
       oneOverRadiiSquared,
       centerToleranceSquared
     } = ellipsoid;
     scratchVector2.from(cartesian);
-    const positionX = cartesian.x;
-    const positionY = cartesian.y;
-    const positionZ = cartesian.z;
+    const positionX = scratchVector2.x;
+    const positionY = scratchVector2.y;
+    const positionZ = scratchVector2.z;
     const oneOverRadiiX = oneOverRadii.x;
     const oneOverRadiiY = oneOverRadii.y;
     const oneOverRadiiZ = oneOverRadii.z;
@@ -2904,7 +3096,7 @@
     const oneOverRadiiSquaredZ = oneOverRadiiSquared.z;
     const gradient = scaleToGeodeticSurfaceGradient;
     gradient.set(intersection.x * oneOverRadiiSquaredX * 2, intersection.y * oneOverRadiiSquaredY * 2, intersection.z * oneOverRadiiSquaredZ * 2);
-    let lambda = (1 - ratio) * cartesian.len() / (0.5 * gradient.len());
+    let lambda = (1 - ratio) * scratchVector2.len() / (0.5 * gradient.len());
     let correction = 0;
     let xMultiplier;
     let yMultiplier;
@@ -3067,9 +3259,10 @@
   });
 
   // ../../node_modules/@math.gl/geospatial/dist/esm/ellipsoid/ellipsoid.js
-  var scratchVector4, scratchNormal, scratchK, scratchPosition, scratchHeight, scratchCartesian, wgs84, Ellipsoid;
+  var scratchVector4, scratchNormal, scratchK, scratchPosition, scratchHeight, scratchCartesian, Ellipsoid;
   var init_ellipsoid = __esm({
     "../../node_modules/@math.gl/geospatial/dist/esm/ellipsoid/ellipsoid.js"() {
+      init_defineProperty();
       init_esm();
       init_vec3();
       init_constants();
@@ -3083,11 +3276,16 @@
       scratchHeight = new Vector3();
       scratchCartesian = new Vector3();
       Ellipsoid = class {
-        static get WGS84() {
-          wgs84 = wgs84 || new Ellipsoid(WGS84_RADIUS_X, WGS84_RADIUS_Y, WGS84_RADIUS_Z);
-          return wgs84;
-        }
         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_default.EPSILON1);
+          _defineProperty(this, "squaredXOverSquaredZ", void 0);
           assert(x >= 0);
           assert(y >= 0);
           assert(z >= 0);
@@ -3098,7 +3296,6 @@
           this.oneOverRadiiSquared = new Vector3(x === 0 ? 0 : 1 / (x * x), y === 0 ? 0 : 1 / (y * y), z === 0 ? 0 : 1 / (z * z));
           this.minimumRadius = Math.min(x, y, z);
           this.maximumRadius = Math.max(x, y, z);
-          this.centerToleranceSquared = math_utils_default.EPSILON1;
           if (this.radiiSquared.z !== 0) {
             this.squaredXOverSquaredZ = this.radiiSquared.x / this.radiiSquared.z;
           }
@@ -3185,6 +3382,7 @@
           return scratchPosition.set(0, 0, z).to(result);
         }
       };
+      _defineProperty(Ellipsoid, "WGS84", new Ellipsoid(WGS84_RADIUS_X, WGS84_RADIUS_Y, WGS84_RADIUS_Z));
     }
   });
 
@@ -3196,26 +3394,7 @@
     }
   });
 
-  // ../../node_modules/@babel/runtime/helpers/esm/defineProperty.js
-  function _defineProperty(obj, key, value) {
-    if (key in obj) {
-      Object.defineProperty(obj, key, {
-        value,
-        enumerable: true,
-        configurable: true,
-        writable: true
-      });
-    } else {
-      obj[key] = value;
-    }
-    return obj;
-  }
-  var init_defineProperty = __esm({
-    "../../node_modules/@babel/runtime/helpers/esm/defineProperty.js"() {
-    }
-  });
-
-  // ../../node_modules/@probe.gl/stats/dist/esm/utils/hi-res-timestamp.js
+  // ../../node_modules/@probe.gl/stats/dist/utils/hi-res-timestamp.js
   function getHiResTimestamp() {
     let timestamp;
     if (typeof window !== "undefined" && window.performance) {
@@ -3229,14 +3408,14 @@
     return timestamp;
   }
   var init_hi_res_timestamp = __esm({
-    "../../node_modules/@probe.gl/stats/dist/esm/utils/hi-res-timestamp.js"() {
+    "../../node_modules/@probe.gl/stats/dist/utils/hi-res-timestamp.js"() {
     }
   });
 
-  // ../../node_modules/@probe.gl/stats/dist/esm/lib/stat.js
+  // ../../node_modules/@probe.gl/stats/dist/lib/stat.js
   var Stat;
   var init_stat = __esm({
-    "../../node_modules/@probe.gl/stats/dist/esm/lib/stat.js"() {
+    "../../node_modules/@probe.gl/stats/dist/lib/stat.js"() {
       init_defineProperty();
       init_hi_res_timestamp();
       Stat = class {
@@ -3244,12 +3423,12 @@
           _defineProperty(this, "name", void 0);
           _defineProperty(this, "type", void 0);
           _defineProperty(this, "sampleSize", 1);
-          _defineProperty(this, "time", void 0);
-          _defineProperty(this, "count", void 0);
-          _defineProperty(this, "samples", void 0);
-          _defineProperty(this, "lastTiming", void 0);
-          _defineProperty(this, "lastSampleTime", void 0);
-          _defineProperty(this, "lastSampleCount", void 0);
+          _defineProperty(this, "time", 0);
+          _defineProperty(this, "count", 0);
+          _defineProperty(this, "samples", 0);
+          _defineProperty(this, "lastTiming", 0);
+          _defineProperty(this, "lastSampleTime", 0);
+          _defineProperty(this, "lastSampleCount", 0);
           _defineProperty(this, "_count", 0);
           _defineProperty(this, "_time", 0);
           _defineProperty(this, "_samples", 0);
@@ -3259,6 +3438,20 @@
           this.type = type;
           this.reset();
         }
+        reset() {
+          this.time = 0;
+          this.count = 0;
+          this.samples = 0;
+          this.lastTiming = 0;
+          this.lastSampleTime = 0;
+          this.lastSampleCount = 0;
+          this._count = 0;
+          this._time = 0;
+          this._samples = 0;
+          this._startTime = 0;
+          this._timerPending = false;
+          return this;
+        }
         setSampleSize(samples) {
           this.sampleSize = samples;
           return this;
@@ -3322,20 +3515,6 @@
         getHz() {
           return this.time > 0 ? this.samples / (this.time / 1e3) : 0;
         }
-        reset() {
-          this.time = 0;
-          this.count = 0;
-          this.samples = 0;
-          this.lastTiming = 0;
-          this.lastSampleTime = 0;
-          this.lastSampleCount = 0;
-          this._count = 0;
-          this._time = 0;
-          this._samples = 0;
-          this._startTime = 0;
-          this._timerPending = false;
-          return this;
-        }
         _checkSampling() {
           if (this._samples === this.sampleSize) {
             this.lastSampleTime = this._time;
@@ -3352,10 +3531,10 @@
     }
   });
 
-  // ../../node_modules/@probe.gl/stats/dist/esm/lib/stats.js
+  // ../../node_modules/@probe.gl/stats/dist/lib/stats.js
   var Stats;
   var init_stats = __esm({
-    "../../node_modules/@probe.gl/stats/dist/esm/lib/stats.js"() {
+    "../../node_modules/@probe.gl/stats/dist/lib/stats.js"() {
       init_defineProperty();
       init_stat();
       Stats = class {
@@ -3378,14 +3557,14 @@
           return Object.keys(this.stats).length;
         }
         reset() {
-          for (const key in this.stats) {
-            this.stats[key].reset();
+          for (const stat of Object.values(this.stats)) {
+            stat.reset();
           }
           return this;
         }
         forEach(fn) {
-          for (const key in this.stats) {
-            fn(this.stats[key]);
+          for (const stat of Object.values(this.stats)) {
+            fn(stat);
           }
         }
         getTable() {
@@ -3405,29 +3584,28 @@
           stats.forEach((stat) => this._getOrCreate(stat));
         }
         _getOrCreate(stat) {
-          if (!stat || !stat.name) {
-            return null;
-          }
           const {
             name,
             type
           } = stat;
-          if (!this.stats[name]) {
+          let result = this.stats[name];
+          if (!result) {
             if (stat instanceof Stat) {
-              this.stats[name] = stat;
+              result = stat;
             } else {
-              this.stats[name] = new Stat(name, type);
+              result = new Stat(name, type);
             }
+            this.stats[name] = result;
           }
-          return this.stats[name];
+          return result;
         }
       };
     }
   });
 
-  // ../../node_modules/@probe.gl/stats/dist/esm/index.js
-  var init_esm3 = __esm({
-    "../../node_modules/@probe.gl/stats/dist/esm/index.js"() {
+  // ../../node_modules/@probe.gl/stats/dist/index.js
+  var init_dist = __esm({
+    "../../node_modules/@probe.gl/stats/dist/index.js"() {
       init_stats();
       init_stat();
       init_hi_res_timestamp();
@@ -3446,19 +3624,19 @@
   });
 
   // ../loader-utils/src/lib/env-utils/globals.ts
-  var globals2, self_, window_, global_2, document_, isBrowser, matches, nodeVersion;
+  var globals, self_, window_, global_, document_, isBrowser, matches, nodeVersion;
   var init_globals = __esm({
     "../loader-utils/src/lib/env-utils/globals.ts"() {
-      globals2 = {
+      globals = {
         self: typeof self !== "undefined" && self,
         window: typeof window !== "undefined" && window,
         global: typeof global !== "undefined" && global,
         document: typeof document !== "undefined" && document
       };
-      self_ = globals2.self || globals2.window || globals2.global || {};
-      window_ = globals2.window || globals2.self || globals2.global || {};
-      global_2 = globals2.global || globals2.self || globals2.window || {};
-      document_ = globals2.document || {};
+      self_ = globals.self || globals.window || globals.global || {};
+      window_ = globals.window || globals.self || globals.global || {};
+      global_ = globals.global || globals.self || globals.window || {};
+      document_ = globals.document || {};
       isBrowser = Boolean(typeof process !== "object" || String(process) !== "[object process]" || process.browser);
       matches = typeof process !== "undefined" && process.version && /v([0-9]*)/.exec(process.version);
       nodeVersion = matches && parseFloat(matches[1]) || 0;
@@ -3489,19 +3667,19 @@
   });
 
   // ../worker-utils/src/lib/env-utils/globals.ts
-  var globals3, self_2, window_2, global_3, document_2, isBrowser2, isMobile, matches2, nodeVersion2;
+  var globals2, self_2, window_2, global_2, document_2, isBrowser2, isMobile, matches2, nodeVersion2;
   var init_globals2 = __esm({
     "../worker-utils/src/lib/env-utils/globals.ts"() {
-      globals3 = {
+      globals2 = {
         self: typeof self !== "undefined" && self,
         window: typeof window !== "undefined" && window,
         global: typeof global !== "undefined" && global,
         document: typeof document !== "undefined" && document
       };
-      self_2 = globals3.self || globals3.window || globals3.global || {};
-      window_2 = globals3.window || globals3.self || globals3.global || {};
-      global_3 = globals3.global || globals3.self || globals3.window || {};
-      document_2 = globals3.document || {};
+      self_2 = globals2.self || globals2.window || globals2.global || {};
+      window_2 = globals2.window || globals2.self || globals2.global || {};
+      global_2 = globals2.global || globals2.self || globals2.window || {};
+      document_2 = globals2.document || {};
       isBrowser2 = typeof process !== "object" || String(process) !== "[object process]" || process.browser;
       isMobile = typeof window !== "undefined" && typeof window.orientation !== "undefined";
       matches2 = typeof process !== "undefined" && process.version && /v([0-9]*)/.exec(process.version);
@@ -3516,15 +3694,15 @@
       init_assert3();
       WorkerJob = class {
         constructor(jobName, workerThread) {
-          this.name = jobName;
-          this.workerThread = workerThread;
           this.isRunning = true;
           this._resolve = () => {
           };
           this._reject = () => {
           };
-          this.result = new Promise((resolve, reject) => {
-            this._resolve = resolve;
+          this.name = jobName;
+          this.workerThread = workerThread;
+          this.result = new Promise((resolve2, reject) => {
+            this._resolve = resolve2;
             this._reject = reject;
           });
         }
@@ -3549,6 +3727,17 @@
     }
   });
 
+  // ../worker-utils/src/lib/node/worker_threads-browser.ts
+  var Worker2;
+  var init_worker_threads_browser = __esm({
+    "../worker-utils/src/lib/node/worker_threads-browser.ts"() {
+      Worker2 = class {
+        terminate() {
+        }
+      };
+    }
+  });
+
   // ../worker-utils/src/lib/worker-utils/get-loadable-worker-url.ts
   function getLoadableWorkerURL(props) {
     assert3(props.source && !props.url || !props.source && props.url);
@@ -3636,6 +3825,8 @@
   var NOOP, WorkerThread;
   var init_worker_thread = __esm({
     "../worker-utils/src/lib/worker-farm/worker-thread.ts"() {
+      init_worker_threads_browser();
+      init_globals2();
       init_assert3();
       init_get_loadable_worker_url();
       init_get_transfer_list();
@@ -3652,10 +3843,10 @@
           this.url = url;
           this.onMessage = NOOP;
           this.onError = (error) => console.log(error);
-          this.worker = this._createBrowserWorker();
+          this.worker = isBrowser2 ? this._createBrowserWorker() : this._createNodeWorker();
         }
         static isSupported() {
-          return typeof Worker !== "undefined";
+          return typeof Worker !== "undefined" && isBrowser2 || typeof Worker2 !== "undefined" && !isBrowser2;
         }
         destroy() {
           this.onMessage = NOOP;
@@ -3698,6 +3889,27 @@
           worker.onmessageerror = (event) => console.error(event);
           return worker;
         }
+        _createNodeWorker() {
+          let worker;
+          if (this.url) {
+            const absolute = this.url.includes(":/") || this.url.startsWith("/");
+            const url = absolute ? this.url : `./${this.url}`;
+            worker = new Worker2(url, { eval: false });
+          } else if (this.source) {
+            worker = new Worker2(this.source, { eval: true });
+          } else {
+            throw new Error("no worker");
+          }
+          worker.on("message", (data) => {
+            this.onMessage(data);
+          });
+          worker.on("error", (error) => {
+            this.onError(error);
+          });
+          worker.on("exit", (code) => {
+          });
+          return worker;
+        }
       };
     }
   });
@@ -3726,6 +3938,9 @@
           this.url = props.url;
           this.setProps(props);
         }
+        static isSupported() {
+          return WorkerThread.isSupported();
+        }
         destroy() {
           this.idleQueue.forEach((worker) => worker.destroy());
           this.isDestroyed = true;
@@ -3822,9 +4037,9 @@
       DEFAULT_PROPS = {
         maxConcurrency: 3,
         maxMobileConcurrency: 1,
+        reuseWorkers: true,
         onDebug: () => {
-        },
-        reuseWorkers: true
+        }
       };
       WorkerFarm = class {
         constructor(props) {
@@ -3845,6 +4060,7 @@
           for (const workerPool of this.workerPools.values()) {
             workerPool.destroy();
           }
+          this.workerPools = new Map();
         }
         setProps(props) {
           this.props = { ...this.props, ...props };
@@ -3928,6 +4144,7 @@
   var init_src = __esm({
     "../worker-utils/src/index.ts"() {
       init_assert3();
+      init_globals2();
       init_worker_farm();
       init_get_worker_url();
       init_validate_worker_version();
@@ -3939,6 +4156,9 @@
     if (!WorkerFarm.isSupported()) {
       return false;
     }
+    if (!isBrowser2 && !options?._nodeWorkers) {
+      return false;
+    }
     return loader.worker && options?.worker;
   }
   async function parseWithWorker(loader, data, options, context, parseOnMainThread) {
@@ -3947,10 +4167,12 @@
     const workerFarm = WorkerFarm.getWorkerFarm(options);
     const workerPool = workerFarm.getWorkerPool({ name, url });
     options = JSON.parse(JSON.stringify(options));
+    context = JSON.parse(JSON.stringify(context || {}));
     const job = await workerPool.startJob("process-on-worker", onMessage.bind(null, parseOnMainThread));
     job.postMessage("process", {
       input: data,
-      options
+      options,
+      context
     });
     const result = await job.result;
     return await result.result;
@@ -3980,49 +4202,11 @@
   var init_parse_with_worker = __esm({
     "../loader-utils/src/lib/worker-loader-utils/parse-with-worker.ts"() {
       init_src();
-    }
-  });
-
-  // ../loader-utils/src/lib/binary-utils/buffer-utils.ts
-  function isBuffer(value) {
-    return value && typeof value === "object" && value.isBuffer;
-  }
-  function bufferToArrayBuffer(buffer) {
-    if (isBuffer(buffer)) {
-      const typedArray = new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.length);
-      return typedArray.slice().buffer;
-    }
-    return buffer;
-  }
-  var init_buffer_utils = __esm({
-    "../loader-utils/src/lib/binary-utils/buffer-utils.ts"() {
+      init_src();
     }
   });
 
   // ../loader-utils/src/lib/binary-utils/array-buffer-utils.ts
-  function toArrayBuffer(data) {
-    if (isBuffer(data)) {
-      return bufferToArrayBuffer(data);
-    }
-    if (data instanceof ArrayBuffer) {
-      return data;
-    }
-    if (ArrayBuffer.isView(data)) {
-      if (data.byteOffset === 0 && data.byteLength === data.buffer.byteLength) {
-        return data.buffer;
-      }
-      return data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
-    }
-    if (typeof data === "string") {
-      const text = data;
-      const uint8Array = new TextEncoder().encode(text);
-      return uint8Array.buffer;
-    }
-    if (data && typeof data === "object" && data._toArrayBuffer) {
-      return data._toArrayBuffer();
-    }
-    throw new Error("toArrayBuffer");
-  }
   function compareArrayBuffers(arrayBuffer1, arrayBuffer2, byteLength) {
     byteLength = byteLength || arrayBuffer1.byteLength;
     if (arrayBuffer1.byteLength < byteLength || arrayBuffer2.byteLength < byteLength) {
@@ -4050,7 +4234,6 @@
   }
   var init_array_buffer_utils = __esm({
     "../loader-utils/src/lib/binary-utils/array-buffer-utils.ts"() {
-      init_buffer_utils();
     }
   });
 
@@ -4072,7 +4255,7 @@
   var STAT_QUEUED_REQUESTS, STAT_ACTIVE_REQUESTS, STAT_CANCELLED_REQUESTS, STAT_QUEUED_REQUESTS_EVER, STAT_ACTIVE_REQUESTS_EVER, DEFAULT_PROPS2, RequestScheduler;
   var init_request_scheduler = __esm({
     "../loader-utils/src/lib/request-utils/request-scheduler.ts"() {
-      init_esm3();
+      init_dist();
       STAT_QUEUED_REQUESTS = "Queued Requests";
       STAT_ACTIVE_REQUESTS = "Active Requests";
       STAT_CANCELLED_REQUESTS = "Cancelled Requests";
@@ -4106,8 +4289,8 @@
             return this.requestMap.get(handle);
           }
           const request = { handle, priority: 0, getPriority };
-          const promise = new Promise((resolve) => {
-            request.resolve = resolve;
+          const promise = new Promise((resolve2) => {
+            request.resolve = resolve2;
             return request;
           });
           this.requestQueue.push(request);
@@ -4116,7 +4299,7 @@
           return promise;
         }
         _issueRequest(request) {
-          const { handle, resolve } = request;
+          const { handle, resolve: resolve2 } = request;
           let isDone = false;
           const done = () => {
             if (!isDone) {
@@ -4127,7 +4310,7 @@
             }
           };
           this.activeRequestCount++;
-          return resolve ? resolve({ done }) : Promise.resolve({ done });
+          return resolve2 ? resolve2({ done }) : Promise.resolve({ done });
         }
         _issueNewRequests() {
           if (!this.deferredUpdate) {
@@ -4193,19 +4376,75 @@
     }
   });
 
+  // ../loader-utils/src/lib/node/buffer.browser.ts
+  function toArrayBuffer(buffer) {
+    return buffer;
+  }
+  var init_buffer_browser = __esm({
+    "../loader-utils/src/lib/node/buffer.browser.ts"() {
+    }
+  });
+
+  // ../loader-utils/src/lib/binary-utils/memory-conversion-utils.ts
+  function isBuffer(value) {
+    return value && typeof value === "object" && value.isBuffer;
+  }
+  function toArrayBuffer2(data) {
+    if (isBuffer(data)) {
+      return toArrayBuffer(data);
+    }
+    if (data instanceof ArrayBuffer) {
+      return data;
+    }
+    if (ArrayBuffer.isView(data)) {
+      if (data.byteOffset === 0 && data.byteLength === data.buffer.byteLength) {
+        return data.buffer;
+      }
+      return data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
+    }
+    if (typeof data === "string") {
+      const text = data;
+      const uint8Array = new TextEncoder().encode(text);
+      return uint8Array.buffer;
+    }
+    if (data && typeof data === "object" && data._toArrayBuffer) {
+      return data._toArrayBuffer();
+    }
+    throw new Error("toArrayBuffer");
+  }
+  var init_memory_conversion_utils = __esm({
+    "../loader-utils/src/lib/binary-utils/memory-conversion-utils.ts"() {
+      init_buffer_browser();
+    }
+  });
+
+  // ../loader-utils/src/lib/path-utils/get-cwd.ts
+  function getCWD() {
+    if (typeof process !== "undefined" && typeof process.cwd !== "undefined") {
+      return process.cwd();
+    }
+    const pathname = window.location?.pathname;
+    return pathname?.slice(0, pathname.lastIndexOf("/") + 1) || "";
+  }
+  var init_get_cwd = __esm({
+    "../loader-utils/src/lib/path-utils/get-cwd.ts"() {
+    }
+  });
+
   // ../loader-utils/src/lib/path-utils/path.ts
   var path_exports = {};
   __export(path_exports, {
     dirname: () => dirname,
     filename: () => filename,
-    join: () => join
+    join: () => join,
+    resolve: () => resolve
   });
   function filename(url) {
-    const slashIndex = url && url.lastIndexOf("/");
+    const slashIndex = url ? url.lastIndexOf("/") : -1;
     return slashIndex >= 0 ? url.substr(slashIndex + 1) : "";
   }
   function dirname(url) {
-    const slashIndex = url && url.lastIndexOf("/");
+    const slashIndex = url ? url.lastIndexOf("/") : -1;
     return slashIndex >= 0 ? url.substr(0, slashIndex) : "";
   }
   function join(...parts) {
@@ -4221,8 +4460,112 @@
     });
     return parts.join(separator);
   }
+  function resolve(...components) {
+    const paths = [];
+    for (let _i = 0; _i < components.length; _i++) {
+      paths[_i] = components[_i];
+    }
+    let resolvedPath = "";
+    let resolvedAbsolute = false;
+    let cwd;
+    for (let i = paths.length - 1; i >= -1 && !resolvedAbsolute; i--) {
+      let path;
+      if (i >= 0) {
+        path = paths[i];
+      } else {
+        if (cwd === void 0) {
+          cwd = getCWD();
+        }
+        path = cwd;
+      }
+      if (path.length === 0) {
+        continue;
+      }
+      resolvedPath = `${path}/${resolvedPath}`;
+      resolvedAbsolute = path.charCodeAt(0) === SLASH;
+    }
+    resolvedPath = normalizeStringPosix(resolvedPath, !resolvedAbsolute);
+    if (resolvedAbsolute) {
+      return `/${resolvedPath}`;
+    } else if (resolvedPath.length > 0) {
+      return resolvedPath;
+    }
+    return ".";
+  }
+  function normalizeStringPosix(path, allowAboveRoot) {
+    let res = "";
+    let lastSlash = -1;
+    let dots = 0;
+    let code;
+    let isAboveRoot = false;
+    for (let i = 0; i <= path.length; ++i) {
+      if (i < path.length) {
+        code = path.charCodeAt(i);
+      } else if (code === SLASH) {
+        break;
+      } else {
+        code = SLASH;
+      }
+      if (code === SLASH) {
+        if (lastSlash === i - 1 || dots === 1) {
+        } else if (lastSlash !== i - 1 && dots === 2) {
+          if (res.length < 2 || !isAboveRoot || res.charCodeAt(res.length - 1) !== DOT || res.charCodeAt(res.length - 2) !== DOT) {
+            if (res.length > 2) {
+              const start = res.length - 1;
+              let j = start;
+              for (; j >= 0; --j) {
+                if (res.charCodeAt(j) === SLASH) {
+                  break;
+                }
+              }
+              if (j !== start) {
+                res = j === -1 ? "" : res.slice(0, j);
+                lastSlash = i;
+                dots = 0;
+                isAboveRoot = false;
+                continue;
+              }
+            } else if (res.length === 2 || res.length === 1) {
+              res = "";
+              lastSlash = i;
+              dots = 0;
+              isAboveRoot = false;
+              continue;
+            }
+          }
+          if (allowAboveRoot) {
+            if (res.length > 0) {
+              res += "/..";
+            } else {
+              res = "..";
+            }
+            isAboveRoot = true;
+          }
+        } else {
+          const slice = path.slice(lastSlash + 1, i);
+          if (res.length > 0) {
+            res += `/${slice}`;
+          } else {
+            res = slice;
+          }
+          isAboveRoot = false;
+        }
+        lastSlash = i;
+        dots = 0;
+      } else if (code === DOT && dots !== -1) {
+        ++dots;
+      } else {
+        dots = -1;
+      }
+    }
+    return res;
+  }
+  var SLASH, DOT;
   var init_path = __esm({
     "../loader-utils/src/lib/path-utils/path.ts"() {
+      init_get_cwd();
+      SLASH = 47;
+      DOT = 46;
     }
   });
 
@@ -4236,6 +4579,7 @@
       init_async_iteration();
       init_request_scheduler();
       init_file_aliases();
+      init_memory_conversion_utils();
       init_path();
     }
   });
@@ -4269,55 +4613,55 @@
           return this._length;
         }
         add(item) {
-          const node = new DoublyLinkedListNode(item, this.tail, null);
+          const node2 = new DoublyLinkedListNode(item, this.tail, null);
           if (this.tail) {
-            this.tail.next = node;
-            this.tail = node;
+            this.tail.next = node2;
+            this.tail = node2;
           } else {
-            this.head = node;
-            this.tail = node;
+            this.head = node2;
+            this.tail = node2;
           }
           ++this._length;
-          return node;
+          return node2;
         }
-        remove(node) {
-          if (!node) {
+        remove(node2) {
+          if (!node2) {
             return;
           }
-          if (node.previous && node.next) {
-            node.previous.next = node.next;
-            node.next.previous = node.previous;
-          } else if (node.previous) {
-            node.previous.next = null;
-            this.tail = node.previous;
-          } else if (node.next) {
-            node.next.previous = null;
-            this.head = node.next;
+          if (node2.previous && node2.next) {
+            node2.previous.next = node2.next;
+            node2.next.previous = node2.previous;
+          } else if (node2.previous) {
+            node2.previous.next = null;
+            this.tail = node2.previous;
+          } else if (node2.next) {
+            node2.next.previous = null;
+            this.head = node2.next;
           } else {
             this.head = null;
             this.tail = null;
           }
-          node.next = null;
-          node.previous = null;
+          node2.next = null;
+          node2.previous = null;
           --this._length;
         }
-        splice(node, nextNode) {
-          if (node === nextNode) {
+        splice(node2, nextNode) {
+          if (node2 === nextNode) {
             return;
           }
           this.remove(nextNode);
-          this._insert(node, nextNode);
+          this._insert(node2, nextNode);
         }
-        _insert(node, nextNode) {
-          const oldNodeNext = node.next;
-          node.next = nextNode;
-          if (this.tail === node) {
+        _insert(node2, nextNode) {
+          const oldNodeNext = node2.next;
+          node2.next = nextNode;
+          if (this.tail === node2) {
             this.tail = nextNode;
           } else {
             oldNodeNext.previous = nextNode;
           }
           nextNode.next = oldNodeNext;
-          nextNode.previous = node;
+          nextNode.previous = node2;
           ++this._length;
         }
       };
@@ -4342,9 +4686,9 @@
           this._list.splice(this._list.tail, this._sentinel);
         }
         touch(tile) {
-          const node = tile._cacheNode;
-          if (defined(node)) {
-            this._list.splice(this._sentinel, node);
+          const node2 = tile._cacheNode;
+          if (defined(node2)) {
+            this._list.splice(this._sentinel, node2);
           }
         }
         add(tileset, tile, addCallback) {
@@ -4356,11 +4700,11 @@
           }
         }
         unloadTile(tileset, tile, unloadCallback) {
-          const node = tile._cacheNode;
-          if (!defined(node)) {
+          const node2 = tile._cacheNode;
+          if (!defined(node2)) {
             return;
           }
-          this._list.remove(node);
+          this._list.remove(node2);
           tile._cacheNode = void 0;
           if (unloadCallback) {
             unloadCallback(tileset, tile);
@@ -4372,10 +4716,10 @@
           const list = this._list;
           const maximumMemoryUsageInBytes = tileset.maximumMemoryUsage * 1024 * 1024;
           const sentinel = this._sentinel;
-          let node = list.head;
-          while (node !== sentinel && (tileset.gpuMemoryUsageInBytes > maximumMemoryUsageInBytes || trimTiles)) {
-            const tile = node.item;
-            node = node.next;
+          let node2 = list.head;
+          while (node2 !== sentinel && (tileset.gpuMemoryUsageInBytes > maximumMemoryUsageInBytes || trimTiles)) {
+            const tile = node2.item;
+            node2 = node2.next;
             this.unloadTile(tileset, tile, unloadCallback);
           }
         }
@@ -4440,11 +4784,11 @@
   var INTERSECTION;
   var init_constants2 = __esm({
     "../../node_modules/@math.gl/culling/dist/esm/constants.js"() {
-      INTERSECTION = Object.freeze({
+      INTERSECTION = {
         OUTSIDE: -1,
         INTERSECTING: 0,
         INSIDE: 1
-      });
+      };
     }
   });
 
@@ -4452,6 +4796,7 @@
   var scratchVector5, scratchNormal2;
   var init_axis_aligned_bounding_box = __esm({
     "../../node_modules/@math.gl/culling/dist/esm/lib/bounding-volumes/axis-aligned-bounding-box.js"() {
+      init_defineProperty();
       init_esm();
       init_constants2();
       scratchVector5 = new Vector3();
@@ -4463,6 +4808,7 @@
   var scratchVector6, scratchVector23, BoundingSphere;
   var init_bounding_sphere = __esm({
     "../../node_modules/@math.gl/culling/dist/esm/lib/bounding-volumes/bounding-sphere.js"() {
+      init_defineProperty();
       init_esm();
       init_mat4();
       init_constants2();
@@ -4470,6 +4816,8 @@
       scratchVector23 = new Vector3();
       BoundingSphere = class {
         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);
@@ -4511,8 +4859,8 @@
           return this;
         }
         expand(point) {
-          point = scratchVector6.from(point);
-          const radius = point.subtract(this.center).magnitude();
+          const scratchPoint2 = scratchVector6.from(point);
+          const radius = scratchPoint2.subtract(this.center).magnitude();
           if (radius > this.radius) {
             this.radius = radius;
           }
@@ -4525,12 +4873,13 @@
           return this;
         }
         distanceSquaredTo(point) {
-          point = scratchVector6.from(point);
-          const delta = point.subtract(this.center);
-          return delta.lengthSquared() - this.radius * this.radius;
+          const d = this.distanceTo(point);
+          return d * d;
         }
         distanceTo(point) {
-          return Math.sqrt(this.distanceSquaredTo(point));
+          const scratchPoint2 = scratchVector6.from(point);
+          const delta = scratchPoint2.subtract(this.center);
+          return Math.max(0, delta.len() - this.radius);
         }
         intersectPlane(plane) {
           const center = this.center;
@@ -4553,6 +4902,7 @@
   var scratchVector32, scratchOffset, scratchVectorU, scratchVectorV, scratchVectorW, scratchCorner, scratchToCenter, MATRIX3, OrientedBoundingBox;
   var init_oriented_bounding_box = __esm({
     "../../node_modules/@math.gl/culling/dist/esm/lib/bounding-volumes/oriented-bounding-box.js"() {
+      init_defineProperty();
       init_esm();
       init_bounding_sphere();
       init_constants2();
@@ -4576,6 +4926,8 @@
       };
       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);
         }
@@ -4747,11 +5099,14 @@
   var scratchPosition2, scratchNormal3, Plane;
   var init_plane = __esm({
     "../../node_modules/@math.gl/culling/dist/esm/lib/plane.js"() {
+      init_defineProperty();
       init_esm();
       scratchPosition2 = new Vector3();
       scratchNormal3 = new Vector3();
       Plane = class {
         constructor(normal = [0, 0, 1], distance = 0) {
+          _defineProperty(this, "normal", void 0);
+          _defineProperty(this, "distance", void 0);
           this.normal = new Vector3();
           this.distance = -0;
           this.fromNormalDistance(normal, distance);
@@ -4775,7 +5130,7 @@
           this.distance = d;
           return this;
         }
-        clone(plane) {
+        clone() {
           return new Plane(this.normal, this.distance);
         }
         equals(right) {
@@ -4803,6 +5158,7 @@
   var faces, scratchPlaneCenter, scratchPlaneNormal, scratchPlane, CullingVolume;
   var init_culling_volume = __esm({
     "../../node_modules/@math.gl/culling/dist/esm/lib/culling-volume.js"() {
+      init_defineProperty();
       init_esm();
       init_constants2();
       init_plane();
@@ -4811,18 +5167,9 @@
       scratchPlaneNormal = new Vector3();
       scratchPlane = new Plane(new Vector3(1, 0, 0), 0);
       CullingVolume = class {
-        static get MASK_OUTSIDE() {
-          return 4294967295;
-        }
-        static get MASK_INSIDE() {
-          return 0;
-        }
-        static get MASK_INDETERMINATE() {
-          return 2147483647;
-        }
         constructor(planes = []) {
+          _defineProperty(this, "planes", void 0);
           this.planes = planes;
-          assert(this.planes.every((plane) => plane instanceof Plane));
         }
         fromBoundingSphere(boundingSphere) {
           this.planes.length = 2 * faces.length;
@@ -4850,7 +5197,6 @@
           return this;
         }
         computeVisibility(boundingVolume) {
-          assert(boundingVolume);
           let intersect = INTERSECTION.INSIDE;
           for (const plane of this.planes) {
             const result = boundingVolume.intersectPlane(plane);
@@ -4866,7 +5212,6 @@
           return intersect;
         }
         computeVisibilityWithPlaneMask(boundingVolume, parentPlaneMask) {
-          assert(boundingVolume, "boundingVolume is required.");
           assert(Number.isFinite(parentPlaneMask), "parentPlaneMask is required.");
           if (parentPlaneMask === CullingVolume.MASK_OUTSIDE || parentPlaneMask === CullingVolume.MASK_INSIDE) {
             return parentPlaneMask;
@@ -4889,6 +5234,9 @@
           return mask;
         }
       };
+      _defineProperty(CullingVolume, "MASK_OUTSIDE", 4294967295);
+      _defineProperty(CullingVolume, "MASK_INSIDE", 0);
+      _defineProperty(CullingVolume, "MASK_INDETERMINATE", 2147483647);
     }
   });
 
@@ -4896,6 +5244,7 @@
   var scratchPlaneUpVector, scratchPlaneRightVector, scratchPlaneNearCenter, scratchPlaneFarCenter, scratchPlaneNormal2;
   var init_perspective_off_center_frustum = __esm({
     "../../node_modules/@math.gl/culling/dist/esm/lib/perspective-off-center-frustum.js"() {
+      init_defineProperty();
       init_esm();
       init_culling_volume();
       init_plane();
@@ -4910,6 +5259,7 @@
   // ../../node_modules/@math.gl/culling/dist/esm/lib/perspective-frustum.js
   var init_perspective_frustum = __esm({
     "../../node_modules/@math.gl/culling/dist/esm/lib/perspective-frustum.js"() {
+      init_defineProperty();
       init_perspective_off_center_frustum();
     }
   });
@@ -4971,7 +5321,7 @@
   });
 
   // ../../node_modules/@math.gl/culling/dist/esm/index.js
-  var init_esm4 = __esm({
+  var init_esm3 = __esm({
     "../../node_modules/@math.gl/culling/dist/esm/index.js"() {
       init_constants2();
       init_axis_aligned_bounding_box();
@@ -4984,8 +5334,6 @@
       init_bounding_sphere_from_points();
       init_bounding_box_from_points();
       init_compute_eigen_decomposition();
-      init_constants2();
-      init_constants2();
     }
   });
 
@@ -4993,44 +5341,93 @@
   function getFrameState(viewport, frameNumber) {
     const { cameraDirection, cameraUp, height } = viewport;
     const { metersPerUnit } = viewport.distanceScales;
-    const viewportCenterCartographic = viewport.unprojectPosition(viewport.center);
-    const viewportCenterCartesian = Ellipsoid.WGS84.cartographicToCartesian(viewportCenterCartographic, new Vector3());
+    const viewportCenterCartesian = worldToCartesian(viewport, viewport.center);
     const enuToFixedTransform = Ellipsoid.WGS84.eastNorthUpToFixedFrame(viewportCenterCartesian);
     const cameraPositionCartographic = viewport.unprojectPosition(viewport.cameraPosition);
-    const cameraPositionCartesian = Ellipsoid.WGS84.cartographicToCartesian(cameraPositionCartographic, new Vector3());
+    const cameraPositionCartesian2 = Ellipsoid.WGS84.cartographicToCartesian(cameraPositionCartographic, new Vector3());
     const cameraDirectionCartesian = new Vector3(enuToFixedTransform.transformAsVector(new Vector3(cameraDirection).scale(metersPerUnit))).normalize();
     const cameraUpCartesian = new Vector3(enuToFixedTransform.transformAsVector(new Vector3(cameraUp).scale(metersPerUnit))).normalize();
-    commonSpacePlanesToWGS84(viewport, viewportCenterCartesian);
+    commonSpacePlanesToWGS84(viewport);
+    const ViewportClass = viewport.constructor;
+    const { longitude, latitude, width, bearing, zoom } = viewport;
+    const topDownViewport = new ViewportClass({
+      longitude,
+      latitude,
+      height,
+      width,
+      bearing,
+      zoom,
+      pitch: 0
+    });
     return {
       camera: {
-        position: cameraPositionCartesian,
+        position: cameraPositionCartesian2,
         direction: cameraDirectionCartesian,
         up: cameraUpCartesian
       },
       viewport,
+      topDownViewport,
       height,
       cullingVolume,
       frameNumber,
       sseDenominator: 1.15
     };
   }
-  function commonSpacePlanesToWGS84(viewport, viewportCenterCartesian) {
+  function limitSelectedTiles(tiles, frameState, maximumTilesSelected) {
+    if (maximumTilesSelected === 0 || tiles.length <= maximumTilesSelected) {
+      return [tiles, []];
+    }
+    const tuples = [];
+    const { longitude: viewportLongitude, latitude: viewportLatitude } = frameState.viewport;
+    for (const [index, tile] of tiles.entries()) {
+      const [longitude, latitude] = tile.header.mbs;
+      const deltaLon = Math.abs(viewportLongitude - longitude);
+      const deltaLat = Math.abs(viewportLatitude - latitude);
+      const distance = Math.sqrt(deltaLat * deltaLat + deltaLon * deltaLon);
+      tuples.push([index, distance]);
+    }
+    const tuplesSorted = tuples.sort((a, b) => a[1] - b[1]);
+    const selectedTiles = [];
+    for (let i = 0; i < maximumTilesSelected; i++) {
+      selectedTiles.push(tiles[tuplesSorted[i][0]]);
+    }
+    const unselectedTiles = [];
+    for (let i = maximumTilesSelected; i < tuplesSorted.length; i++) {
+      unselectedTiles.push(tiles[tuplesSorted[i][0]]);
+    }
+    return [selectedTiles, unselectedTiles];
+  }
+  function commonSpacePlanesToWGS84(viewport) {
     const frustumPlanes = viewport.getFrustumPlanes();
+    const nearCenterCommon = closestPointOnPlane(frustumPlanes.near, viewport.cameraPosition);
+    const nearCenterCartesian = worldToCartesian(viewport, nearCenterCommon);
+    const cameraCartesian = worldToCartesian(viewport, viewport.cameraPosition, scratchPosition3);
     let i = 0;
+    cullingVolume.planes[i++].fromPointNormal(nearCenterCartesian, scratchVector7.copy(nearCenterCartesian).subtract(cameraCartesian));
     for (const dir in frustumPlanes) {
+      if (dir === "near") {
+        continue;
+      }
       const plane = frustumPlanes[dir];
-      const distanceToCenter = plane.normal.dot(viewport.center);
-      scratchPosition3.copy(plane.normal).scale(plane.distance - distanceToCenter).add(viewport.center);
-      const cartographicPos = viewport.unprojectPosition(scratchPosition3);
-      const cartesianPos = Ellipsoid.WGS84.cartographicToCartesian(cartographicPos, new Vector3());
-      cullingVolume.planes[i++].fromPointNormal(cartesianPos, scratchVector7.copy(viewportCenterCartesian).subtract(cartesianPos));
+      const posCommon = closestPointOnPlane(plane, nearCenterCommon, scratchPosition3);
+      const cartesianPos = worldToCartesian(viewport, posCommon, scratchPosition3);
+      cullingVolume.planes[i++].fromPointNormal(cartesianPos, scratchVector7.copy(nearCenterCartesian).subtract(cartesianPos));
     }
   }
+  function closestPointOnPlane(plane, refPoint, out = new Vector3()) {
+    const distanceToRef = plane.normal.dot(refPoint);
+    out.copy(plane.normal).scale(plane.distance - distanceToRef).add(refPoint);
+    return out;
+  }
+  function worldToCartesian(viewport, point, out = new Vector3()) {
+    const cartographicPos = viewport.unprojectPosition(point);
+    return Ellipsoid.WGS84.cartographicToCartesian(cartographicPos, out);
+  }
   var scratchVector7, scratchPosition3, cullingVolume;
   var init_frame_state = __esm({
     "src/tileset/helpers/frame-state.ts"() {
       init_esm();
-      init_esm4();
+      init_esm3();
       init_esm2();
       scratchVector7 = new Vector3();
       scratchPosition3 = new Vector3();
@@ -5046,20 +5443,31 @@
   });
 
   // src/tileset/helpers/zoom.ts
-  function getZoomFromBoundingVolume(boundingVolume) {
-    const { halfAxes, radius, width, height } = boundingVolume;
-    if (halfAxes) {
+  function getZoomFromBoundingVolume(boundingVolume, cartorgraphicCenter) {
+    if (boundingVolume instanceof OrientedBoundingBox) {
+      const { halfAxes } = boundingVolume;
       const obbSize = getObbSize(halfAxes);
-      return Math.log2(WGS84_RADIUS_Z2 / obbSize);
-    } else if (radius) {
-      return Math.log2(WGS84_RADIUS_Z2 / radius);
-    } else if (height && width) {
+      return Math.log2(WGS84_RADIUS_Z2 / (obbSize + cartorgraphicCenter[2]));
+    } else if (boundingVolume instanceof BoundingSphere) {
+      const { radius } = boundingVolume;
+      return Math.log2(WGS84_RADIUS_Z2 / (radius + cartorgraphicCenter[2]));
+    } else if (boundingVolume.width && boundingVolume.height) {
+      const { width, height } = boundingVolume;
       const zoomX = Math.log2(WGS84_RADIUS_X2 / width);
       const zoomY = Math.log2(WGS84_RADIUS_Y2 / height);
       return (zoomX + zoomY) / 2;
     }
     return 1;
   }
+  function getZoomFromFullExtent(fullExtent, cartorgraphicCenter, cartesianCenter) {
+    const extentVertex = Ellipsoid.WGS84.cartographicToCartesian([fullExtent.xmax, fullExtent.ymax, fullExtent.zmax], new Vector3());
+    const extentSize = Math.sqrt(Math.pow(extentVertex[0] - cartesianCenter[0], 2) + Math.pow(extentVertex[1] - cartesianCenter[1], 2) + Math.pow(extentVertex[2] - cartesianCenter[2], 2));
+    return Math.log2(WGS84_RADIUS_Z2 / (extentSize + cartorgraphicCenter[2]));
+  }
+  function getZoomFromExtent(extent, cartorgraphicCenter, cartesianCenter) {
+    const [xmin, ymin, xmax, ymax] = extent;
+    return getZoomFromFullExtent({ xmin, xmax, ymin, ymax, zmin: 0, zmax: 0 }, cartorgraphicCenter, cartesianCenter);
+  }
   function getObbSize(halfAxes) {
     halfAxes.getColumn(0, scratchVector8);
     const axeY = halfAxes.getColumn(1);
@@ -5072,6 +5480,8 @@
   var init_zoom = __esm({
     "src/tileset/helpers/zoom.ts"() {
       init_esm();
+      init_esm3();
+      init_esm2();
       WGS84_RADIUS_X2 = 6378137;
       WGS84_RADIUS_Y2 = 6378137;
       WGS84_RADIUS_Z2 = 6356752314245179e-9;
@@ -5218,7 +5628,7 @@
         text += ` ${await response.text()}`;
       }
       message += text;
-      message = message.length > 60 ? `${message.slice(60)}...` : message;
+      message = message.length > 60 ? `${message.slice(0, 60)}...` : message;
     } catch (error) {
     }
     return message;
@@ -5230,9 +5640,9 @@
     }
     if (resource instanceof Blob) {
       const blobSlice = resource.slice(0, 5);
-      return await new Promise((resolve) => {
+      return await new Promise((resolve2) => {
         const reader = new FileReader();
-        reader.onload = (event) => resolve(event?.target?.result);
+        reader.onload = (event) => resolve2(event?.target?.result);
         reader.readAsDataURL(blobSlice);
       });
     }
@@ -5277,12 +5687,12 @@
     }
   });
 
-  // ../../node_modules/probe.gl/dist/esm/env/is-electron.js
+  // ../../node_modules/@probe.gl/env/dist/lib/is-electron.js
   function isElectron(mockUserAgent) {
     if (typeof window !== "undefined" && typeof window.process === "object" && window.process.type === "renderer") {
       return true;
     }
-    if (typeof process !== "undefined" && typeof process.versions === "object" && Boolean(process.versions.electron)) {
+    if (typeof process !== "undefined" && typeof process.versions === "object" && Boolean(process.versions["electron"])) {
       return true;
     }
     const realUserAgent = typeof navigator === "object" && typeof navigator.userAgent === "string" && navigator.userAgent;
@@ -5293,52 +5703,54 @@
     return false;
   }
   var init_is_electron = __esm({
-    "../../node_modules/probe.gl/dist/esm/env/is-electron.js"() {
+    "../../node_modules/@probe.gl/env/dist/lib/is-electron.js"() {
     }
   });
 
-  // ../../node_modules/probe.gl/dist/esm/env/is-browser.js
+  // ../../node_modules/@probe.gl/env/dist/lib/is-browser.js
   function isBrowser3() {
     const isNode = typeof process === "object" && String(process) === "[object process]" && !process.browser;
     return !isNode || isElectron();
   }
   var init_is_browser = __esm({
-    "../../node_modules/probe.gl/dist/esm/env/is-browser.js"() {
+    "../../node_modules/@probe.gl/env/dist/lib/is-browser.js"() {
       init_is_electron();
     }
   });
 
-  // ../../node_modules/probe.gl/dist/esm/env/globals.js
-  var globals4, self_3, window_3, global_4, document_3, process_;
+  // ../../node_modules/@probe.gl/env/dist/lib/globals.js
+  var self_3, window_3, document_3, process_, console_, navigator_;
   var init_globals3 = __esm({
-    "../../node_modules/probe.gl/dist/esm/env/globals.js"() {
-      globals4 = {
-        self: typeof self !== "undefined" && self,
-        window: typeof window !== "undefined" && window,
-        global: typeof global !== "undefined" && global,
-        document: typeof document !== "undefined" && document,
-        process: typeof process === "object" && process
-      };
-      self_3 = globals4.self || globals4.window || globals4.global;
-      window_3 = globals4.window || globals4.self || globals4.global;
-      global_4 = globals4.global || globals4.self || globals4.window;
-      document_3 = globals4.document || {};
-      process_ = globals4.process || {};
+    "../../node_modules/@probe.gl/env/dist/lib/globals.js"() {
+      self_3 = globalThis.self || globalThis.window || globalThis.global;
+      window_3 = globalThis.window || globalThis.self || globalThis.global;
+      document_3 = globalThis.document || {};
+      process_ = globalThis.process || {};
+      console_ = globalThis.console;
+      navigator_ = globalThis.navigator || {};
     }
   });
 
-  // ../../node_modules/probe.gl/dist/esm/utils/globals.js
+  // ../../node_modules/@probe.gl/env/dist/utils/globals.js
   var VERSION2, isBrowser4;
   var init_globals4 = __esm({
-    "../../node_modules/probe.gl/dist/esm/utils/globals.js"() {
+    "../../node_modules/@probe.gl/env/dist/utils/globals.js"() {
       init_is_browser();
-      init_globals3();
       VERSION2 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "untranspiled source";
       isBrowser4 = isBrowser3();
     }
   });
 
-  // ../../node_modules/probe.gl/dist/esm/utils/local-storage.js
+  // ../../node_modules/@probe.gl/env/dist/index.js
+  var init_dist2 = __esm({
+    "../../node_modules/@probe.gl/env/dist/index.js"() {
+      init_globals4();
+      init_globals3();
+      init_is_browser();
+    }
+  });
+
+  // ../../node_modules/@probe.gl/log/dist/utils/local-storage.js
   function getStorage(type) {
     try {
       const storage = window[type];
@@ -5352,29 +5764,28 @@
   }
   var LocalStorage;
   var init_local_storage = __esm({
-    "../../node_modules/probe.gl/dist/esm/utils/local-storage.js"() {
+    "../../node_modules/@probe.gl/log/dist/utils/local-storage.js"() {
+      init_defineProperty();
       LocalStorage = class {
-        constructor(id, defaultSettings, type = "sessionStorage") {
+        constructor(id, defaultConfig) {
+          let type = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : "sessionStorage";
+          _defineProperty(this, "storage", void 0);
+          _defineProperty(this, "id", void 0);
+          _defineProperty(this, "config", void 0);
           this.storage = getStorage(type);
           this.id = id;
-          this.config = {};
-          Object.assign(this.config, defaultSettings);
+          this.config = defaultConfig;
           this._loadConfiguration();
         }
         getConfiguration() {
           return this.config;
         }
         setConfiguration(configuration) {
-          this.config = {};
-          return this.updateConfiguration(configuration);
-        }
-        updateConfiguration(configuration) {
           Object.assign(this.config, configuration);
           if (this.storage) {
             const serialized = JSON.stringify(this.config);
             this.storage.setItem(this.id, serialized);
           }
-          return this;
         }
         _loadConfiguration() {
           let configuration = {};
@@ -5389,7 +5800,7 @@
     }
   });
 
-  // ../../node_modules/probe.gl/dist/esm/utils/formatters.js
+  // ../../node_modules/@probe.gl/log/dist/utils/formatters.js
   function formatTime(ms) {
     let formatted;
     if (ms < 10) {
@@ -5403,11 +5814,13 @@
     }
     return formatted;
   }
-  function leftPad(string, length4 = 8) {
+  function leftPad(string) {
+    let length4 = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 8;
     const padLength = Math.max(length4 - string.length, 0);
     return "".concat(" ".repeat(padLength)).concat(string);
   }
-  function formatImage(image, message, scale5, maxWidth = 600) {
+  function formatImage(image, message, scale5) {
+    let maxWidth = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : 600;
     const imageUrl = image.src.replace(/\(/g, "%28").replace(/\)/g, "%29");
     if (image.width > maxWidth) {
       scale5 = Math.min(scale5, maxWidth / image.width);
@@ -5418,87 +5831,97 @@
     return ["".concat(message, " %c+"), style];
   }
   var init_formatters = __esm({
-    "../../node_modules/probe.gl/dist/esm/utils/formatters.js"() {
+    "../../node_modules/@probe.gl/log/dist/utils/formatters.js"() {
     }
   });
 
-  // ../../node_modules/probe.gl/dist/esm/utils/color.js
+  // ../../node_modules/@probe.gl/log/dist/utils/color.js
   function getColor(color) {
-    return typeof color === "string" ? COLOR[color.toUpperCase()] || COLOR.WHITE : color;
+    if (typeof color !== "string") {
+      return color;
+    }
+    color = color.toUpperCase();
+    return COLOR[color] || COLOR.WHITE;
   }
   function addColor(string, color, background) {
-    if (!isBrowser4 && typeof string === "string") {
+    if (!isBrowser3 && typeof string === "string") {
       if (color) {
-        color = getColor(color);
-        string = "[".concat(color, "m").concat(string, "");
+        const colorCode = getColor(color);
+        string = "[".concat(colorCode, "m").concat(string, "");
       }
       if (background) {
-        color = getColor(background);
-        string = "[".concat(background + 10, "m").concat(string, "");
+        const colorCode = getColor(background);
+        string = "[".concat(colorCode + BACKGROUND_INCREMENT, "m").concat(string, "");
       }
     }
     return string;
   }
-  var COLOR;
+  var COLOR, BACKGROUND_INCREMENT;
   var init_color = __esm({
-    "../../node_modules/probe.gl/dist/esm/utils/color.js"() {
-      init_globals4();
-      COLOR = {
-        BLACK: 30,
-        RED: 31,
-        GREEN: 32,
-        YELLOW: 33,
-        BLUE: 34,
-        MAGENTA: 35,
-        CYAN: 36,
-        WHITE: 37,
-        BRIGHT_BLACK: 90,
-        BRIGHT_RED: 91,
-        BRIGHT_GREEN: 92,
-        BRIGHT_YELLOW: 93,
-        BRIGHT_BLUE: 94,
-        BRIGHT_MAGENTA: 95,
-        BRIGHT_CYAN: 96,
-        BRIGHT_WHITE: 97
-      };
+    "../../node_modules/@probe.gl/log/dist/utils/color.js"() {
+      init_dist2();
+      (function(COLOR2) {
+        COLOR2[COLOR2["BLACK"] = 30] = "BLACK";
+        COLOR2[COLOR2["RED"] = 31] = "RED";
+        COLOR2[COLOR2["GREEN"] = 32] = "GREEN";
+        COLOR2[COLOR2["YELLOW"] = 33] = "YELLOW";
+        COLOR2[COLOR2["BLUE"] = 34] = "BLUE";
+        COLOR2[COLOR2["MAGENTA"] = 35] = "MAGENTA";
+        COLOR2[COLOR2["CYAN"] = 36] = "CYAN";
+        COLOR2[COLOR2["WHITE"] = 37] = "WHITE";
+        COLOR2[COLOR2["BRIGHT_BLACK"] = 90] = "BRIGHT_BLACK";
+        COLOR2[COLOR2["BRIGHT_RED"] = 91] = "BRIGHT_RED";
+        COLOR2[COLOR2["BRIGHT_GREEN"] = 92] = "BRIGHT_GREEN";
+        COLOR2[COLOR2["BRIGHT_YELLOW"] = 93] = "BRIGHT_YELLOW";
+        COLOR2[COLOR2["BRIGHT_BLUE"] = 94] = "BRIGHT_BLUE";
+        COLOR2[COLOR2["BRIGHT_MAGENTA"] = 95] = "BRIGHT_MAGENTA";
+        COLOR2[COLOR2["BRIGHT_CYAN"] = 96] = "BRIGHT_CYAN";
+        COLOR2[COLOR2["BRIGHT_WHITE"] = 97] = "BRIGHT_WHITE";
+      })(COLOR || (COLOR = {}));
+      BACKGROUND_INCREMENT = 10;
     }
   });
 
-  // ../../node_modules/probe.gl/dist/esm/utils/autobind.js
-  function autobind(obj, predefined = ["constructor"]) {
+  // ../../node_modules/@probe.gl/log/dist/utils/autobind.js
+  function autobind(obj) {
+    let predefined = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : ["constructor"];
     const proto = Object.getPrototypeOf(obj);
     const propNames = Object.getOwnPropertyNames(proto);
+    const object = obj;
     for (const key of propNames) {
-      if (typeof obj[key] === "function") {
+      const value = object[key];
+      if (typeof value === "function") {
         if (!predefined.find((name) => key === name)) {
-          obj[key] = obj[key].bind(obj);
+          object[key] = value.bind(obj);
         }
       }
     }
   }
   var init_autobind = __esm({
-    "../../node_modules/probe.gl/dist/esm/utils/autobind.js"() {
+    "../../node_modules/@probe.gl/log/dist/utils/autobind.js"() {
     }
   });
 
-  // ../../node_modules/probe.gl/dist/esm/utils/assert.js
+  // ../../node_modules/@probe.gl/log/dist/utils/assert.js
   function assert4(condition, message) {
     if (!condition) {
       throw new Error(message || "Assertion failed");
     }
   }
   var init_assert4 = __esm({
-    "../../node_modules/probe.gl/dist/esm/utils/assert.js"() {
+    "../../node_modules/@probe.gl/log/dist/utils/assert.js"() {
     }
   });
 
-  // ../../node_modules/probe.gl/dist/esm/utils/hi-res-timestamp.js
+  // ../../node_modules/@probe.gl/log/dist/utils/hi-res-timestamp.js
   function getHiResTimestamp2() {
     let timestamp;
-    if (isBrowser4 && window_3.performance) {
-      timestamp = window_3.performance.now();
-    } else if (process_.hrtime) {
-      const timeParts = process_.hrtime();
+    if (isBrowser3() && window_3.performance) {
+      var _window$performance, _window$performance$n;
+      timestamp = window_3 === null || window_3 === void 0 ? void 0 : (_window$performance = window_3.performance) === null || _window$performance === void 0 ? void 0 : (_window$performance$n = _window$performance.now) === null || _window$performance$n === void 0 ? void 0 : _window$performance$n.call(_window$performance);
+    } else if ("hrtime" in process_) {
+      var _process$hrtime;
+      const timeParts = process_ === null || process_ === void 0 ? void 0 : (_process$hrtime = process_.hrtime) === null || _process$hrtime === void 0 ? void 0 : _process$hrtime.call(process_);
       timestamp = timeParts[0] * 1e3 + timeParts[1] / 1e6;
     } else {
       timestamp = Date.now();
@@ -5506,21 +5929,13 @@
     return timestamp;
   }
   var init_hi_res_timestamp2 = __esm({
-    "../../node_modules/probe.gl/dist/esm/utils/hi-res-timestamp.js"() {
-      init_globals4();
+    "../../node_modules/@probe.gl/log/dist/utils/hi-res-timestamp.js"() {
+      init_dist2();
     }
   });
 
-  // ../../node_modules/probe.gl/dist/esm/lib/log.js
-  function noop2() {
-  }
-  function getTableHeader(table) {
-    for (const key in table) {
-      for (const title in table[key]) {
-        return title || "untitled";
-      }
-    }
-    return "empty";
+  // ../../node_modules/@probe.gl/log/dist/log.js
+  function noop() {
   }
   function normalizeLogLevel(logLevel) {
     if (!logLevel) {
@@ -5549,7 +5964,6 @@
     const args = opts.args ? Array.from(opts.args) : [];
     while (args.length && args.shift() !== message) {
     }
-    opts.args = args;
     switch (typeof logLevel) {
       case "string":
       case "function":
@@ -5568,7 +5982,9 @@
     }
     const messageType = typeof opts.message;
     assert4(messageType === "string" || messageType === "object");
-    return Object.assign(opts, opts.opts);
+    return Object.assign(opts, {
+      args
+    }, opts.opts);
   }
   function decorateMessage(id, message, opts) {
     if (typeof message === "string") {
@@ -5578,29 +5994,21 @@
     }
     return message;
   }
-  function logImageInNode({
-    image,
-    message = "",
-    scale: scale5 = 1
-  }) {
-    let asciify = null;
-    try {
-      asciify = module.require("asciify-image");
-    } catch (error) {
-    }
-    if (asciify) {
-      return () => asciify(image, {
-        fit: "box",
-        width: "".concat(Math.round(80 * scale5), "%")
-      }).then((data) => console.log(data));
-    }
-    return noop2;
-  }
-  function logImageInBrowser({
-    image,
-    message = "",
-    scale: scale5 = 1
-  }) {
+  function logImageInNode(_ref2) {
+    let {
+      image,
+      message = "",
+      scale: scale5 = 1
+    } = _ref2;
+    console.warn("removed");
+    return noop;
+  }
+  function logImageInBrowser(_ref3) {
+    let {
+      image,
+      message = "",
+      scale: scale5 = 1
+    } = _ref3;
     if (typeof image === "string") {
       const img = new Image();
       img.onload = () => {
@@ -5608,25 +6016,34 @@
         console.log(...args);
       };
       img.src = image;
-      return noop2;
+      return noop;
     }
     const element = image.nodeName || "";
     if (element.toLowerCase() === "img") {
       console.log(...formatImage(image, message, scale5));
-      return noop2;
+      return noop;
     }
     if (element.toLowerCase() === "canvas") {
       const img = new Image();
       img.onload = () => console.log(...formatImage(img, message, scale5));
       img.src = image.toDataURL();
-      return noop2;
+      return noop;
+    }
+    return noop;
+  }
+  function getTableHeader(table) {
+    for (const key in table) {
+      for (const title in table[key]) {
+        return title || "untitled";
+      }
     }
-    return noop2;
+    return "empty";
   }
-  var originalConsole, DEFAULT_SETTINGS, cache, ONCE, Log;
+  var originalConsole, DEFAULT_LOG_CONFIGURATION, cache, ONCE, Log;
   var init_log = __esm({
-    "../../node_modules/probe.gl/dist/esm/lib/log.js"() {
-      init_globals4();
+    "../../node_modules/@probe.gl/log/dist/log.js"() {
+      init_defineProperty();
+      init_dist2();
       init_local_storage();
       init_formatters();
       init_color();
@@ -5634,13 +6051,13 @@
       init_assert4();
       init_hi_res_timestamp2();
       originalConsole = {
-        debug: isBrowser4 ? console.debug || console.log : console.log,
+        debug: isBrowser3() ? console.debug || console.log : console.log,
         log: console.log,
         info: console.info,
         warn: console.warn,
         error: console.error
       };
-      DEFAULT_SETTINGS = {
+      DEFAULT_LOG_CONFIGURATION = {
         enabled: true,
         level: 0
       };
@@ -5649,18 +6066,22 @@
         once: true
       };
       Log = class {
-        constructor({
-          id
-        } = {
-          id: ""
-        }) {
+        constructor() {
+          let {
+            id
+          } = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {
+            id: ""
+          };
+          _defineProperty(this, "id", void 0);
+          _defineProperty(this, "VERSION", VERSION2);
+          _defineProperty(this, "_startTs", getHiResTimestamp2());
+          _defineProperty(this, "_deltaTs", getHiResTimestamp2());
+          _defineProperty(this, "_storage", void 0);
+          _defineProperty(this, "userData", {});
+          _defineProperty(this, "LOG_THROTTLE_TIMEOUT", 0);
           this.id = id;
-          this.VERSION = VERSION2;
-          this._startTs = getHiResTimestamp2();
-          this._deltaTs = getHiResTimestamp2();
-          this.LOG_THROTTLE_TIMEOUT = 0;
-          this._storage = new LocalStorage("__probe-".concat(this.id, "__"), DEFAULT_SETTINGS);
           this.userData = {};
+          this._storage = new LocalStorage("__probe-".concat(this.id, "__"), DEFAULT_LOG_CONFIGURATION);
           this.timeStamp("".concat(this.id, " started"));
           autobind(this);
           Object.seal(this);
@@ -5692,18 +6113,34 @@
         getPriority() {
           return this.level;
         }
-        enable(enabled = true) {
-          this._storage.updateConfiguration({
+        enable() {
+          let enabled = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : true;
+          this._storage.setConfiguration({
             enabled
           });
           return this;
         }
         setLevel(level) {
-          this._storage.updateConfiguration({
+          this._storage.setConfiguration({
             level
           });
           return this;
         }
+        get(setting) {
+          return this._storage.config[setting];
+        }
+        set(setting, value) {
+          this._storage.setConfiguration({
+            [setting]: value
+          });
+        }
+        settings() {
+          if (console.table) {
+            console.table(this._storage.config);
+          } else {
+            console.log(this._storage.config);
+          }
+        }
         assert(condition, message) {
           assert4(condition, message);
         }
@@ -5736,23 +6173,24 @@
         }
         table(logLevel, table, columns) {
           if (table) {
-            return this._getLogFunction(logLevel, table, console.table || noop2, columns && [columns], {
+            return this._getLogFunction(logLevel, table, console.table || noop, columns && [columns], {
               tag: getTableHeader(table)
             });
           }
-          return noop2;
+          return noop;
         }
-        image({
-          logLevel,
-          priority,
-          image,
-          message = "",
-          scale: scale5 = 1
-        }) {
+        image(_ref) {
+          let {
+            logLevel,
+            priority,
+            image,
+            message = "",
+            scale: scale5 = 1
+          } = _ref;
           if (!this._shouldLog(logLevel || priority)) {
-            return noop2;
+            return noop;
           }
-          return isBrowser4 ? logImageInBrowser({
+          return isBrowser3() ? logImageInBrowser({
             image,
             message,
             scale: scale5
@@ -5762,21 +6200,6 @@
             scale: scale5
           });
         }
-        settings() {
-          if (console.table) {
-            console.table(this._storage.config);
-          } else {
-            console.log(this._storage.config);
-          }
-        }
-        get(setting) {
-          return this._storage.config[setting];
-        }
-        set(setting, value) {
-          this._storage.updateConfiguration({
-            [setting]: value
-          });
-        }
         time(logLevel, message) {
           return this._getLogFunction(logLevel, message, console.time ? console.time : console.info);
         }
@@ -5784,12 +6207,13 @@
           return this._getLogFunction(logLevel, message, console.timeEnd ? console.timeEnd : console.info);
         }
         timeStamp(logLevel, message) {
-          return this._getLogFunction(logLevel, message, console.timeStamp || noop2);
+          return this._getLogFunction(logLevel, message, console.timeStamp || noop);
         }
-        group(logLevel, message, opts = {
-          collapsed: false
-        }) {
-          opts = normalizeArguments({
+        group(logLevel, message) {
+          let opts = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {
+            collapsed: false
+          };
+          const options = normalizeArguments({
             logLevel,
             message,
             opts
@@ -5797,16 +6221,17 @@
           const {
             collapsed
           } = opts;
-          opts.method = (collapsed ? console.groupCollapsed : console.group) || console.info;
-          return this._getLogFunction(opts);
+          options.method = (collapsed ? console.groupCollapsed : console.group) || console.info;
+          return this._getLogFunction(options);
         }
-        groupCollapsed(logLevel, message, opts = {}) {
+        groupCollapsed(logLevel, message) {
+          let opts = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
           return this.group(logLevel, message, Object.assign({}, opts, {
             collapsed: true
           }));
         }
         groupEnd(logLevel) {
-          return this._getLogFunction(logLevel, "", console.groupEnd || noop2);
+          return this._getLogFunction(logLevel, "", console.groupEnd || noop);
         }
         withGroup(logLevel, message, func) {
           this.group(logLevel, message)();
@@ -5824,7 +6249,7 @@
         _shouldLog(logLevel) {
           return this.isEnabled() && this.getLevel() >= normalizeLogLevel(logLevel);
         }
-        _getLogFunction(logLevel, message, method, args = [], opts) {
+        _getLogFunction(logLevel, message, method, args, opts) {
           if (this._shouldLog(logLevel)) {
             opts = normalizeArguments({
               logLevel,
@@ -5838,61 +6263,31 @@
             opts.delta = this.getDelta();
             this._deltaTs = getHiResTimestamp2();
             const tag = opts.tag || opts.message;
-            if (opts.once) {
+            if (opts.once && tag) {
               if (!cache[tag]) {
                 cache[tag] = getHiResTimestamp2();
               } else {
-                return noop2;
+                return noop;
               }
             }
             message = decorateMessage(this.id, opts.message, opts);
             return method.bind(console, message, ...opts.args);
           }
-          return noop2;
+          return noop;
         }
       };
-      Log.VERSION = VERSION2;
-    }
-  });
-
-  // ../../node_modules/probe.gl/node_modules/@probe.gl/stats/dist/esm/utils/hi-res-timestamp.js
-  var init_hi_res_timestamp3 = __esm({
-    "../../node_modules/probe.gl/node_modules/@probe.gl/stats/dist/esm/utils/hi-res-timestamp.js"() {
-    }
-  });
-
-  // ../../node_modules/probe.gl/node_modules/@probe.gl/stats/dist/esm/lib/stat.js
-  var init_stat2 = __esm({
-    "../../node_modules/probe.gl/node_modules/@probe.gl/stats/dist/esm/lib/stat.js"() {
-      init_hi_res_timestamp3();
-    }
-  });
-
-  // ../../node_modules/probe.gl/node_modules/@probe.gl/stats/dist/esm/lib/stats.js
-  var init_stats2 = __esm({
-    "../../node_modules/probe.gl/node_modules/@probe.gl/stats/dist/esm/lib/stats.js"() {
-      init_stat2();
-    }
-  });
-
-  // ../../node_modules/probe.gl/node_modules/@probe.gl/stats/dist/esm/index.js
-  var init_esm5 = __esm({
-    "../../node_modules/probe.gl/node_modules/@probe.gl/stats/dist/esm/index.js"() {
-      init_stats2();
-      init_stat2();
-      init_hi_res_timestamp3();
+      _defineProperty(Log, "VERSION", VERSION2);
     }
   });
 
-  // ../../node_modules/probe.gl/dist/esm/index.js
-  var esm_default;
-  var init_esm6 = __esm({
-    "../../node_modules/probe.gl/dist/esm/index.js"() {
+  // ../../node_modules/@probe.gl/log/dist/index.js
+  var dist_default;
+  var init_dist3 = __esm({
+    "../../node_modules/@probe.gl/log/dist/index.js"() {
       init_log();
       init_log();
-      init_esm5();
-      esm_default = new Log({
-        id: "probe.gl"
+      dist_default = new Log({
+        id: "@probe.gl/log"
       });
     }
   });
@@ -5901,7 +6296,7 @@
   var probeLog, NullLog, ConsoleLog;
   var init_loggers = __esm({
     "../core/src/lib/loader-utils/loggers.ts"() {
-      init_esm6();
+      init_dist3();
       probeLog = new Log({ id: "loaders.gl" });
       NullLog = class {
         log() {
@@ -5945,6 +6340,7 @@
   var DEFAULT_LOADER_OPTIONS, REMOVED_LOADER_OPTIONS;
   var init_option_defaults = __esm({
     "../core/src/lib/loader-utils/option-defaults.ts"() {
+      init_src2();
       init_loggers();
       DEFAULT_LOADER_OPTIONS = {
         fetch: null,
@@ -5955,7 +6351,8 @@
         worker: true,
         maxConcurrency: 3,
         maxMobileConcurrency: 1,
-        reuseWorkers: true,
+        reuseWorkers: isBrowser,
+        _nodeWorkers: false,
         _workerType: "",
         limit: 0,
         _limitMB: 0,
@@ -5997,20 +6394,6 @@
     validateOptions(options, loaders);
     return normalizeOptionsInternal(loader, options, url);
   }
-  function getFetchFunction(options, context) {
-    const globalOptions = getGlobalLoaderOptions();
-    const fetchOptions = options || globalOptions;
-    if (typeof fetchOptions.fetch === "function") {
-      return fetchOptions.fetch;
-    }
-    if (isObject(fetchOptions.fetch)) {
-      return (url) => fetchFile(url, fetchOptions);
-    }
-    if (context?.fetch) {
-      return context?.fetch;
-    }
-    return fetchFile;
-  }
   function validateOptions(options, loaders) {
     validateOptionsObject(options, null, DEFAULT_LOADER_OPTIONS, REMOVED_LOADER_OPTIONS, loaders);
     for (const loader of loaders) {
@@ -6089,7 +6472,6 @@
   var init_option_utils = __esm({
     "../core/src/lib/loader-utils/option-utils.ts"() {
       init_is_type();
-      init_fetch_file();
       init_loggers();
       init_option_defaults();
       getGlobalLoaderOptions = () => {
@@ -6153,6 +6535,15 @@
     }
   });
 
+  // ../core/src/lib/utils/log.ts
+  var log;
+  var init_log2 = __esm({
+    "../core/src/lib/utils/log.ts"() {
+      init_dist3();
+      log = new Log({ id: "loaders.gl" });
+    }
+  });
+
   // ../core/src/lib/api/select-loader.ts
   async function selectLoader(data, loaders = [], options, context) {
     if (!validHTTPResponse(data)) {
@@ -6196,13 +6587,22 @@
     const { url, type } = getResourceUrlAndType(data);
     const testUrl = url || context?.url;
     let loader = null;
+    let reason = "";
     if (options?.mimeType) {
       loader = findLoaderByMIMEType(loaders, options?.mimeType);
+      reason = `match forced by supplied MIME type ${options?.mimeType}`;
     }
     loader = loader || findLoaderByUrl(loaders, testUrl);
+    reason = reason || (loader ? `matched url ${testUrl}` : "");
     loader = loader || findLoaderByMIMEType(loaders, type);
+    reason = reason || (loader ? `matched MIME type ${type}` : "");
     loader = loader || findLoaderByInitialBytes(loaders, data);
+    reason = reason || (loader ? `matched initial data ${getFirstCharacters(data)}` : "");
     loader = loader || findLoaderByMIMEType(loaders, options?.fallbackMimeType);
+    reason = reason || (loader ? `matched fallback MIME type ${type}` : "");
+    if (reason) {
+      log.log(1, `selectLoader selected ${loader?.name}: ${reason}.`);
+    }
     return loader;
   }
   function validHTTPResponse(data) {
@@ -6329,6 +6729,7 @@
     "../core/src/lib/api/select-loader.ts"() {
       init_src2();
       init_normalize_loader();
+      init_log2();
       init_resource_utils();
       init_register_loaders();
       init_is_type();
@@ -6411,7 +6812,7 @@
         if (done) {
           return;
         }
-        yield toArrayBuffer(value);
+        yield toArrayBuffer2(value);
       }
     } catch (error) {
       reader.releaseLock();
@@ -6419,7 +6820,7 @@
   }
   async function* makeNodeStreamIterator(stream, options) {
     for await (const chunk of stream) {
-      yield toArrayBuffer(chunk);
+      yield toArrayBuffer2(chunk);
     }
   }
   var init_make_stream_iterator = __esm({
@@ -6520,6 +6921,29 @@
     }
   });
 
+  // ../core/src/lib/loader-utils/get-fetch-function.ts
+  function getFetchFunction(options, context) {
+    const globalOptions = getGlobalLoaderOptions();
+    const fetchOptions = options || globalOptions;
+    if (typeof fetchOptions.fetch === "function") {
+      return fetchOptions.fetch;
+    }
+    if (isObject(fetchOptions.fetch)) {
+      return (url) => fetchFile(url, fetchOptions);
+    }
+    if (context?.fetch) {
+      return context?.fetch;
+    }
+    return fetchFile;
+  }
+  var init_get_fetch_function = __esm({
+    "../core/src/lib/loader-utils/get-fetch-function.ts"() {
+      init_is_type();
+      init_fetch_file();
+      init_option_utils();
+    }
+  });
+
   // ../core/src/lib/loader-utils/loader-context.ts
   function getLoaderContext(context, options, previousContext = null) {
     if (previousContext) {
@@ -6550,7 +6974,7 @@
   }
   var init_loader_context = __esm({
     "../core/src/lib/loader-utils/loader-context.ts"() {
-      init_option_utils();
+      init_get_fetch_function();
     }
   });
 
@@ -6577,6 +7001,12 @@
   }
   async function parseWithLoader(loader, data, options, context) {
     validateWorkerVersion(loader);
+    if (isResponse(data)) {
+      const response = data;
+      const { ok, redirected, status, statusText, type, url } = response;
+      const headers = Object.fromEntries(response.headers.entries());
+      context.response = { headers, ok, redirected, status, statusText, type, url };
+    }
     data = await getArrayBufferOrStringFromData(data, loader, options);
     if (loader.parseTextSync && typeof data === "string") {
       options.dataType = "text";
@@ -6599,6 +7029,7 @@
       init_src();
       init_src2();
       init_normalize_loader();
+      init_is_type();
       init_option_utils();
       init_get_data();
       init_loader_context();
@@ -6609,12 +7040,17 @@
 
   // ../core/src/lib/api/load.ts
   async function load(url, loaders, options, context) {
+    let resolvedLoaders;
+    let resolvedOptions;
     if (!Array.isArray(loaders) && !isLoaderObject(loaders)) {
+      resolvedLoaders = [];
+      resolvedOptions = loaders;
       context = void 0;
-      options = loaders;
-      loaders = void 0;
+    } else {
+      resolvedLoaders = loaders;
+      resolvedOptions = options;
     }
-    const fetch2 = getFetchFunction(options);
+    const fetch2 = getFetchFunction(resolvedOptions);
     let data = url;
     if (typeof url === "string") {
       data = await fetch2(url);
@@ -6622,13 +7058,13 @@
     if (isBlob(url)) {
       data = await fetch2(url);
     }
-    return await parse(data, loaders, options);
+    return Array.isArray(resolvedLoaders) ? await parse(data, resolvedLoaders, resolvedOptions) : await parse(data, resolvedLoaders, resolvedOptions);
   }
   var init_load = __esm({
     "../core/src/lib/api/load.ts"() {
       init_is_type();
       init_normalize_loader();
-      init_option_utils();
+      init_get_fetch_function();
       init_parse();
     }
   });
@@ -6700,6 +7136,22 @@
     }
     throw new Error("3D Tile: boundingVolume must contain a sphere, region, or box");
   }
+  function getCartographicBounds(boundingVolumeHeader, boundingVolume) {
+    if (boundingVolumeHeader.box) {
+      return orientedBoundingBoxToCartographicBounds(boundingVolume);
+    }
+    if (boundingVolumeHeader.region) {
+      const [west, south, east, north, minHeight, maxHeight] = boundingVolumeHeader.region;
+      return [
+        [degrees(west), degrees(south), minHeight],
+        [degrees(east), degrees(north), maxHeight]
+      ];
+    }
+    if (boundingVolumeHeader.sphere) {
+      return boundingSphereToCartographicBounds(boundingVolume);
+    }
+    throw new Error("Unkown boundingVolume type");
+  }
   function createBox(box, transform, result) {
     const center = new Vector3(box[0], box[1], box[2]);
     transform.transform(center, center);
@@ -6755,13 +7207,79 @@
     }
     return new BoundingSphere(center, radius);
   }
-  var scratchScale, scratchNorthWest, scratchSouthEast;
+  function orientedBoundingBoxToCartographicBounds(boundingVolume) {
+    const result = emptyCartographicBounds();
+    const { halfAxes } = boundingVolume;
+    const xAxis = new Vector3(halfAxes.getColumn(0));
+    const yAxis = new Vector3(halfAxes.getColumn(1));
+    const zAxis = new Vector3(halfAxes.getColumn(2));
+    for (let x = 0; x < 2; x++) {
+      for (let y = 0; y < 2; y++) {
+        for (let z = 0; z < 2; z++) {
+          scratchPoint.copy(boundingVolume.center);
+          scratchPoint.add(xAxis);
+          scratchPoint.add(yAxis);
+          scratchPoint.add(zAxis);
+          addToCartographicBounds(result, scratchPoint);
+          zAxis.negate();
+        }
+        yAxis.negate();
+      }
+      xAxis.negate();
+    }
+    return result;
+  }
+  function boundingSphereToCartographicBounds(boundingVolume) {
+    const result = emptyCartographicBounds();
+    const { center, radius } = boundingVolume;
+    const point = Ellipsoid.WGS84.scaleToGeodeticSurface(center, scratchPoint);
+    let zAxis;
+    if (point) {
+      zAxis = Ellipsoid.WGS84.geodeticSurfaceNormal(point);
+    } else {
+      zAxis = new Vector3(0, 0, 1);
+    }
+    let xAxis = new Vector3(zAxis[2], -zAxis[1], 0);
+    if (xAxis.len() > 0) {
+      xAxis.normalize();
+    } else {
+      xAxis = new Vector3(0, 1, 0);
+    }
+    const yAxis = xAxis.clone().cross(zAxis);
+    for (const axis of [xAxis, yAxis, zAxis]) {
+      scratchScale.copy(axis).scale(radius);
+      for (let dir = 0; dir < 2; dir++) {
+        scratchPoint.copy(center);
+        scratchPoint.add(scratchScale);
+        addToCartographicBounds(result, scratchPoint);
+        scratchScale.negate();
+      }
+    }
+    return result;
+  }
+  function emptyCartographicBounds() {
+    return [
+      [Infinity, Infinity, Infinity],
+      [-Infinity, -Infinity, -Infinity]
+    ];
+  }
+  function addToCartographicBounds(target, cartesian) {
+    Ellipsoid.WGS84.cartesianToCartographic(cartesian, scratchPoint);
+    target[0][0] = Math.min(target[0][0], scratchPoint[0]);
+    target[0][1] = Math.min(target[0][1], scratchPoint[1]);
+    target[0][2] = Math.min(target[0][2], scratchPoint[2]);
+    target[1][0] = Math.max(target[1][0], scratchPoint[0]);
+    target[1][1] = Math.max(target[1][1], scratchPoint[1]);
+    target[1][2] = Math.max(target[1][2], scratchPoint[2]);
+  }
+  var scratchPoint, scratchScale, scratchNorthWest, scratchSouthEast;
   var init_bounding_volume = __esm({
     "src/tileset/helpers/bounding-volume.ts"() {
       init_esm();
-      init_esm4();
+      init_esm3();
       init_esm2();
       init_src2();
+      scratchPoint = new Vector3();
       scratchScale = new Vector3();
       scratchNorthWest = new Vector3();
       scratchSouthEast = new Vector3();
@@ -6826,39 +7344,43 @@
     return "OUT";
   }
   function getProjectedRadius(tile, frameState) {
-    const originalViewport = frameState.viewport;
-    const ViewportClass = originalViewport.constructor;
-    const { longitude, latitude, height, width, bearing, zoom } = originalViewport;
-    const viewport = new ViewportClass({ longitude, latitude, height, width, bearing, zoom, pitch: 0 });
+    const { topDownViewport: viewport } = frameState;
     const mbsLat = tile.header.mbs[1];
     const mbsLon = tile.header.mbs[0];
     const mbsZ = tile.header.mbs[2];
     const mbsR = tile.header.mbs[3];
     const mbsCenterCartesian = [...tile.boundingVolume.center];
     const cameraPositionCartographic = viewport.unprojectPosition(viewport.cameraPosition);
-    const cameraPositionCartesian = Ellipsoid.WGS84.cartographicToCartesian(cameraPositionCartographic, new Vector3());
-    const toEye = new Vector3(cameraPositionCartesian).subtract(mbsCenterCartesian).normalize();
-    const enuToCartesianMatrix = new Matrix4();
+    Ellipsoid.WGS84.cartographicToCartesian(cameraPositionCartographic, cameraPositionCartesian);
+    toEye.copy(cameraPositionCartesian).subtract(mbsCenterCartesian).normalize();
     Ellipsoid.WGS84.eastNorthUpToFixedFrame(mbsCenterCartesian, enuToCartesianMatrix);
-    const cartesianToEnuMatrix = new Matrix4(enuToCartesianMatrix).invert();
-    const cameraPositionEnu = new Vector3(cameraPositionCartesian).transform(cartesianToEnuMatrix);
+    cartesianToEnuMatrix.copy(enuToCartesianMatrix).invert();
+    cameraPositionEnu.copy(cameraPositionCartesian).transform(cartesianToEnuMatrix);
     const projection = Math.sqrt(cameraPositionEnu[0] * cameraPositionEnu[0] + cameraPositionEnu[1] * cameraPositionEnu[1]);
     const extraZ = projection * projection / cameraPositionEnu[2];
-    const extraVertexEnu = new Vector3([cameraPositionEnu[0], cameraPositionEnu[1], extraZ]);
+    extraVertexEnu.copy([cameraPositionEnu[0], cameraPositionEnu[1], extraZ]);
     const extraVertexCartesian = extraVertexEnu.transform(enuToCartesianMatrix);
-    const extraVectorCartesian = new Vector3(extraVertexCartesian).subtract(mbsCenterCartesian).normalize();
+    const extraVectorCartesian = extraVertexCartesian.subtract(mbsCenterCartesian).normalize();
     const radiusVector = toEye.cross(extraVectorCartesian).normalize().scale(mbsR);
-    const sphereMbsBorderVertexCartesian = new Vector3(mbsCenterCartesian).add(radiusVector);
+    const sphereMbsBorderVertexCartesian = radiusVector.add(mbsCenterCartesian);
     const sphereMbsBorderVertexCartographic = Ellipsoid.WGS84.cartesianToCartographic(sphereMbsBorderVertexCartesian);
     const projectedOrigin = viewport.project([mbsLon, mbsLat, mbsZ]);
     const projectedMbsBorderVertex = viewport.project(sphereMbsBorderVertexCartographic);
-    const projectedRadius = new Vector3(projectedOrigin).subtract(projectedMbsBorderVertex).magnitude();
+    const projectedRadius = projectedOriginVector.copy(projectedOrigin).subtract(projectedMbsBorderVertex).magnitude();
     return projectedRadius;
   }
+  var cameraPositionCartesian, toEye, cameraPositionEnu, extraVertexEnu, projectedOriginVector, enuToCartesianMatrix, cartesianToEnuMatrix;
   var init_i3s_lod = __esm({
     "src/tileset/helpers/i3s-lod.ts"() {
       init_esm();
       init_esm2();
+      cameraPositionCartesian = new Vector3();
+      toEye = new Vector3();
+      cameraPositionEnu = new Vector3();
+      extraVertexEnu = new Vector3();
+      projectedOriginVector = new Vector3();
+      enuToCartesianMatrix = new Matrix4();
+      cartesianToEnuMatrix = new Matrix4();
     }
   });
 
@@ -6962,10 +7484,10 @@
     }
   });
 
-  // src/tileset/traversers/tileset-traverser.ts
+  // src/tileset/tileset-traverser.ts
   var DEFAULT_PROPS3, TilesetTraverser;
   var init_tileset_traverser = __esm({
-    "src/tileset/traversers/tileset-traverser.ts"() {
+    "src/tileset/tileset-traverser.ts"() {
       init_managed_array();
       init_constants3();
       DEFAULT_PROPS3 = {
@@ -6980,6 +7502,8 @@
       };
       TilesetTraverser = class {
         constructor(options) {
+          this.lastUpdate = new Date().getTime();
+          this.updateDebounceTime = 1e3;
           this.options = { ...DEFAULT_PROPS3, ...options };
           this._traversalStack = new ManagedArray();
           this._emptyTraversalStack = new ManagedArray();
@@ -6989,6 +7513,9 @@
           this.requestedTiles = {};
           this.emptyTiles = {};
         }
+        traversalFinished(frameState) {
+          return true;
+        }
         traverse(root, frameState, options) {
           this.root = root;
           this.options = { ...this.options, ...options };
@@ -7036,7 +7563,11 @@
             this.touchTile(tile, frameState);
             tile._shouldRefine = shouldRefine && parentRefines;
           }
-          this.options.onTraversalEnd(frameState);
+          const newTime = new Date().getTime();
+          if (this.traversalFinished(frameState) || newTime - this.lastUpdate > this.updateDebounceTime) {
+            this.lastUpdate = newTime;
+            this.options.onTraversalEnd(frameState);
+          }
         }
         updateChildTiles(tile, frameState) {
           const children = tile.children;
@@ -7188,11 +7719,11 @@
   function defined3(x) {
     return x !== void 0 && x !== null;
   }
-  var scratchVector9, TileHeader;
+  var scratchVector9, Tile3D;
   var init_tile_3d = __esm({
     "src/tileset/tile-3d.ts"() {
       init_esm();
-      init_esm4();
+      init_esm3();
       init_src3();
       init_constants3();
       init_bounding_volume();
@@ -7201,7 +7732,7 @@
       init_d_tiles_options();
       init_tileset_traverser();
       scratchVector9 = new Vector3();
-      TileHeader = class {
+      Tile3D = class {
         constructor(tileset, header, parentHeader, extendedId = "") {
           this.header = header;
           this.tileset = tileset;
@@ -7251,6 +7782,7 @@
           this._lodJudge = null;
           this._expireDate = null;
           this._expiredContent = null;
+          this.implicitTiling = null;
           Object.seal(this);
         }
         destroy() {
@@ -7292,6 +7824,18 @@
         get contentFailed() {
           return this.contentState === TILE_CONTENT_STATE.FAILED;
         }
+        get distanceToCamera() {
+          return this._distanceToCamera;
+        }
+        get screenSpaceError() {
+          return this._screenSpaceError;
+        }
+        get boundingBox() {
+          if (!this._boundingBox) {
+            this._boundingBox = getCartographicBounds(this.header.boundingVolume, this.boundingVolume);
+          }
+          return this._boundingBox;
+        }
         getScreenSpaceError(frameState, useParentLodMetric) {
           switch (this.tileset.type) {
             case TILESET_TYPE.I3S:
@@ -7302,6 +7846,9 @@
               throw new Error("Unsupported tileset type");
           }
         }
+        unselect() {
+          this._selectedFrame = 0;
+        }
         _getPriority() {
           const traverser = this.tileset._traverser;
           const { skipLevelOfDetail } = traverser.options;
@@ -7530,8 +8077,20 @@
             case "i3s":
               return {
                 ...this.tileset.options.i3s,
-                tile: this.header,
-                tileset: this.tileset.tileset,
+                _tileOptions: {
+                  attributeUrls: this.header.attributeUrls,
+                  textureUrl: this.header.textureUrl,
+                  textureFormat: this.header.textureFormat,
+                  textureLoaderOptions: this.header.textureLoaderOptions,
+                  materialDefinition: this.header.materialDefinition,
+                  isDracoGeometry: this.header.isDracoGeometry,
+                  mbs: this.header.mbs
+                },
+                _tilesetOptions: {
+                  store: this.tileset.tileset.store,
+                  attributeStorageInfo: this.tileset.tileset.attributeStorageInfo,
+                  fields: this.tileset.tileset.fields
+                },
                 isTileHeader: false
               };
             case "3d-tiles":
@@ -7544,10 +8103,10 @@
     }
   });
 
-  // src/tileset/traversers/tileset-3d-traverser.ts
+  // src/tileset/format-3d-tiles/tileset-3d-traverser.ts
   var Tileset3DTraverser;
   var init_tileset_3d_traverser = __esm({
-    "src/tileset/traversers/tileset-3d-traverser.ts"() {
+    "src/tileset/format-3d-tiles/tileset-3d-traverser.ts"() {
       init_constants3();
       init_tileset_traverser();
       Tileset3DTraverser = class extends TilesetTraverser {
@@ -7590,10 +8149,41 @@
     }
   });
 
-  // src/tileset/traversers/i3s-tile-manager.ts
+  // src/tileset/format-i3s/i3s-pending-tiles-register.ts
+  var I3SPendingTilesRegister;
+  var init_i3s_pending_tiles_register = __esm({
+    "src/tileset/format-i3s/i3s-pending-tiles-register.ts"() {
+      I3SPendingTilesRegister = class {
+        constructor() {
+          this.frameNumberMap = new Map();
+        }
+        register(viewportId, frameNumber) {
+          const viewportMap = this.frameNumberMap.get(viewportId) || new Map();
+          const oldCount = viewportMap.get(frameNumber) || 0;
+          viewportMap.set(frameNumber, oldCount + 1);
+          this.frameNumberMap.set(viewportId, viewportMap);
+        }
+        deregister(viewportId, frameNumber) {
+          const viewportMap = this.frameNumberMap.get(viewportId);
+          if (!viewportMap) {
+            return;
+          }
+          const oldCount = viewportMap.get(frameNumber) || 1;
+          viewportMap.set(frameNumber, oldCount - 1);
+        }
+        isZero(viewportId, frameNumber) {
+          const count = this.frameNumberMap.get(viewportId)?.get(frameNumber) || 0;
+          return count === 0;
+        }
+      };
+    }
+  });
+
+  // src/tileset/format-i3s/i3s-tile-manager.ts
   var STATUS, I3STileManager;
   var init_i3s_tile_manager = __esm({
-    "src/tileset/traversers/i3s-tile-manager.ts"() {
+    "src/tileset/format-i3s/i3s-tile-manager.ts"() {
+      init_i3s_pending_tiles_register();
       STATUS = {
         REQUESTED: "REQUESTED",
         COMPLETED: "COMPLETED",
@@ -7601,36 +8191,65 @@
       };
       I3STileManager = class {
         constructor() {
+          this.pendingTilesRegister = new I3SPendingTilesRegister();
           this._statusMap = {};
         }
         add(request, key, callback, frameState) {
           if (!this._statusMap[key]) {
+            const {
+              frameNumber,
+              viewport: { id }
+            } = frameState;
             this._statusMap[key] = { request, callback, key, frameState, status: STATUS.REQUESTED };
+            this.pendingTilesRegister.register(id, frameNumber);
             request().then((data) => {
               this._statusMap[key].status = STATUS.COMPLETED;
+              const {
+                frameNumber: actualFrameNumber,
+                viewport: { id: id2 }
+              } = this._statusMap[key].frameState;
+              this.pendingTilesRegister.deregister(id2, actualFrameNumber);
               this._statusMap[key].callback(data, frameState);
             }).catch((error) => {
               this._statusMap[key].status = STATUS.ERROR;
+              const {
+                frameNumber: actualFrameNumber,
+                viewport: { id: id2 }
+              } = this._statusMap[key].frameState;
+              this.pendingTilesRegister.deregister(id2, actualFrameNumber);
               callback(error);
             });
           }
         }
         update(key, frameState) {
           if (this._statusMap[key]) {
+            const {
+              frameNumber,
+              viewport: { id }
+            } = this._statusMap[key].frameState;
+            this.pendingTilesRegister.deregister(id, frameNumber);
+            const {
+              frameNumber: newFrameNumber,
+              viewport: { id: newViewportId }
+            } = frameState;
+            this.pendingTilesRegister.register(newViewportId, newFrameNumber);
             this._statusMap[key].frameState = frameState;
           }
         }
         find(key) {
           return this._statusMap[key];
         }
+        hasPendingTiles(viewportId, frameNumber) {
+          return !this.pendingTilesRegister.isZero(viewportId, frameNumber);
+        }
       };
     }
   });
 
-  // src/tileset/traversers/i3s-tileset-traverser.ts
+  // src/tileset/format-i3s/i3s-tileset-traverser.ts
   var I3STilesetTraverser;
   var init_i3s_tileset_traverser = __esm({
-    "src/tileset/traversers/i3s-tileset-traverser.ts"() {
+    "src/tileset/format-i3s/i3s-tileset-traverser.ts"() {
       init_src3();
       init_tileset_traverser();
       init_i3s_lod();
@@ -7641,6 +8260,9 @@
           super(options);
           this._tileManager = new I3STileManager();
         }
+        traversalFinished(frameState) {
+          return !this._tileManager.hasPendingTiles(frameState.viewport.id, this._frameNumber || 0);
+        }
         shouldRefine(tile, frameState) {
           tile._lodJudge = getLodStatus(tile, frameState);
           return tile._lodJudge === "DIG";
@@ -7676,18 +8298,17 @@
             ...tileset.loadOptions,
             i3s: {
               ...tileset.loadOptions.i3s,
-              isTileHeader: true,
-              loadContent: false
+              isTileHeader: true
             }
           };
           return await load(nodeUrl, loader, options);
         }
         _onTileLoad(header, tile, extendedId) {
-          const childTile = new TileHeader(tile.tileset, header, tile, extendedId);
+          const childTile = new Tile3D(tile.tileset, header, tile, extendedId);
           tile.children.push(childTile);
           const frameState = this._tileManager.find(childTile.id).frameState;
           this.updateTile(childTile, frameState);
-          if (this._frameNumber === frameState.frameNumber) {
+          if (this._frameNumber === frameState.frameNumber && (this.traversalFinished(frameState) || new Date().getTime() - this.lastUpdate > this.updateDebounceTime)) {
             this.executeTraversal(childTile, frameState);
           }
         }
@@ -7715,17 +8336,17 @@
     "src/tileset/tileset-3d.ts"() {
       init_esm();
       init_esm2();
-      init_esm3();
+      init_dist();
       init_src2();
       init_tileset_cache();
       init_transform_utils();
       init_frame_state();
       init_zoom();
       init_tile_3d();
-      init_tileset_3d_traverser();
+      init_constants3();
       init_tileset_traverser();
+      init_tileset_3d_traverser();
       init_i3s_tileset_traverser();
-      init_constants3();
       DEFAULT_PROPS4 = {
         description: "",
         ellipsoid: Ellipsoid.WGS84,
@@ -7733,6 +8354,8 @@
         throttleRequests: true,
         maxRequests: 64,
         maximumMemoryUsage: 32,
+        maximumTilesSelected: 0,
+        debounceTime: 0,
         onTileLoad: () => {
         },
         onTileUnload: () => {
@@ -7759,10 +8382,12 @@
       TILES_LOADING = "Tiles Loading";
       TILES_UNLOADED = "Tiles Unloaded";
       TILES_LOAD_FAILED = "Failed Tile Loads";
-      POINTS_COUNT = "Points";
+      POINTS_COUNT = "Points/Vertices";
       TILES_GPU_MEMORY = "Tile Memory Use";
       Tileset3D = class {
         constructor(json, options) {
+          this.contentFormats = { draco: false, meshopt: false, dds: false, ktx2: false };
+          this.updatePromise = null;
           assert2(json);
           this.options = { ...DEFAULT_PROPS4, ...options };
           this.tileset = json;
@@ -7810,13 +8435,13 @@
           this.asset = {};
           this.credits = {};
           this.description = this.options.description || "";
-          this._initializeTileSet(json);
+          this.tilesetInitializationPromise = this._initializeTileSet(json);
         }
         destroy() {
           this._destroy();
         }
         isLoaded() {
-          return this._pendingCount === 0 && this._frameNumber !== 0;
+          return this._pendingCount === 0 && this._frameNumber !== 0 && this._requestedTiles.length === 0;
         }
         get tiles() {
           return Object.values(this._tiles);
@@ -7846,26 +8471,49 @@
         hasExtension(extensionName) {
           return Boolean(this._extensionsUsed && this._extensionsUsed.indexOf(extensionName) > -1);
         }
-        update(viewports) {
+        update(viewports = null) {
+          this.tilesetInitializationPromise.then(() => {
+            if (!viewports && this.lastUpdatedVieports) {
+              viewports = this.lastUpdatedVieports;
+            } else {
+              this.lastUpdatedVieports = viewports;
+            }
+            if (viewports) {
+              this.doUpdate(viewports);
+            }
+          });
+        }
+        async selectTiles(viewports = null) {
+          await this.tilesetInitializationPromise;
+          if (viewports) {
+            this.lastUpdatedVieports = viewports;
+          }
+          if (!this.updatePromise) {
+            this.updatePromise = new Promise((resolve2) => {
+              setTimeout(() => {
+                if (this.lastUpdatedVieports) {
+                  this.doUpdate(this.lastUpdatedVieports);
+                }
+                resolve2(this._frameNumber);
+                this.updatePromise = null;
+              }, this.options.debounceTime);
+            });
+          }
+          return this.updatePromise;
+        }
+        doUpdate(viewports) {
           if ("loadTiles" in this.options && !this.options.loadTiles) {
             return;
           }
           if (this.traverseCounter > 0) {
             return;
           }
-          if (!viewports && this.lastUpdatedVieports) {
-            viewports = this.lastUpdatedVieports;
-          } else {
-            this.lastUpdatedVieports = viewports;
-          }
-          if (!(viewports instanceof Array)) {
-            viewports = [viewports];
-          }
+          const preparedViewports = viewports instanceof Array ? viewports : [viewports];
           this._cache.reset();
           this._frameNumber++;
-          this.traverseCounter = viewports.length;
+          this.traverseCounter = preparedViewports.length;
           const viewportsToTraverse = [];
-          for (const viewport of viewports) {
+          for (const viewport of preparedViewports) {
             const id = viewport.id;
             if (this._needTraverse(id)) {
               viewportsToTraverse.push(id);
@@ -7873,7 +8521,7 @@
               this.traverseCounter--;
             }
           }
-          for (const viewport of viewports) {
+          for (const viewport of preparedViewports) {
             const id = viewport.id;
             if (!this.roots[id]) {
               this.roots[id] = this._initializeTileHeaders(this.tileset, null);
@@ -7902,7 +8550,11 @@
           }
           const currentFrameStateData = this.frameStateData[id];
           const selectedTiles = Object.values(this._traverser.selectedTiles);
-          currentFrameStateData.selectedTiles = selectedTiles;
+          const [filteredSelectedTiles, unselectedTiles] = limitSelectedTiles(selectedTiles, frameState, this.options.maximumTilesSelected);
+          currentFrameStateData.selectedTiles = filteredSelectedTiles;
+          for (const tile of unselectedTiles) {
+            tile.unselect();
+          }
           currentFrameStateData._requestedTiles = Object.values(this._traverser.requestedTiles);
           currentFrameStateData._emptyTiles = Object.values(this._traverser.emptyTiles);
           this.traverseCounter--;
@@ -7957,6 +8609,8 @@
               tilesRenderable++;
               if (tile.content.pointCount) {
                 pointsRenderable += tile.content.pointCount;
+              } else {
+                pointsRenderable += tile.content.vertexCount;
               }
             }
           }
@@ -7964,17 +8618,43 @@
           this.stats.get(TILES_RENDERABLE).count = tilesRenderable;
           this.stats.get(POINTS_COUNT).count = pointsRenderable;
         }
-        _initializeTileSet(tilesetJson) {
+        async _initializeTileSet(tilesetJson) {
+          if (this.type === TILESET_TYPE.I3S) {
+            this.calculateViewPropsI3S();
+            tilesetJson.root = await tilesetJson.root;
+          }
           this.root = this._initializeTileHeaders(tilesetJson, null);
           if (this.type === TILESET_TYPE.TILES3D) {
-            this._initializeCesiumTileset(tilesetJson);
+            this._initializeTiles3DTileset(tilesetJson);
+            this.calculateViewPropsTiles3D();
           }
           if (this.type === TILESET_TYPE.I3S) {
             this._initializeI3STileset();
           }
-          this._calculateViewProps();
         }
-        _calculateViewProps() {
+        calculateViewPropsI3S() {
+          const fullExtent = this.tileset.fullExtent;
+          if (fullExtent) {
+            const { xmin, xmax, ymin, ymax, zmin, zmax } = fullExtent;
+            this.cartographicCenter = new Vector3(xmin + (xmax - xmin) / 2, ymin + (ymax - ymin) / 2, zmin + (zmax - zmin) / 2);
+            this.cartesianCenter = Ellipsoid.WGS84.cartographicToCartesian(this.cartographicCenter, new Vector3());
+            this.zoom = getZoomFromFullExtent(fullExtent, this.cartographicCenter, this.cartesianCenter);
+            return;
+          }
+          const extent = this.tileset.store?.extent;
+          if (extent) {
+            const [xmin, ymin, xmax, ymax] = extent;
+            this.cartographicCenter = new Vector3(xmin + (xmax - xmin) / 2, ymin + (ymax - ymin) / 2, 0);
+            this.cartesianCenter = Ellipsoid.WGS84.cartographicToCartesian(this.cartographicCenter, new Vector3());
+            this.zoom = getZoomFromExtent(extent, this.cartographicCenter, this.cartesianCenter);
+            return;
+          }
+          console.warn("Extent is not defined in the tileset header");
+          this.cartographicCenter = new Vector3();
+          this.zoom = 1;
+          return;
+        }
+        calculateViewPropsTiles3D() {
           const root = this.root;
           assert2(root);
           const { center } = root.boundingVolume;
@@ -7984,9 +8664,13 @@
             this.zoom = 1;
             return;
           }
-          this.cartographicCenter = Ellipsoid.WGS84.cartesianToCartographic(center, new Vector3());
+          if (center[0] !== 0 || center[1] !== 0 || center[2] !== 0) {
+            this.cartographicCenter = Ellipsoid.WGS84.cartesianToCartographic(center, new Vector3());
+          } else {
+            this.cartographicCenter = new Vector3(0, 0, -Ellipsoid.WGS84.radii[0]);
+          }
           this.cartesianCenter = center;
-          this.zoom = getZoomFromBoundingVolume(root.boundingVolume);
+          this.zoom = getZoomFromBoundingVolume(root.boundingVolume, this.cartographicCenter);
         }
         _initializeStats() {
           this.stats.get(TILES_TOTAL);
@@ -7997,11 +8681,11 @@
           this.stats.get(TILES_LOADED);
           this.stats.get(TILES_UNLOADED);
           this.stats.get(TILES_LOAD_FAILED);
-          this.stats.get(POINTS_COUNT, "memory");
+          this.stats.get(POINTS_COUNT);
           this.stats.get(TILES_GPU_MEMORY, "memory");
         }
         _initializeTileHeaders(tilesetJson, parentTileHeader) {
-          const rootTile = new TileHeader(this, tilesetJson.root, parentTileHeader);
+          const rootTile = new Tile3D(this, tilesetJson.root, parentTileHeader);
           if (parentTileHeader) {
             parentTileHeader.children.push(rootTile);
             rootTile.depth = parentTileHeader.depth + 1;
@@ -8014,7 +8698,7 @@
               this.stats.get(TILES_TOTAL).incrementCount();
               const children = tile.header.children || [];
               for (const childHeader of children) {
-                const childTile = new TileHeader(this, childHeader, tile);
+                const childTile = new Tile3D(this, childHeader, tile);
                 tile.children.push(childTile);
                 childTile.depth = tile.depth + 1;
                 stack.push(childTile);
@@ -8067,12 +8751,45 @@
           if (!loaded) {
             return;
           }
+          if (this.type === TILESET_TYPE.I3S) {
+            const nodesInNodePages = this.tileset?.nodePagesTile?.nodesInNodePages || 0;
+            this.stats.get(TILES_TOTAL).reset();
+            this.stats.get(TILES_TOTAL).addCount(nodesInNodePages);
+          }
           if (tile && tile.content) {
             calculateTransformProps(tile, tile.content);
           }
+          this.updateContentTypes(tile);
           this._addTileToCache(tile);
           this.options.onTileLoad(tile);
         }
+        updateContentTypes(tile) {
+          if (this.type === TILESET_TYPE.I3S) {
+            if (tile.header.isDracoGeometry) {
+              this.contentFormats.draco = true;
+            }
+            switch (tile.header.textureFormat) {
+              case "dds":
+                this.contentFormats.dds = true;
+                break;
+              case "ktx2":
+                this.contentFormats.ktx2 = true;
+                break;
+              default:
+            }
+          } else if (this.type === TILESET_TYPE.TILES3D) {
+            const { extensionsRemoved = [] } = tile.content?.gltf || {};
+            if (extensionsRemoved.includes("KHR_draco_mesh_compression")) {
+              this.contentFormats.draco = true;
+            }
+            if (extensionsRemoved.includes("EXT_meshopt_compression")) {
+              this.contentFormats.meshopt = true;
+            }
+            if (extensionsRemoved.includes("KHR_texture_basisu")) {
+              this.contentFormats.ktx2 = true;
+            }
+          }
+        }
         _onStartTileLoading() {
           this._pendingCount++;
           this.stats.get(TILES_LOADING).incrementCount();
@@ -8132,7 +8849,7 @@
           this._unloadTile(tile);
           tile.destroy();
         }
-        _initializeCesiumTileset(tilesetJson) {
+        _initializeTiles3DTileset(tilesetJson) {
           this.asset = tilesetJson.asset;
           if (!this.asset) {
             throw new Error("Tileset must have an asset property.");
@@ -8169,7 +8886,7 @@
     TILE_CONTENT_STATE: () => TILE_CONTENT_STATE,
     TILE_REFINEMENT: () => TILE_REFINEMENT,
     TILE_TYPE: () => TILE_TYPE,
-    Tile3D: () => TileHeader,
+    Tile3D: () => Tile3D,
     Tileset3D: () => Tileset3D,
     TilesetCache: () => TilesetCache,
     TilesetTraverser: () => TilesetTraverser,
@@ -8194,10 +8911,10 @@
 
   // src/bundle.ts
   var require_bundle = __commonJS({
-    "src/bundle.ts"(exports, module2) {
+    "src/bundle.ts"(exports, module) {
       var moduleExports = (init_src4(), src_exports);
       globalThis.loaders = globalThis.loaders || {};
-      module2.exports = Object.assign(globalThis.loaders, moduleExports);
+      module.exports = Object.assign(globalThis.loaders, moduleExports);
     }
   });
   require_bundle();