@loaders.gl/3d-tiles 3.4.0-alpha.1 → 3.4.0-alpha.3

package/dist/dist.min.js

@@ -119,8 +119,8 @@
           };
           this.name = jobName;
           this.workerThread = workerThread;
-          this.result = new Promise((resolve, reject) => {
-            this._resolve = resolve;
+          this.result = new Promise((resolve2, reject) => {
+            this._resolve = resolve2;
             this._reject = reject;
           });
         }
@@ -751,46 +751,7 @@
     }
   });
 
-  // ../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"() {
-    }
-  });
-
   // ../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) {
@@ -823,7 +784,6 @@
   }
   var init_array_buffer_utils = __esm({
     "../loader-utils/src/lib/binary-utils/array-buffer-utils.ts"() {
-      init_buffer_utils();
     }
   });
 
@@ -851,34 +811,7 @@
     }
   });
 
-  // ../loader-utils/src/lib/binary-utils/binary-copy-utils.ts
-  function copyPaddedArrayBufferToDataView(dataView, byteOffset, sourceBuffer, padding) {
-    const paddedLength = padToNBytes(sourceBuffer.byteLength, padding);
-    const padLength = paddedLength - sourceBuffer.byteLength;
-    if (dataView) {
-      const targetArray = new Uint8Array(dataView.buffer, dataView.byteOffset + byteOffset, sourceBuffer.byteLength);
-      const sourceArray = new Uint8Array(sourceBuffer);
-      targetArray.set(sourceArray);
-      for (let i2 = 0; i2 < padLength; ++i2) {
-        dataView.setUint8(byteOffset + sourceBuffer.byteLength + i2, 32);
-      }
-    }
-    byteOffset += paddedLength;
-    return byteOffset;
-  }
-  function copyPaddedStringToDataView(dataView, byteOffset, string, padding) {
-    const textEncoder = new TextEncoder();
-    const stringBuffer = textEncoder.encode(string);
-    byteOffset = copyPaddedArrayBufferToDataView(dataView, byteOffset, stringBuffer, padding);
-    return byteOffset;
-  }
-  var init_binary_copy_utils = __esm({
-    "../loader-utils/src/lib/binary-utils/binary-copy-utils.ts"() {
-      init_memory_copy_utils();
-    }
-  });
-
-  // ../loader-utils/src/lib/binary-utils/encode-utils.ts
+  // ../loader-utils/src/lib/binary-utils/dataview-copy-utils.ts
   function padStringToByteAlignment(string, byteAlignment) {
     const length4 = string.length;
     const paddedLength = Math.ceil(length4 / byteAlignment) * byteAlignment;
@@ -905,8 +838,29 @@
     }
     return byteOffset + byteLength;
   }
-  var init_encode_utils = __esm({
-    "../loader-utils/src/lib/binary-utils/encode-utils.ts"() {
+  function copyPaddedArrayBufferToDataView(dataView, byteOffset, sourceBuffer, padding) {
+    const paddedLength = padToNBytes(sourceBuffer.byteLength, padding);
+    const padLength = paddedLength - sourceBuffer.byteLength;
+    if (dataView) {
+      const targetArray = new Uint8Array(dataView.buffer, dataView.byteOffset + byteOffset, sourceBuffer.byteLength);
+      const sourceArray = new Uint8Array(sourceBuffer);
+      targetArray.set(sourceArray);
+      for (let i2 = 0; i2 < padLength; ++i2) {
+        dataView.setUint8(byteOffset + sourceBuffer.byteLength + i2, 32);
+      }
+    }
+    byteOffset += paddedLength;
+    return byteOffset;
+  }
+  function copyPaddedStringToDataView(dataView, byteOffset, string, padding) {
+    const textEncoder = new TextEncoder();
+    const stringBuffer = textEncoder.encode(string);
+    byteOffset = copyPaddedArrayBufferToDataView(dataView, byteOffset, stringBuffer, padding);
+    return byteOffset;
+  }
+  var init_dataview_copy_utils = __esm({
+    "../loader-utils/src/lib/binary-utils/dataview-copy-utils.ts"() {
+      init_memory_copy_utils();
     }
   });
 
@@ -924,8 +878,54 @@
     }
   });
 
+  // ../../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,
@@ -940,6 +940,7 @@
   }
   var init_defineProperty = __esm({
     "../../node_modules/@babel/runtime/helpers/esm/defineProperty.js"() {
+      init_toPropertyKey();
     }
   });
 
@@ -964,19 +965,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) {
@@ -992,8 +1049,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 i2 = paths.length - 1; i2 >= -1 && !resolvedAbsolute; i2--) {
+      let path;
+      if (i2 >= 0) {
+        path = paths[i2];
+      } 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 i2 = 0; i2 <= path.length; ++i2) {
+      if (i2 < path.length) {
+        code = path.charCodeAt(i2);
+      } else if (code === SLASH) {
+        break;
+      } else {
+        code = SLASH;
+      }
+      if (code === SLASH) {
+        if (lastSlash === i2 - 1 || dots === 1) {
+        } else if (lastSlash !== i2 - 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 = i2;
+                dots = 0;
+                isAboveRoot = false;
+                continue;
+              }
+            } else if (res.length === 2 || res.length === 1) {
+              res = "";
+              lastSlash = i2;
+              dots = 0;
+              isAboveRoot = false;
+              continue;
+            }
+          }
+          if (allowAboveRoot) {
+            if (res.length > 0) {
+              res += "/..";
+            } else {
+              res = "..";
+            }
+            isAboveRoot = true;
+          }
+        } else {
+          const slice = path.slice(lastSlash + 1, i2);
+          if (res.length > 0) {
+            res += `/${slice}`;
+          } else {
+            res = slice;
+          }
+          isAboveRoot = false;
+        }
+        lastSlash = i2;
+        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;
     }
   });
 
@@ -1006,10 +1167,10 @@
       init_parse_json();
       init_array_buffer_utils();
       init_memory_copy_utils();
-      init_binary_copy_utils();
-      init_encode_utils();
+      init_dataview_copy_utils();
       init_async_iteration();
       init_file_aliases();
+      init_memory_conversion_utils();
       init_path();
     }
   });
@@ -2830,6 +2991,21 @@
     out[7] = a13 * c - a03 * s2;
     return out;
   }
+  function getScaling(out, mat) {
+    var m11 = mat[0];
+    var m12 = mat[1];
+    var m13 = mat[2];
+    var m21 = mat[4];
+    var m22 = mat[5];
+    var m23 = mat[6];
+    var m31 = mat[8];
+    var m32 = mat[9];
+    var m33 = mat[10];
+    out[0] = Math.hypot(m11, m12, m13);
+    out[1] = Math.hypot(m21, m22, m23);
+    out[2] = Math.hypot(m31, m32, m33);
+    return out;
+  }
   function fromQuat2(out, q) {
     var x = q[0], y = q[1], z = q[2], w = q[3];
     var x2 = x + x;
@@ -4413,6 +4589,716 @@
     }
   });
 
+  // ../../node_modules/@math.gl/culling/dist/esm/constants.js
+  var INTERSECTION;
+  var init_constants2 = __esm({
+    "../../node_modules/@math.gl/culling/dist/esm/constants.js"() {
+      INTERSECTION = {
+        OUTSIDE: -1,
+        INTERSECTING: 0,
+        INSIDE: 1
+      };
+    }
+  });
+
+  // ../../node_modules/@math.gl/culling/dist/esm/lib/bounding-volumes/axis-aligned-bounding-box.js
+  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();
+      scratchNormal2 = new Vector3();
+    }
+  });
+
+  // ../../node_modules/@math.gl/culling/dist/esm/lib/bounding-volumes/bounding-sphere.js
+  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();
+      scratchVector6 = new Vector3();
+      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);
+        }
+        fromCenterRadius(center, radius) {
+          this.center.from(center);
+          this.radius = radius;
+          return this;
+        }
+        fromCornerPoints(corner, oppositeCorner) {
+          oppositeCorner = scratchVector6.from(oppositeCorner);
+          this.center = new Vector3().from(corner).add(oppositeCorner).scale(0.5);
+          this.radius = this.center.distance(oppositeCorner);
+          return this;
+        }
+        equals(right) {
+          return this === right || Boolean(right) && this.center.equals(right.center) && this.radius === right.radius;
+        }
+        clone() {
+          return new BoundingSphere(this.center, this.radius);
+        }
+        union(boundingSphere) {
+          const leftCenter = this.center;
+          const leftRadius = this.radius;
+          const rightCenter = boundingSphere.center;
+          const rightRadius = boundingSphere.radius;
+          const toRightCenter = scratchVector6.copy(rightCenter).subtract(leftCenter);
+          const centerSeparation = toRightCenter.magnitude();
+          if (leftRadius >= centerSeparation + rightRadius) {
+            return this.clone();
+          }
+          if (rightRadius >= centerSeparation + leftRadius) {
+            return boundingSphere.clone();
+          }
+          const halfDistanceBetweenTangentPoints = (leftRadius + centerSeparation + rightRadius) * 0.5;
+          scratchVector23.copy(toRightCenter).scale((-leftRadius + halfDistanceBetweenTangentPoints) / centerSeparation).add(leftCenter);
+          this.center.copy(scratchVector23);
+          this.radius = halfDistanceBetweenTangentPoints;
+          return this;
+        }
+        expand(point) {
+          const scratchPoint = scratchVector6.from(point);
+          const radius = scratchPoint.subtract(this.center).magnitude();
+          if (radius > this.radius) {
+            this.radius = radius;
+          }
+          return this;
+        }
+        transform(transform) {
+          this.center.transform(transform);
+          const scale5 = getScaling(scratchVector6, transform);
+          this.radius = Math.max(scale5[0], Math.max(scale5[1], scale5[2])) * this.radius;
+          return this;
+        }
+        distanceSquaredTo(point) {
+          const d = this.distanceTo(point);
+          return d * d;
+        }
+        distanceTo(point) {
+          const scratchPoint = scratchVector6.from(point);
+          const delta = scratchPoint.subtract(this.center);
+          return Math.max(0, delta.len() - this.radius);
+        }
+        intersectPlane(plane) {
+          const center = this.center;
+          const radius = this.radius;
+          const normal = plane.normal;
+          const distanceToPlane = normal.dot(center) + plane.distance;
+          if (distanceToPlane < -radius) {
+            return INTERSECTION.OUTSIDE;
+          }
+          if (distanceToPlane < radius) {
+            return INTERSECTION.INTERSECTING;
+          }
+          return INTERSECTION.INSIDE;
+        }
+      };
+    }
+  });
+
+  // ../../node_modules/@math.gl/culling/dist/esm/lib/bounding-volumes/oriented-bounding-box.js
+  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();
+      scratchVector32 = new Vector3();
+      scratchOffset = new Vector3();
+      scratchVectorU = new Vector3();
+      scratchVectorV = new Vector3();
+      scratchVectorW = new Vector3();
+      scratchCorner = new Vector3();
+      scratchToCenter = new Vector3();
+      MATRIX3 = {
+        COLUMN0ROW0: 0,
+        COLUMN0ROW1: 1,
+        COLUMN0ROW2: 2,
+        COLUMN1ROW0: 3,
+        COLUMN1ROW1: 4,
+        COLUMN1ROW2: 5,
+        COLUMN2ROW0: 6,
+        COLUMN2ROW1: 7,
+        COLUMN2ROW2: 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);
+        }
+        get halfSize() {
+          const xAxis = this.halfAxes.getColumn(0);
+          const yAxis = this.halfAxes.getColumn(1);
+          const zAxis = this.halfAxes.getColumn(2);
+          return [new Vector3(xAxis).len(), new Vector3(yAxis).len(), new Vector3(zAxis).len()];
+        }
+        get quaternion() {
+          const xAxis = this.halfAxes.getColumn(0);
+          const yAxis = this.halfAxes.getColumn(1);
+          const zAxis = this.halfAxes.getColumn(2);
+          const normXAxis = new Vector3(xAxis).normalize();
+          const normYAxis = new Vector3(yAxis).normalize();
+          const normZAxis = new Vector3(zAxis).normalize();
+          return new Quaternion().fromMatrix3(new Matrix3([...normXAxis, ...normYAxis, ...normZAxis]));
+        }
+        fromCenterHalfSizeQuaternion(center, halfSize, quaternion) {
+          const quaternionObject = new Quaternion(quaternion);
+          const directionsMatrix = new Matrix3().fromQuaternion(quaternionObject);
+          directionsMatrix[0] = directionsMatrix[0] * halfSize[0];
+          directionsMatrix[1] = directionsMatrix[1] * halfSize[0];
+          directionsMatrix[2] = directionsMatrix[2] * halfSize[0];
+          directionsMatrix[3] = directionsMatrix[3] * halfSize[1];
+          directionsMatrix[4] = directionsMatrix[4] * halfSize[1];
+          directionsMatrix[5] = directionsMatrix[5] * halfSize[1];
+          directionsMatrix[6] = directionsMatrix[6] * halfSize[2];
+          directionsMatrix[7] = directionsMatrix[7] * halfSize[2];
+          directionsMatrix[8] = directionsMatrix[8] * halfSize[2];
+          this.center = new Vector3().from(center);
+          this.halfAxes = directionsMatrix;
+          return this;
+        }
+        clone() {
+          return new OrientedBoundingBox(this.center, this.halfAxes);
+        }
+        equals(right) {
+          return this === right || Boolean(right) && this.center.equals(right.center) && this.halfAxes.equals(right.halfAxes);
+        }
+        getBoundingSphere(result = new BoundingSphere()) {
+          const halfAxes = this.halfAxes;
+          const u = halfAxes.getColumn(0, scratchVectorU);
+          const v = halfAxes.getColumn(1, scratchVectorV);
+          const w = halfAxes.getColumn(2, scratchVectorW);
+          const cornerVector = scratchVector32.copy(u).add(v).add(w);
+          result.center.copy(this.center);
+          result.radius = cornerVector.magnitude();
+          return result;
+        }
+        intersectPlane(plane) {
+          const center = this.center;
+          const normal = plane.normal;
+          const halfAxes = this.halfAxes;
+          const normalX = normal.x;
+          const normalY = normal.y;
+          const normalZ = normal.z;
+          const radEffective = Math.abs(normalX * halfAxes[MATRIX3.COLUMN0ROW0] + normalY * halfAxes[MATRIX3.COLUMN0ROW1] + normalZ * halfAxes[MATRIX3.COLUMN0ROW2]) + Math.abs(normalX * halfAxes[MATRIX3.COLUMN1ROW0] + normalY * halfAxes[MATRIX3.COLUMN1ROW1] + normalZ * halfAxes[MATRIX3.COLUMN1ROW2]) + Math.abs(normalX * halfAxes[MATRIX3.COLUMN2ROW0] + normalY * halfAxes[MATRIX3.COLUMN2ROW1] + normalZ * halfAxes[MATRIX3.COLUMN2ROW2]);
+          const distanceToPlane = normal.dot(center) + plane.distance;
+          if (distanceToPlane <= -radEffective) {
+            return INTERSECTION.OUTSIDE;
+          } else if (distanceToPlane >= radEffective) {
+            return INTERSECTION.INSIDE;
+          }
+          return INTERSECTION.INTERSECTING;
+        }
+        distanceTo(point) {
+          return Math.sqrt(this.distanceSquaredTo(point));
+        }
+        distanceSquaredTo(point) {
+          const offset = scratchOffset.from(point).subtract(this.center);
+          const halfAxes = this.halfAxes;
+          const u = halfAxes.getColumn(0, scratchVectorU);
+          const v = halfAxes.getColumn(1, scratchVectorV);
+          const w = halfAxes.getColumn(2, scratchVectorW);
+          const uHalf = u.magnitude();
+          const vHalf = v.magnitude();
+          const wHalf = w.magnitude();
+          u.normalize();
+          v.normalize();
+          w.normalize();
+          let distanceSquared = 0;
+          let d;
+          d = Math.abs(offset.dot(u)) - uHalf;
+          if (d > 0) {
+            distanceSquared += d * d;
+          }
+          d = Math.abs(offset.dot(v)) - vHalf;
+          if (d > 0) {
+            distanceSquared += d * d;
+          }
+          d = Math.abs(offset.dot(w)) - wHalf;
+          if (d > 0) {
+            distanceSquared += d * d;
+          }
+          return distanceSquared;
+        }
+        computePlaneDistances(position, direction, result = [-0, -0]) {
+          let minDist = Number.POSITIVE_INFINITY;
+          let maxDist = Number.NEGATIVE_INFINITY;
+          const center = this.center;
+          const halfAxes = this.halfAxes;
+          const u = halfAxes.getColumn(0, scratchVectorU);
+          const v = halfAxes.getColumn(1, scratchVectorV);
+          const w = halfAxes.getColumn(2, scratchVectorW);
+          const corner = scratchCorner.copy(u).add(v).add(w).add(center);
+          const toCenter = scratchToCenter.copy(corner).subtract(position);
+          let mag = direction.dot(toCenter);
+          minDist = Math.min(mag, minDist);
+          maxDist = Math.max(mag, maxDist);
+          corner.copy(center).add(u).add(v).subtract(w);
+          toCenter.copy(corner).subtract(position);
+          mag = direction.dot(toCenter);
+          minDist = Math.min(mag, minDist);
+          maxDist = Math.max(mag, maxDist);
+          corner.copy(center).add(u).subtract(v).add(w);
+          toCenter.copy(corner).subtract(position);
+          mag = direction.dot(toCenter);
+          minDist = Math.min(mag, minDist);
+          maxDist = Math.max(mag, maxDist);
+          corner.copy(center).add(u).subtract(v).subtract(w);
+          toCenter.copy(corner).subtract(position);
+          mag = direction.dot(toCenter);
+          minDist = Math.min(mag, minDist);
+          maxDist = Math.max(mag, maxDist);
+          center.copy(corner).subtract(u).add(v).add(w);
+          toCenter.copy(corner).subtract(position);
+          mag = direction.dot(toCenter);
+          minDist = Math.min(mag, minDist);
+          maxDist = Math.max(mag, maxDist);
+          center.copy(corner).subtract(u).add(v).subtract(w);
+          toCenter.copy(corner).subtract(position);
+          mag = direction.dot(toCenter);
+          minDist = Math.min(mag, minDist);
+          maxDist = Math.max(mag, maxDist);
+          center.copy(corner).subtract(u).subtract(v).add(w);
+          toCenter.copy(corner).subtract(position);
+          mag = direction.dot(toCenter);
+          minDist = Math.min(mag, minDist);
+          maxDist = Math.max(mag, maxDist);
+          center.copy(corner).subtract(u).subtract(v).subtract(w);
+          toCenter.copy(corner).subtract(position);
+          mag = direction.dot(toCenter);
+          minDist = Math.min(mag, minDist);
+          maxDist = Math.max(mag, maxDist);
+          result[0] = minDist;
+          result[1] = maxDist;
+          return result;
+        }
+        transform(transformation) {
+          this.center.transformAsPoint(transformation);
+          const xAxis = this.halfAxes.getColumn(0, scratchVectorU);
+          xAxis.transformAsPoint(transformation);
+          const yAxis = this.halfAxes.getColumn(1, scratchVectorV);
+          yAxis.transformAsPoint(transformation);
+          const zAxis = this.halfAxes.getColumn(2, scratchVectorW);
+          zAxis.transformAsPoint(transformation);
+          this.halfAxes = new Matrix3([...xAxis, ...yAxis, ...zAxis]);
+          return this;
+        }
+        getTransform() {
+          throw new Error("not implemented");
+        }
+      };
+    }
+  });
+
+  // ../../node_modules/@math.gl/culling/dist/esm/lib/plane.js
+  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);
+        }
+        fromNormalDistance(normal, distance) {
+          assert4(Number.isFinite(distance));
+          this.normal.from(normal).normalize();
+          this.distance = distance;
+          return this;
+        }
+        fromPointNormal(point, normal) {
+          point = scratchPosition2.from(point);
+          this.normal.from(normal).normalize();
+          const distance = -this.normal.dot(point);
+          this.distance = distance;
+          return this;
+        }
+        fromCoefficients(a2, b, c, d) {
+          this.normal.set(a2, b, c);
+          assert4(equals(this.normal.len(), 1));
+          this.distance = d;
+          return this;
+        }
+        clone() {
+          return new Plane(this.normal, this.distance);
+        }
+        equals(right) {
+          return equals(this.distance, right.distance) && equals(this.normal, right.normal);
+        }
+        getPointDistance(point) {
+          return this.normal.dot(point) + this.distance;
+        }
+        transform(matrix4) {
+          const normal = scratchNormal3.copy(this.normal).transformAsVector(matrix4).normalize();
+          const point = this.normal.scale(-this.distance).transform(matrix4);
+          return this.fromPointNormal(point, normal);
+        }
+        projectPointOntoPlane(point, result = [0, 0, 0]) {
+          point = scratchPosition2.from(point);
+          const pointDistance = this.getPointDistance(point);
+          const scaledNormal = scratchNormal3.copy(this.normal).scale(pointDistance);
+          return point.subtract(scaledNormal).to(result);
+        }
+      };
+    }
+  });
+
+  // ../../node_modules/@math.gl/culling/dist/esm/lib/culling-volume.js
+  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();
+      faces = [new Vector3([1, 0, 0]), new Vector3([0, 1, 0]), new Vector3([0, 0, 1])];
+      scratchPlaneCenter = new Vector3();
+      scratchPlaneNormal = new Vector3();
+      scratchPlane = new Plane(new Vector3(1, 0, 0), 0);
+      CullingVolume = class {
+        constructor(planes = []) {
+          _defineProperty(this, "planes", void 0);
+          this.planes = planes;
+        }
+        fromBoundingSphere(boundingSphere) {
+          this.planes.length = 2 * faces.length;
+          const center = boundingSphere.center;
+          const radius = boundingSphere.radius;
+          let planeIndex = 0;
+          for (const faceNormal of faces) {
+            let plane0 = this.planes[planeIndex];
+            let plane1 = this.planes[planeIndex + 1];
+            if (!plane0) {
+              plane0 = this.planes[planeIndex] = new Plane();
+            }
+            if (!plane1) {
+              plane1 = this.planes[planeIndex + 1] = new Plane();
+            }
+            const plane0Center = scratchPlaneCenter.copy(faceNormal).scale(-radius).add(center);
+            const plane0Distance = -faceNormal.dot(plane0Center);
+            plane0.fromPointNormal(plane0Center, faceNormal);
+            const plane1Center = scratchPlaneCenter.copy(faceNormal).scale(radius).add(center);
+            const negatedFaceNormal = scratchPlaneNormal.copy(faceNormal).negate();
+            const plane1Distance = -negatedFaceNormal.dot(plane1Center);
+            plane1.fromPointNormal(plane1Center, negatedFaceNormal);
+            planeIndex += 2;
+          }
+          return this;
+        }
+        computeVisibility(boundingVolume) {
+          let intersect = INTERSECTION.INSIDE;
+          for (const plane of this.planes) {
+            const result = boundingVolume.intersectPlane(plane);
+            switch (result) {
+              case INTERSECTION.OUTSIDE:
+                return INTERSECTION.OUTSIDE;
+              case INTERSECTION.INTERSECTING:
+                intersect = INTERSECTION.INTERSECTING;
+                break;
+              default:
+            }
+          }
+          return intersect;
+        }
+        computeVisibilityWithPlaneMask(boundingVolume, parentPlaneMask) {
+          assert4(Number.isFinite(parentPlaneMask), "parentPlaneMask is required.");
+          if (parentPlaneMask === CullingVolume.MASK_OUTSIDE || parentPlaneMask === CullingVolume.MASK_INSIDE) {
+            return parentPlaneMask;
+          }
+          let mask = CullingVolume.MASK_INSIDE;
+          const planes = this.planes;
+          for (let k = 0; k < this.planes.length; ++k) {
+            const flag = k < 31 ? 1 << k : 0;
+            if (k < 31 && (parentPlaneMask & flag) === 0) {
+              continue;
+            }
+            const plane = planes[k];
+            const result = boundingVolume.intersectPlane(plane);
+            if (result === INTERSECTION.OUTSIDE) {
+              return CullingVolume.MASK_OUTSIDE;
+            } else if (result === INTERSECTION.INTERSECTING) {
+              mask |= flag;
+            }
+          }
+          return mask;
+        }
+      };
+      _defineProperty(CullingVolume, "MASK_OUTSIDE", 4294967295);
+      _defineProperty(CullingVolume, "MASK_INSIDE", 0);
+      _defineProperty(CullingVolume, "MASK_INDETERMINATE", 2147483647);
+    }
+  });
+
+  // ../../node_modules/@math.gl/culling/dist/esm/lib/perspective-off-center-frustum.js
+  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();
+      scratchPlaneUpVector = new Vector3();
+      scratchPlaneRightVector = new Vector3();
+      scratchPlaneNearCenter = new Vector3();
+      scratchPlaneFarCenter = new Vector3();
+      scratchPlaneNormal2 = new Vector3();
+    }
+  });
+
+  // ../../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();
+    }
+  });
+
+  // ../../node_modules/@math.gl/culling/dist/esm/lib/algorithms/bounding-sphere-from-points.js
+  var fromPointsXMin, fromPointsYMin, fromPointsZMin, fromPointsXMax, fromPointsYMax, fromPointsZMax, fromPointsCurrentPos, fromPointsScratch, fromPointsRitterCenter, fromPointsMinBoxPt, fromPointsMaxBoxPt, fromPointsNaiveCenterScratch, volumeConstant;
+  var init_bounding_sphere_from_points = __esm({
+    "../../node_modules/@math.gl/culling/dist/esm/lib/algorithms/bounding-sphere-from-points.js"() {
+      init_esm();
+      init_bounding_sphere();
+      fromPointsXMin = new Vector3();
+      fromPointsYMin = new Vector3();
+      fromPointsZMin = new Vector3();
+      fromPointsXMax = new Vector3();
+      fromPointsYMax = new Vector3();
+      fromPointsZMax = new Vector3();
+      fromPointsCurrentPos = new Vector3();
+      fromPointsScratch = new Vector3();
+      fromPointsRitterCenter = new Vector3();
+      fromPointsMinBoxPt = new Vector3();
+      fromPointsMaxBoxPt = new Vector3();
+      fromPointsNaiveCenterScratch = new Vector3();
+      volumeConstant = 4 / 3 * Math.PI;
+    }
+  });
+
+  // ../../node_modules/@math.gl/culling/dist/esm/lib/algorithms/compute-eigen-decomposition.js
+  function computeEigenDecomposition(matrix, result = {}) {
+    const EIGEN_TOLERANCE = math_utils_default.EPSILON20;
+    const EIGEN_MAX_SWEEPS = 10;
+    let count = 0;
+    let sweep = 0;
+    const unitaryMatrix = scratchUnitary;
+    const diagonalMatrix = scratchDiagonal;
+    unitaryMatrix.identity();
+    diagonalMatrix.copy(matrix);
+    const epsilon = EIGEN_TOLERANCE * computeFrobeniusNorm(diagonalMatrix);
+    while (sweep < EIGEN_MAX_SWEEPS && offDiagonalFrobeniusNorm(diagonalMatrix) > epsilon) {
+      shurDecomposition(diagonalMatrix, jMatrix);
+      jMatrixTranspose.copy(jMatrix).transpose();
+      diagonalMatrix.multiplyRight(jMatrix);
+      diagonalMatrix.multiplyLeft(jMatrixTranspose);
+      unitaryMatrix.multiplyRight(jMatrix);
+      if (++count > 2) {
+        ++sweep;
+        count = 0;
+      }
+    }
+    result.unitary = unitaryMatrix.toTarget(result.unitary);
+    result.diagonal = diagonalMatrix.toTarget(result.diagonal);
+    return result;
+  }
+  function computeFrobeniusNorm(matrix) {
+    let norm = 0;
+    for (let i2 = 0; i2 < 9; ++i2) {
+      const temp = matrix[i2];
+      norm += temp * temp;
+    }
+    return Math.sqrt(norm);
+  }
+  function offDiagonalFrobeniusNorm(matrix) {
+    let norm = 0;
+    for (let i2 = 0; i2 < 3; ++i2) {
+      const temp = matrix[scratchMatrix.getElementIndex(colVal[i2], rowVal[i2])];
+      norm += 2 * temp * temp;
+    }
+    return Math.sqrt(norm);
+  }
+  function shurDecomposition(matrix, result) {
+    const tolerance = math_utils_default.EPSILON15;
+    let maxDiagonal = 0;
+    let rotAxis = 1;
+    for (let i2 = 0; i2 < 3; ++i2) {
+      const temp = Math.abs(matrix[scratchMatrix.getElementIndex(colVal[i2], rowVal[i2])]);
+      if (temp > maxDiagonal) {
+        rotAxis = i2;
+        maxDiagonal = temp;
+      }
+    }
+    const p2 = rowVal[rotAxis];
+    const q = colVal[rotAxis];
+    let c = 1;
+    let s2 = 0;
+    if (Math.abs(matrix[scratchMatrix.getElementIndex(q, p2)]) > tolerance) {
+      const qq = matrix[scratchMatrix.getElementIndex(q, q)];
+      const pp = matrix[scratchMatrix.getElementIndex(p2, p2)];
+      const qp = matrix[scratchMatrix.getElementIndex(q, p2)];
+      const tau = (qq - pp) / 2 / qp;
+      let t2;
+      if (tau < 0) {
+        t2 = -1 / (-tau + Math.sqrt(1 + tau * tau));
+      } else {
+        t2 = 1 / (tau + Math.sqrt(1 + tau * tau));
+      }
+      c = 1 / Math.sqrt(1 + t2 * t2);
+      s2 = t2 * c;
+    }
+    Matrix3.IDENTITY.to(result);
+    result[scratchMatrix.getElementIndex(p2, p2)] = result[scratchMatrix.getElementIndex(q, q)] = c;
+    result[scratchMatrix.getElementIndex(q, p2)] = s2;
+    result[scratchMatrix.getElementIndex(p2, q)] = -s2;
+    return result;
+  }
+  var scratchMatrix, scratchUnitary, scratchDiagonal, jMatrix, jMatrixTranspose, rowVal, colVal;
+  var init_compute_eigen_decomposition = __esm({
+    "../../node_modules/@math.gl/culling/dist/esm/lib/algorithms/compute-eigen-decomposition.js"() {
+      init_esm();
+      scratchMatrix = new Matrix3();
+      scratchUnitary = new Matrix3();
+      scratchDiagonal = new Matrix3();
+      jMatrix = new Matrix3();
+      jMatrixTranspose = new Matrix3();
+      rowVal = [1, 0, 0];
+      colVal = [2, 2, 1];
+    }
+  });
+
+  // ../../node_modules/@math.gl/culling/dist/esm/lib/algorithms/bounding-box-from-points.js
+  function makeOrientedBoundingBoxFromPoints(positions, result = new OrientedBoundingBox()) {
+    if (!positions || positions.length === 0) {
+      result.halfAxes = new Matrix3([0, 0, 0, 0, 0, 0, 0, 0, 0]);
+      result.center = new Vector3();
+      return result;
+    }
+    const length4 = positions.length;
+    const meanPoint = new Vector3(0, 0, 0);
+    for (const position of positions) {
+      meanPoint.add(position);
+    }
+    const invLength = 1 / length4;
+    meanPoint.multiplyByScalar(invLength);
+    let exx = 0;
+    let exy = 0;
+    let exz = 0;
+    let eyy = 0;
+    let eyz = 0;
+    let ezz = 0;
+    for (const position of positions) {
+      const p2 = scratchVector24.copy(position).subtract(meanPoint);
+      exx += p2.x * p2.x;
+      exy += p2.x * p2.y;
+      exz += p2.x * p2.z;
+      eyy += p2.y * p2.y;
+      eyz += p2.y * p2.z;
+      ezz += p2.z * p2.z;
+    }
+    exx *= invLength;
+    exy *= invLength;
+    exz *= invLength;
+    eyy *= invLength;
+    eyz *= invLength;
+    ezz *= invLength;
+    const covarianceMatrix = scratchCovarianceResult;
+    covarianceMatrix[0] = exx;
+    covarianceMatrix[1] = exy;
+    covarianceMatrix[2] = exz;
+    covarianceMatrix[3] = exy;
+    covarianceMatrix[4] = eyy;
+    covarianceMatrix[5] = eyz;
+    covarianceMatrix[6] = exz;
+    covarianceMatrix[7] = eyz;
+    covarianceMatrix[8] = ezz;
+    const {
+      unitary
+    } = computeEigenDecomposition(covarianceMatrix, scratchEigenResult);
+    const rotation = result.halfAxes.copy(unitary);
+    let v1 = rotation.getColumn(0, scratchVector42);
+    let v2 = rotation.getColumn(1, scratchVector52);
+    let v3 = rotation.getColumn(2, scratchVector62);
+    let u1 = -Number.MAX_VALUE;
+    let u2 = -Number.MAX_VALUE;
+    let u3 = -Number.MAX_VALUE;
+    let l1 = Number.MAX_VALUE;
+    let l2 = Number.MAX_VALUE;
+    let l3 = Number.MAX_VALUE;
+    for (const position of positions) {
+      scratchVector24.copy(position);
+      u1 = Math.max(scratchVector24.dot(v1), u1);
+      u2 = Math.max(scratchVector24.dot(v2), u2);
+      u3 = Math.max(scratchVector24.dot(v3), u3);
+      l1 = Math.min(scratchVector24.dot(v1), l1);
+      l2 = Math.min(scratchVector24.dot(v2), l2);
+      l3 = Math.min(scratchVector24.dot(v3), l3);
+    }
+    v1 = v1.multiplyByScalar(0.5 * (l1 + u1));
+    v2 = v2.multiplyByScalar(0.5 * (l2 + u2));
+    v3 = v3.multiplyByScalar(0.5 * (l3 + u3));
+    result.center.copy(v1).add(v2).add(v3);
+    const scale5 = scratchVector33.set(u1 - l1, u2 - l2, u3 - l3).multiplyByScalar(0.5);
+    const scaleMatrix = new Matrix3([scale5[0], 0, 0, 0, scale5[1], 0, 0, 0, scale5[2]]);
+    result.halfAxes.multiplyRight(scaleMatrix);
+    return result;
+  }
+  var scratchVector24, scratchVector33, scratchVector42, scratchVector52, scratchVector62, scratchCovarianceResult, scratchEigenResult;
+  var init_bounding_box_from_points = __esm({
+    "../../node_modules/@math.gl/culling/dist/esm/lib/algorithms/bounding-box-from-points.js"() {
+      init_esm();
+      init_compute_eigen_decomposition();
+      init_oriented_bounding_box();
+      init_axis_aligned_bounding_box();
+      scratchVector24 = new Vector3();
+      scratchVector33 = new Vector3();
+      scratchVector42 = new Vector3();
+      scratchVector52 = new Vector3();
+      scratchVector62 = new Vector3();
+      scratchCovarianceResult = new Matrix3();
+      scratchEigenResult = {
+        diagonal: new Matrix3(),
+        unitary: new Matrix3()
+      };
+    }
+  });
+
+  // ../../node_modules/@math.gl/culling/dist/esm/index.js
+  var init_esm3 = __esm({
+    "../../node_modules/@math.gl/culling/dist/esm/index.js"() {
+      init_constants2();
+      init_axis_aligned_bounding_box();
+      init_bounding_sphere();
+      init_oriented_bounding_box();
+      init_culling_volume();
+      init_plane();
+      init_perspective_off_center_frustum();
+      init_perspective_frustum();
+      init_bounding_sphere_from_points();
+      init_bounding_box_from_points();
+      init_compute_eigen_decomposition();
+    }
+  });
+
   // ../core/src/javascript-utils/is-type.ts
   var isBoolean, isFunction, isObject, isPureObject, isIterable, isAsyncIterable, isResponse, isBlob, isBuffer2, isReadableDOMStream, isReadableNodeStream, isReadableStream;
   var init_is_type = __esm({
@@ -4564,9 +5450,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);
       });
     }
@@ -4611,12 +5497,12 @@
     }
   });
 
-  // ../../node_modules/@probe.gl/env/dist/esm/lib/is-electron.js
+  // ../core/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;
@@ -4627,59 +5513,54 @@
     return false;
   }
   var init_is_electron = __esm({
-    "../../node_modules/@probe.gl/env/dist/esm/lib/is-electron.js"() {
+    "../core/node_modules/@probe.gl/env/dist/lib/is-electron.js"() {
     }
   });
 
-  // ../../node_modules/@probe.gl/env/dist/esm/lib/is-browser.js
+  // ../core/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/env/dist/esm/lib/is-browser.js"() {
+    "../core/node_modules/@probe.gl/env/dist/lib/is-browser.js"() {
       init_is_electron();
     }
   });
 
-  // ../../node_modules/@probe.gl/env/dist/esm/lib/globals.js
-  var globals3, self_3, window_3, document_3, process_;
+  // ../core/node_modules/@probe.gl/env/dist/lib/globals.js
+  var self2, window2, document2, process2, console2, navigator2;
   var init_globals3 = __esm({
-    "../../node_modules/@probe.gl/env/dist/esm/lib/globals.js"() {
-      globals3 = {
-        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 = globals3.self || globals3.window || globals3.global;
-      window_3 = globals3.window || globals3.self || globals3.global;
-      document_3 = globals3.document || {};
-      process_ = globals3.process || {};
+    "../core/node_modules/@probe.gl/env/dist/lib/globals.js"() {
+      self2 = globalThis.self || globalThis.window || globalThis.global;
+      window2 = globalThis.window || globalThis.self || globalThis.global;
+      document2 = globalThis.document || {};
+      process2 = globalThis.process || {};
+      console2 = globalThis.console;
+      navigator2 = globalThis.navigator || {};
     }
   });
 
-  // ../../node_modules/@probe.gl/env/dist/esm/utils/globals.js
+  // ../core/node_modules/@probe.gl/env/dist/utils/globals.js
   var VERSION3, isBrowser4;
   var init_globals4 = __esm({
-    "../../node_modules/@probe.gl/env/dist/esm/utils/globals.js"() {
+    "../core/node_modules/@probe.gl/env/dist/utils/globals.js"() {
       init_is_browser();
       VERSION3 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "untranspiled source";
       isBrowser4 = isBrowser3();
     }
   });
 
-  // ../../node_modules/@probe.gl/env/dist/esm/index.js
-  var init_esm3 = __esm({
-    "../../node_modules/@probe.gl/env/dist/esm/index.js"() {
+  // ../core/node_modules/@probe.gl/env/dist/index.js
+  var init_dist = __esm({
+    "../core/node_modules/@probe.gl/env/dist/index.js"() {
       init_globals4();
       init_globals3();
       init_is_browser();
     }
   });
 
-  // ../../node_modules/@probe.gl/log/dist/esm/utils/local-storage.js
+  // ../core/node_modules/@probe.gl/log/dist/utils/local-storage.js
   function getStorage(type) {
     try {
       const storage = window[type];
@@ -4693,35 +5574,28 @@
   }
   var LocalStorage;
   var init_local_storage = __esm({
-    "../../node_modules/@probe.gl/log/dist/esm/utils/local-storage.js"() {
+    "../core/node_modules/@probe.gl/log/dist/utils/local-storage.js"() {
       init_defineProperty();
       LocalStorage = class {
-        constructor(id) {
-          let defaultSettings = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+        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", {});
+          _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 = {};
@@ -4736,7 +5610,7 @@
     }
   });
 
-  // ../../node_modules/@probe.gl/log/dist/esm/utils/formatters.js
+  // ../core/node_modules/@probe.gl/log/dist/utils/formatters.js
   function formatTime(ms) {
     let formatted;
     if (ms < 10) {
@@ -4767,31 +5641,35 @@
     return ["".concat(message, " %c+"), style];
   }
   var init_formatters = __esm({
-    "../../node_modules/@probe.gl/log/dist/esm/utils/formatters.js"() {
+    "../core/node_modules/@probe.gl/log/dist/utils/formatters.js"() {
     }
   });
 
-  // ../../node_modules/@probe.gl/log/dist/esm/utils/color.js
+  // ../core/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 (!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/log/dist/esm/utils/color.js"() {
-      init_esm3();
+    "../core/node_modules/@probe.gl/log/dist/utils/color.js"() {
+      init_dist();
       (function(COLOR2) {
         COLOR2[COLOR2["BLACK"] = 30] = "BLACK";
         COLOR2[COLOR2["RED"] = 31] = "RED";
@@ -4810,47 +5688,50 @@
         COLOR2[COLOR2["BRIGHT_CYAN"] = 96] = "BRIGHT_CYAN";
         COLOR2[COLOR2["BRIGHT_WHITE"] = 97] = "BRIGHT_WHITE";
       })(COLOR || (COLOR = {}));
+      BACKGROUND_INCREMENT = 10;
     }
   });
 
-  // ../../node_modules/@probe.gl/log/dist/esm/utils/autobind.js
+  // ../core/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((name10) => key === name10)) {
-          obj[key] = obj[key].bind(obj);
+          object[key] = value.bind(obj);
         }
       }
     }
   }
   var init_autobind = __esm({
-    "../../node_modules/@probe.gl/log/dist/esm/utils/autobind.js"() {
+    "../core/node_modules/@probe.gl/log/dist/utils/autobind.js"() {
     }
   });
 
-  // ../../node_modules/@probe.gl/log/dist/esm/utils/assert.js
+  // ../core/node_modules/@probe.gl/log/dist/utils/assert.js
   function assert5(condition, message) {
     if (!condition) {
       throw new Error(message || "Assertion failed");
     }
   }
   var init_assert4 = __esm({
-    "../../node_modules/@probe.gl/log/dist/esm/utils/assert.js"() {
+    "../core/node_modules/@probe.gl/log/dist/utils/assert.js"() {
     }
   });
 
-  // ../../node_modules/@probe.gl/log/dist/esm/utils/hi-res-timestamp.js
+  // ../core/node_modules/@probe.gl/log/dist/utils/hi-res-timestamp.js
   function getHiResTimestamp() {
     let timestamp;
-    if (isBrowser3 && "performance" in window_3) {
+    if (isBrowser3() && window2.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_) {
+      timestamp = window2 === null || window2 === void 0 ? void 0 : (_window$performance = window2.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 process2) {
       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_);
+      const timeParts = process2 === null || process2 === void 0 ? void 0 : (_process$hrtime = process2.hrtime) === null || _process$hrtime === void 0 ? void 0 : _process$hrtime.call(process2);
       timestamp = timeParts[0] * 1e3 + timeParts[1] / 1e6;
     } else {
       timestamp = Date.now();
@@ -4858,18 +5739,12 @@
     return timestamp;
   }
   var init_hi_res_timestamp = __esm({
-    "../../node_modules/@probe.gl/log/dist/esm/utils/hi-res-timestamp.js"() {
-      init_esm3();
-    }
-  });
-
-  // (disabled):../../node_modules/@probe.gl/log/dist/esm/node/node-asciify-image
-  var init_node_asciify_image = __esm({
-    "(disabled):../../node_modules/@probe.gl/log/dist/esm/node/node-asciify-image"() {
+    "../core/node_modules/@probe.gl/log/dist/utils/hi-res-timestamp.js"() {
+      init_dist();
     }
   });
 
-  // ../../node_modules/@probe.gl/log/dist/esm/log.js
+  // ../core/node_modules/@probe.gl/log/dist/log.js
   function noop() {
   }
   function normalizeLogLevel(logLevel) {
@@ -4935,11 +5810,7 @@
       message = "",
       scale: scale5 = 1
     } = _ref2;
-    asciify.nodeAsciifyImage({
-      image,
-      message,
-      scale: scale5
-    });
+    console.warn("removed");
     return noop;
   }
   function logImageInBrowser(_ref3) {
@@ -4978,26 +5849,25 @@
     }
     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/log/dist/esm/log.js"() {
+    "../core/node_modules/@probe.gl/log/dist/log.js"() {
       init_defineProperty();
-      init_esm3();
+      init_dist();
       init_local_storage();
       init_formatters();
       init_color();
       init_autobind();
       init_assert4();
       init_hi_res_timestamp();
-      init_node_asciify_image();
       originalConsole = {
-        debug: isBrowser3 ? 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
       };
@@ -5020,8 +5890,8 @@
           _defineProperty(this, "userData", {});
           _defineProperty(this, "LOG_THROTTLE_TIMEOUT", 0);
           this.id = id;
-          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);
@@ -5055,13 +5925,13 @@
         }
         enable() {
           let enabled = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : true;
-          this._storage.updateConfiguration({
+          this._storage.setConfiguration({
             enabled
           });
           return this;
         }
         setLevel(level) {
-          this._storage.updateConfiguration({
+          this._storage.setConfiguration({
             level
           });
           return this;
@@ -5070,7 +5940,7 @@
           return this._storage.config[setting];
         }
         set(setting, value) {
-          this._storage.updateConfiguration({
+          this._storage.setConfiguration({
             [setting]: value
           });
         }
@@ -5109,9 +5979,6 @@
           return this._getLogFunction(logLevel, message, console.info, arguments);
         }
         once(logLevel, message) {
-          for (var _len = arguments.length, args = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
-            args[_key - 2] = arguments[_key];
-          }
           return this._getLogFunction(logLevel, message, originalConsole.debug || originalConsole.info, arguments, ONCE);
         }
         table(logLevel, table, columns) {
@@ -5133,7 +6000,7 @@
           if (!this._shouldLog(logLevel || priority)) {
             return noop;
           }
-          return isBrowser3 ? logImageInBrowser({
+          return isBrowser3() ? logImageInBrowser({
             image,
             message,
             scale: scale5
@@ -5206,7 +6073,7 @@
             opts.delta = this.getDelta();
             this._deltaTs = getHiResTimestamp();
             const tag = opts.tag || opts.message;
-            if (opts.once) {
+            if (opts.once && tag) {
               if (!cache[tag]) {
                 cache[tag] = getHiResTimestamp();
               } else {
@@ -5223,13 +6090,13 @@
     }
   });
 
-  // ../../node_modules/@probe.gl/log/dist/esm/index.js
-  var esm_default;
-  var init_esm4 = __esm({
-    "../../node_modules/@probe.gl/log/dist/esm/index.js"() {
+  // ../core/node_modules/@probe.gl/log/dist/index.js
+  var dist_default;
+  var init_dist2 = __esm({
+    "../core/node_modules/@probe.gl/log/dist/index.js"() {
       init_log();
       init_log();
-      esm_default = new Log({
+      dist_default = new Log({
         id: "@probe.gl/log"
       });
     }
@@ -5239,7 +6106,7 @@
   var probeLog, NullLog, ConsoleLog;
   var init_loggers = __esm({
     "../core/src/lib/loader-utils/loggers.ts"() {
-      init_esm4();
+      init_dist2();
       probeLog = new Log({ id: "loaders.gl" });
       NullLog = class {
         log() {
@@ -5337,20 +6204,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) {
@@ -5429,7 +6282,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 = () => {
@@ -5497,7 +6349,7 @@
   var log;
   var init_log2 = __esm({
     "../core/src/lib/utils/log.ts"() {
-      init_esm4();
+      init_dist2();
       log = new Log({ id: "loaders.gl" });
     }
   });
@@ -5770,7 +6622,7 @@
         if (done) {
           return;
         }
-        yield toArrayBuffer(value);
+        yield toArrayBuffer2(value);
       }
     } catch (error) {
       reader.releaseLock();
@@ -5778,7 +6630,7 @@
   }
   async function* makeNodeStreamIterator(stream, options) {
     for await (const chunk of stream) {
-      yield toArrayBuffer(chunk);
+      yield toArrayBuffer2(chunk);
     }
   }
   var init_make_stream_iterator = __esm({
@@ -5879,6 +6731,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) {
@@ -5909,7 +6784,7 @@
   }
   var init_loader_context = __esm({
     "../core/src/lib/loader-utils/loader-context.ts"() {
-      init_option_utils();
+      init_get_fetch_function();
     }
   });
 
@@ -5994,7 +6869,7 @@
     "../core/src/lib/api/load.ts"() {
       init_is_type();
       init_normalize_loader();
-      init_option_utils();
+      init_get_fetch_function();
       init_parse();
     }
   });
@@ -6009,7 +6884,7 @@
 
   // ../tiles/src/constants.ts
   var TILE_REFINEMENT, TILE_TYPE, TILESET_TYPE, LOD_METRIC_TYPE;
-  var init_constants2 = __esm({
+  var init_constants3 = __esm({
     "../tiles/src/constants.ts"() {
       TILE_REFINEMENT = {
         ADD: 1,
@@ -6035,7 +6910,7 @@
   // ../tiles/src/index.ts
   var init_src4 = __esm({
     "../tiles/src/index.ts"() {
-      init_constants2();
+      init_constants3();
     }
   });
 
@@ -6049,7 +6924,7 @@
 
   // src/lib/constants.ts
   var TILE3D_TYPE, TILE3D_TYPES, MAGIC_ARRAY;
-  var init_constants3 = __esm({
+  var init_constants4 = __esm({
     "src/lib/constants.ts"() {
       TILE3D_TYPE = {
         COMPOSITE: "cmpt",
@@ -7126,10 +8001,10 @@
     if (wasmBinary) {
       options.wasmBinary = wasmBinary;
     }
-    return new Promise((resolve) => {
+    return new Promise((resolve2) => {
       DracoDecoderModule({
         ...options,
-        onModuleLoaded: (draco) => resolve({ draco })
+        onModuleLoaded: (draco) => resolve2({ draco })
       });
     });
   }
@@ -7172,7 +8047,7 @@
 
   // ../math/src/geometry/constants.ts
   var GL_PRIMITIVE_MODE, GL_TYPE, GL2;
-  var init_constants4 = __esm({
+  var init_constants5 = __esm({
     "../math/src/geometry/constants.ts"() {
       GL_PRIMITIVE_MODE = {
         POINTS: 0,
@@ -7204,7 +8079,7 @@
   var GL_TYPE_TO_ARRAY_TYPE, NAME_TO_GL_TYPE, ERR_TYPE_CONVERSION, GLType;
   var init_gl_type = __esm({
     "../math/src/geometry/gl/gl-type.ts"() {
-      init_constants4();
+      init_constants5();
       GL_TYPE_TO_ARRAY_TYPE = {
         [GL_TYPE.DOUBLE]: Float64Array,
         [GL_TYPE.FLOAT]: Float32Array,
@@ -7327,14 +8202,14 @@
   function octDecode(x, y, result) {
     return octDecodeInRange(x, y, 255, result);
   }
-  var RIGHT_SHIFT, scratchVector23, scratchVector32, scratchEncodeVector2, octEncodeScratch, uint8ForceArray;
+  var RIGHT_SHIFT, scratchVector25, scratchVector34, scratchEncodeVector2, octEncodeScratch, uint8ForceArray;
   var init_attribute_compression = __esm({
     "../math/src/geometry/compression/attribute-compression.ts"() {
       init_esm();
       init_assert6();
       RIGHT_SHIFT = 1 / 256;
-      scratchVector23 = new Vector2();
-      scratchVector32 = new Vector3();
+      scratchVector25 = new Vector2();
+      scratchVector34 = new Vector3();
       scratchEncodeVector2 = new Vector2();
       octEncodeScratch = new Vector2();
       uint8ForceArray = new Uint8Array(1);
@@ -7344,7 +8219,7 @@
   // ../math/src/index.ts
   var init_src7 = __esm({
     "../math/src/index.ts"() {
-      init_constants4();
+      init_constants5();
       init_gl_type();
       init_rgb565();
       init_attribute_compression();
@@ -8125,8 +9000,8 @@
     if (tile.isOctEncoded16P) {
       const decodedArray = new Float32Array(tile.pointsLength * 3);
       for (let i2 = 0; i2 < tile.pointsLength; i2++) {
-        octDecode(normals[i2 * 2], normals[i2 * 2 + 1], scratchNormal2);
-        scratchNormal2.toArray(decodedArray, i2 * 3);
+        octDecode(normals[i2 * 2], normals[i2 * 2 + 1], scratchNormal4);
+        scratchNormal4.toArray(decodedArray, i2 * 3);
       }
       return {
         type: GL2.FLOAT,
@@ -8140,12 +9015,12 @@
       value: normals
     };
   }
-  var scratchNormal2;
+  var scratchNormal4;
   var init_normalize_3d_tile_normals = __esm({
     "src/lib/parsers/helpers/normalize-3d-tile-normals.ts"() {
       init_esm();
       init_src7();
-      scratchNormal2 = new Vector3();
+      scratchNormal4 = new Vector3();
     }
   });
 
@@ -8166,10 +9041,10 @@
     };
   }
   function decodeQuantizedPositions(tile, positions) {
-    const scratchPosition2 = new Vector3();
+    const scratchPosition3 = new Vector3();
     const decodedArray = new Float32Array(tile.pointCount * 3);
     for (let i2 = 0; i2 < tile.pointCount; i2++) {
-      scratchPosition2.set(positions[i2 * 3], positions[i2 * 3 + 1], positions[i2 * 3 + 2]).scale(1 / tile.quantizedRange).multiply(tile.quantizedVolumeScale).add(tile.quantizedVolumeOffset).toArray(decodedArray, i2 * 3);
+      scratchPosition3.set(positions[i2 * 3], positions[i2 * 3 + 1], positions[i2 * 3 + 2]).scale(1 / tile.quantizedRange).multiply(tile.quantizedVolumeScale).add(tile.quantizedVolumeOffset).toArray(decodedArray, i2 * 3);
     }
     return decodedArray;
   }
@@ -8422,11 +9297,11 @@
     if (wasmBinary) {
       options.wasmBinary = wasmBinary;
     }
-    return new Promise((resolve) => {
+    return new Promise((resolve2) => {
       BasisModule(options).then((module) => {
         const { BasisFile, initializeBasis } = module;
         initializeBasis();
-        resolve({ BasisFile });
+        resolve2({ BasisFile });
       });
     });
   }
@@ -8453,11 +9328,11 @@
     if (wasmBinary) {
       options.wasmBinary = wasmBinary;
     }
-    return new Promise((resolve) => {
+    return new Promise((resolve2) => {
       BasisEncoderModule(options).then((module) => {
         const { BasisFile, KTX2File, initializeBasis, BasisEncoder } = module;
         initializeBasis();
-        resolve({ BasisFile, KTX2File, BasisEncoder });
+        resolve2({ BasisFile, KTX2File, BasisEncoder });
       });
     });
   }
@@ -8998,9 +9873,9 @@
       await image.decode();
       return image;
     }
-    return await new Promise((resolve, reject) => {
+    return await new Promise((resolve2, reject) => {
       try {
-        image.onload = () => resolve(image);
+        image.onload = () => resolve2(image);
         image.onerror = (err) => reject(new Error(`Could not load image ${url}: ${err}`));
       } catch (error) {
         reject(error);
@@ -9055,10 +9930,62 @@
     }
   });
 
+  // ../images/src/lib/category-api/parse-isobmff-binary.ts
+  function getISOBMFFMediaType(buffer) {
+    if (!checkString(buffer, "ftyp", 4)) {
+      return null;
+    }
+    if ((buffer[8] & 96) === 0) {
+      return null;
+    }
+    return decodeMajorBrand(buffer);
+  }
+  function decodeMajorBrand(buffer) {
+    const brandMajor = getUTF8String(buffer, 8, 12).replace("\0", " ").trim();
+    switch (brandMajor) {
+      case "avif":
+      case "avis":
+        return { extension: "avif", mimeType: "image/avif" };
+      default:
+        return null;
+    }
+  }
+  function getUTF8String(array, start, end) {
+    return String.fromCharCode(...array.slice(start, end));
+  }
+  function stringToBytes(string) {
+    return [...string].map((character) => character.charCodeAt(0));
+  }
+  function checkString(buffer, header, offset = 0) {
+    const headerBytes = stringToBytes(header);
+    for (let i2 = 0; i2 < headerBytes.length; ++i2) {
+      if (headerBytes[i2] !== buffer[i2 + offset]) {
+        return false;
+      }
+    }
+    return true;
+  }
+  var init_parse_isobmff_binary = __esm({
+    "../images/src/lib/category-api/parse-isobmff-binary.ts"() {
+    }
+  });
+
   // ../images/src/lib/category-api/binary-image-api.ts
   function getBinaryImageMetadata(binaryData) {
     const dataView = toDataView(binaryData);
-    return getPngMetadata(dataView) || getJpegMetadata(dataView) || getGifMetadata(dataView) || getBmpMetadata(dataView);
+    return getPngMetadata(dataView) || getJpegMetadata(dataView) || getGifMetadata(dataView) || getBmpMetadata(dataView) || getISOBMFFMetadata(dataView);
+  }
+  function getISOBMFFMetadata(binaryData) {
+    const buffer = new Uint8Array(binaryData instanceof DataView ? binaryData.buffer : binaryData);
+    const mediaType = getISOBMFFMediaType(buffer);
+    if (!mediaType) {
+      return null;
+    }
+    return {
+      mimeType: mediaType.mimeType,
+      width: 0,
+      height: 0
+    };
   }
   function getPngMetadata(binaryData) {
     const dataView = toDataView(binaryData);
@@ -9159,6 +10086,7 @@
   var BIG_ENDIAN, LITTLE_ENDIAN;
   var init_binary_image_api = __esm({
     "../images/src/lib/category-api/binary-image-api.ts"() {
+      init_parse_isobmff_binary();
       BIG_ENDIAN = false;
       LITTLE_ENDIAN = true;
     }
@@ -9232,12 +10160,13 @@
       init_version6();
       init_parse_image();
       init_binary_image_api();
-      EXTENSIONS = ["png", "jpg", "jpeg", "gif", "webp", "bmp", "ico", "svg"];
+      EXTENSIONS = ["png", "jpg", "jpeg", "gif", "webp", "bmp", "ico", "svg", "avif"];
       MIME_TYPES = [
         "image/png",
         "image/jpeg",
         "image/gif",
         "image/webp",
+        "image/avif",
         "image/bmp",
         "image/vnd.microsoft.icon",
         "image/svg+xml"
@@ -9263,43 +10192,41 @@
   });
 
   // ../images/src/lib/category-api/image-format.ts
-  function _isImageFormatSupported(mimeType) {
-    if (mimeTypeSupported[mimeType] === void 0) {
-      mimeTypeSupported[mimeType] = checkFormatSupport(mimeType);
+  function isImageFormatSupported(mimeType) {
+    if (mimeTypeSupportedSync[mimeType] === void 0) {
+      const supported = isBrowser ? checkBrowserImageFormatSupport(mimeType) : checkNodeImageFormatSupport(mimeType);
+      mimeTypeSupportedSync[mimeType] = supported;
     }
-    return mimeTypeSupported[mimeType];
+    return mimeTypeSupportedSync[mimeType];
   }
-  function checkFormatSupport(mimeType) {
+  function checkNodeImageFormatSupport(mimeType) {
+    const NODE_FORMAT_SUPPORT = ["image/png", "image/jpeg", "image/gif"];
+    const { _parseImageNode: _parseImageNode2, _imageFormatsNode = NODE_FORMAT_SUPPORT } = globalThis;
+    return Boolean(_parseImageNode2) && _imageFormatsNode.includes(mimeType);
+  }
+  function checkBrowserImageFormatSupport(mimeType) {
     switch (mimeType) {
+      case "image/avif":
       case "image/webp":
-        return checkWebPSupport();
-      case "image/svg":
-        return isBrowser;
+        return testBrowserImageFormatSupport(mimeType);
       default:
-        if (!isBrowser) {
-          const { _parseImageNode: _parseImageNode2 } = globalThis;
-          return Boolean(_parseImageNode2) && NODE_FORMAT_SUPPORT.includes(mimeType);
-        }
         return true;
     }
   }
-  function checkWebPSupport() {
-    if (!isBrowser) {
-      return false;
-    }
+  function testBrowserImageFormatSupport(mimeType) {
     try {
       const element = document.createElement("canvas");
-      return element.toDataURL("image/webp").indexOf("data:image/webp") === 0;
+      const dataURL = element.toDataURL(mimeType);
+      return dataURL.indexOf(`data:${mimeType}`) === 0;
     } catch {
       return false;
     }
   }
-  var NODE_FORMAT_SUPPORT, mimeTypeSupported;
+  var mimeTypeSupportedSync;
   var init_image_format = __esm({
     "../images/src/lib/category-api/image-format.ts"() {
       init_src2();
-      NODE_FORMAT_SUPPORT = ["image/png", "image/jpeg", "image/gif"];
-      mimeTypeSupported = {};
+      mimeTypeSupportedSync = {};
     }
   });
 
@@ -9638,8 +10565,8 @@
           this.json.scenes.push({ nodes: nodeIndices });
           return this.json.scenes.length - 1;
         }
-        addNode(node2) {
-          const { meshIndex, matrix } = node2;
+        addNode(node3) {
+          const { meshIndex, matrix } = node3;
           this.json.nodes = this.json.nodes || [];
           const nodeData = { mesh: meshIndex };
           if (matrix) {
@@ -9849,12 +10776,12 @@
     return wasmPromise;
   }
   async function loadWasmModule() {
-    let wasm = wasm_base;
+    let wasm2 = wasm_base;
     if (WebAssembly.validate(detector)) {
-      wasm = wasm_simd;
+      wasm2 = wasm_simd;
       console.log("Warning: meshopt_decoder is using experimental SIMD support");
     }
-    const result = await WebAssembly.instantiate(unpack(wasm), {});
+    const result = await WebAssembly.instantiate(unpack(wasm2), {});
     await result.instance.exports.__wasm_call_ctors();
     return result.instance;
   }
@@ -10084,7 +11011,7 @@
   });
   function preprocess(gltfData, options) {
     const scenegraph = new GLTFScenegraph(gltfData);
-    if (!_isImageFormatSupported("image/webp")) {
+    if (!isImageFormatSupported("image/webp")) {
       if (scenegraph.getRequiredExtensions().includes(EXT_TEXTURE_WEBP)) {
         throw new Error(`gltf: Required extension ${EXT_TEXTURE_WEBP} not supported by browser`);
       }
@@ -10419,9 +11346,9 @@
           const result = new Float32Array(length4);
           for (let i2 = 0; i2 < accessor.count; i2++) {
             const uv = new ArrayType(arrayBuffer, byteOffset + i2 * elementAddressScale, 2);
-            scratchVector5.set(uv[0], uv[1], 1);
-            scratchVector5.transformByMatrix3(matrix);
-            result.set([scratchVector5[0], scratchVector5[1]], i2 * components);
+            scratchVector7.set(uv[0], uv[1], 1);
+            scratchVector7.transformByMatrix3(matrix);
+            result.set([scratchVector7[0], scratchVector7[1]], i2 * components);
           }
           if (originalTexCoord === texCoord) {
             updateGltf(accessor, bufferView, gltfData.buffers, result);
@@ -10479,7 +11406,7 @@
     const scaleMatrix = scratchScaleMatrix.set(scale5[0], 0, 0, 0, scale5[1], 0, 0, 0, 1);
     return translationMatirx.multiplyRight(rotationMatirx).multiplyRight(scaleMatrix);
   }
-  var EXT_MESHOPT_TRANSFORM, name5, scratchVector5, scratchRotationMatrix, scratchScaleMatrix;
+  var EXT_MESHOPT_TRANSFORM, name5, scratchVector7, scratchRotationMatrix, scratchScaleMatrix;
   var init_KHR_texture_transform = __esm({
     "../gltf/src/lib/extensions/KHR_texture_transform.ts"() {
       init_esm();
@@ -10488,7 +11415,7 @@
       init_gltf_scenegraph();
       EXT_MESHOPT_TRANSFORM = "KHR_texture_transform";
       name5 = EXT_MESHOPT_TRANSFORM;
-      scratchVector5 = new Vector3();
+      scratchVector7 = new Vector3();
       scratchRotationMatrix = new Matrix3();
       scratchScaleMatrix = new Matrix3();
     }
@@ -10509,12 +11436,12 @@
       gltfScenegraph.json.lights = extension.lights;
       gltfScenegraph.removeExtension(KHR_LIGHTS_PUNCTUAL);
     }
-    for (const node2 of json.nodes || []) {
-      const nodeExtension = gltfScenegraph.getObjectExtension(node2, KHR_LIGHTS_PUNCTUAL);
+    for (const node3 of json.nodes || []) {
+      const nodeExtension = gltfScenegraph.getObjectExtension(node3, KHR_LIGHTS_PUNCTUAL);
       if (nodeExtension) {
-        node2.light = nodeExtension.light;
+        node3.light = nodeExtension.light;
       }
-      gltfScenegraph.removeObjectExtension(node2, KHR_LIGHTS_PUNCTUAL);
+      gltfScenegraph.removeObjectExtension(node3, KHR_LIGHTS_PUNCTUAL);
     }
   }
   async function encode2(gltfData) {
@@ -10528,8 +11455,8 @@
     }
     if (gltfScenegraph.json.lights) {
       for (const light of gltfScenegraph.json.lights) {
-        const node2 = light.node;
-        gltfScenegraph.addObjectExtension(node2, KHR_LIGHTS_PUNCTUAL, light);
+        const node3 = light.node;
+        gltfScenegraph.addObjectExtension(node3, KHR_LIGHTS_PUNCTUAL, light);
       }
       delete gltfScenegraph.json.lights;
     }
@@ -10920,11 +11847,11 @@
           for (const mesh of json.meshes) {
             this._convertMeshIds(mesh);
           }
-          for (const node2 of json.nodes) {
-            this._convertNodeIds(node2);
+          for (const node3 of json.nodes) {
+            this._convertNodeIds(node3);
           }
-          for (const node2 of json.scenes) {
-            this._convertSceneIds(node2);
+          for (const node3 of json.scenes) {
+            this._convertSceneIds(node3);
           }
         }
         _convertTextureIds(texture) {
@@ -10946,17 +11873,17 @@
             }
           }
         }
-        _convertNodeIds(node2) {
-          if (node2.children) {
-            node2.children = node2.children.map((child) => this._convertIdToIndex(child, "node"));
+        _convertNodeIds(node3) {
+          if (node3.children) {
+            node3.children = node3.children.map((child) => this._convertIdToIndex(child, "node"));
           }
-          if (node2.meshes) {
-            node2.meshes = node2.meshes.map((mesh) => this._convertIdToIndex(mesh, "mesh"));
+          if (node3.meshes) {
+            node3.meshes = node3.meshes.map((mesh) => this._convertIdToIndex(mesh, "mesh"));
           }
         }
         _convertSceneIds(scene) {
           if (scene.nodes) {
-            scene.nodes = scene.nodes.map((node2) => this._convertIdToIndex(node2, "node"));
+            scene.nodes = scene.nodes.map((node3) => this._convertIdToIndex(node3, "node"));
           }
         }
         _convertIdsToIndices(json, topLevelArrayName) {
@@ -11099,7 +12026,7 @@
             json.meshes = json.meshes.map((mesh, i2) => this._resolveMesh(mesh, i2));
           }
           if (json.nodes) {
-            json.nodes = json.nodes.map((node2, i2) => this._resolveNode(node2, i2));
+            json.nodes = json.nodes.map((node3, i2) => this._resolveNode(node3, i2));
           }
           if (json.skins) {
             json.skins = json.skins.map((skin, i2) => this._resolveSkin(skin, i2));
@@ -11159,31 +12086,31 @@
         }
         _resolveScene(scene, index) {
           scene.id = scene.id || `scene-${index}`;
-          scene.nodes = (scene.nodes || []).map((node2) => this.getNode(node2));
+          scene.nodes = (scene.nodes || []).map((node3) => this.getNode(node3));
           return scene;
         }
-        _resolveNode(node2, index) {
-          node2.id = node2.id || `node-${index}`;
-          if (node2.children) {
-            node2.children = node2.children.map((child) => this.getNode(child));
+        _resolveNode(node3, index) {
+          node3.id = node3.id || `node-${index}`;
+          if (node3.children) {
+            node3.children = node3.children.map((child) => this.getNode(child));
           }
-          if (node2.mesh !== void 0) {
-            node2.mesh = this.getMesh(node2.mesh);
-          } else if (node2.meshes !== void 0 && node2.meshes.length) {
-            node2.mesh = node2.meshes.reduce((accum, meshIndex) => {
+          if (node3.mesh !== void 0) {
+            node3.mesh = this.getMesh(node3.mesh);
+          } else if (node3.meshes !== void 0 && node3.meshes.length) {
+            node3.mesh = node3.meshes.reduce((accum, meshIndex) => {
               const mesh = this.getMesh(meshIndex);
               accum.id = mesh.id;
               accum.primitives = accum.primitives.concat(mesh.primitives);
               return accum;
             }, { primitives: [] });
           }
-          if (node2.camera !== void 0) {
-            node2.camera = this.getCamera(node2.camera);
+          if (node3.camera !== void 0) {
+            node3.camera = this.getCamera(node3.camera);
           }
-          if (node2.skin !== void 0) {
-            node2.skin = this.getSkin(node2.skin);
+          if (node3.skin !== void 0) {
+            node3.skin = this.getSkin(node3.skin);
           }
-          return node2;
+          return node3;
         }
         _resolveSkin(skin, index) {
           skin.id = skin.id || `skin-${index}`;
@@ -11781,7 +12708,7 @@
     const scratch1 = [];
     const scratch2 = [];
     const scratchVector12 = new Vector3();
-    const scratchVector24 = new Vector3();
+    const scratchVector26 = new Vector3();
     for (let i2 = 0; i2 < instancesLength; i2++) {
       let position;
       if (featureTable.hasProperty("POSITION")) {
@@ -11792,7 +12719,7 @@
         if (!quantizedVolumeOffset) {
           throw new Error("i3dm parser: QUANTIZED_VOLUME_OFFSET must be defined for quantized positions.");
         }
-        const quantizedVolumeScale = featureTable.getGlobalProperty("QUANTIZED_VOLUME_SCALE", GL2.FLOAT, 3, scratchVector24);
+        const quantizedVolumeScale = featureTable.getGlobalProperty("QUANTIZED_VOLUME_SCALE", GL2.FLOAT, 3, scratchVector26);
         if (!quantizedVolumeScale) {
           throw new Error("i3dm parser: QUANTIZED_VOLUME_SCALE must be defined for quantized positions.");
         }
@@ -11931,7 +12858,7 @@
   }
   var init_parse_3d_tile = __esm({
     "src/lib/parsers/parse-3d-tile.ts"() {
-      init_constants3();
+      init_constants4();
       init_parse_utils();
       init_parse_3d_tile_point_cloud();
       init_parse_3d_tile_batched_model();
@@ -12034,7 +12961,1260 @@
     }
   });
 
+  // ../../node_modules/long/index.js
+  function Long(low, high, unsigned) {
+    this.low = low | 0;
+    this.high = high | 0;
+    this.unsigned = !!unsigned;
+  }
+  function isLong(obj) {
+    return (obj && obj["__isLong__"]) === true;
+  }
+  function ctz32(value) {
+    var c = Math.clz32(value & -value);
+    return value ? 31 - c : c;
+  }
+  function fromInt(value, unsigned) {
+    var obj, cachedObj, cache2;
+    if (unsigned) {
+      value >>>= 0;
+      if (cache2 = 0 <= value && value < 256) {
+        cachedObj = UINT_CACHE[value];
+        if (cachedObj)
+          return cachedObj;
+      }
+      obj = fromBits(value, 0, true);
+      if (cache2)
+        UINT_CACHE[value] = obj;
+      return obj;
+    } else {
+      value |= 0;
+      if (cache2 = -128 <= value && value < 128) {
+        cachedObj = INT_CACHE[value];
+        if (cachedObj)
+          return cachedObj;
+      }
+      obj = fromBits(value, value < 0 ? -1 : 0, false);
+      if (cache2)
+        INT_CACHE[value] = obj;
+      return obj;
+    }
+  }
+  function fromNumber(value, unsigned) {
+    if (isNaN(value))
+      return unsigned ? UZERO : ZERO4;
+    if (unsigned) {
+      if (value < 0)
+        return UZERO;
+      if (value >= TWO_PWR_64_DBL)
+        return MAX_UNSIGNED_VALUE;
+    } else {
+      if (value <= -TWO_PWR_63_DBL)
+        return MIN_VALUE;
+      if (value + 1 >= TWO_PWR_63_DBL)
+        return MAX_VALUE;
+    }
+    if (value < 0)
+      return fromNumber(-value, unsigned).neg();
+    return fromBits(value % TWO_PWR_32_DBL | 0, value / TWO_PWR_32_DBL | 0, unsigned);
+  }
+  function fromBits(lowBits, highBits, unsigned) {
+    return new Long(lowBits, highBits, unsigned);
+  }
+  function fromString(str, unsigned, radix) {
+    if (str.length === 0)
+      throw Error("empty string");
+    if (typeof unsigned === "number") {
+      radix = unsigned;
+      unsigned = false;
+    } else {
+      unsigned = !!unsigned;
+    }
+    if (str === "NaN" || str === "Infinity" || str === "+Infinity" || str === "-Infinity")
+      return unsigned ? UZERO : ZERO4;
+    radix = radix || 10;
+    if (radix < 2 || 36 < radix)
+      throw RangeError("radix");
+    var p2;
+    if ((p2 = str.indexOf("-")) > 0)
+      throw Error("interior hyphen");
+    else if (p2 === 0) {
+      return fromString(str.substring(1), unsigned, radix).neg();
+    }
+    var radixToPower = fromNumber(pow_dbl(radix, 8));
+    var result = ZERO4;
+    for (var i2 = 0; i2 < str.length; i2 += 8) {
+      var size = Math.min(8, str.length - i2), value = parseInt(str.substring(i2, i2 + size), radix);
+      if (size < 8) {
+        var power = fromNumber(pow_dbl(radix, size));
+        result = result.mul(power).add(fromNumber(value));
+      } else {
+        result = result.mul(radixToPower);
+        result = result.add(fromNumber(value));
+      }
+    }
+    result.unsigned = unsigned;
+    return result;
+  }
+  function fromValue(val, unsigned) {
+    if (typeof val === "number")
+      return fromNumber(val, unsigned);
+    if (typeof val === "string")
+      return fromString(val, unsigned);
+    return fromBits(val.low, val.high, typeof unsigned === "boolean" ? unsigned : val.unsigned);
+  }
+  var wasm, INT_CACHE, UINT_CACHE, pow_dbl, TWO_PWR_16_DBL, TWO_PWR_24_DBL, TWO_PWR_32_DBL, TWO_PWR_64_DBL, TWO_PWR_63_DBL, TWO_PWR_24, ZERO4, UZERO, ONE, UONE, NEG_ONE, MAX_VALUE, MAX_UNSIGNED_VALUE, MIN_VALUE, LongPrototype, long_default;
+  var init_long = __esm({
+    "../../node_modules/long/index.js"() {
+      wasm = null;
+      try {
+        wasm = new WebAssembly.Instance(new WebAssembly.Module(new Uint8Array([
+          0,
+          97,
+          115,
+          109,
+          1,
+          0,
+          0,
+          0,
+          1,
+          13,
+          2,
+          96,
+          0,
+          1,
+          127,
+          96,
+          4,
+          127,
+          127,
+          127,
+          127,
+          1,
+          127,
+          3,
+          7,
+          6,
+          0,
+          1,
+          1,
+          1,
+          1,
+          1,
+          6,
+          6,
+          1,
+          127,
+          1,
+          65,
+          0,
+          11,
+          7,
+          50,
+          6,
+          3,
+          109,
+          117,
+          108,
+          0,
+          1,
+          5,
+          100,
+          105,
+          118,
+          95,
+          115,
+          0,
+          2,
+          5,
+          100,
+          105,
+          118,
+          95,
+          117,
+          0,
+          3,
+          5,
+          114,
+          101,
+          109,
+          95,
+          115,
+          0,
+          4,
+          5,
+          114,
+          101,
+          109,
+          95,
+          117,
+          0,
+          5,
+          8,
+          103,
+          101,
+          116,
+          95,
+          104,
+          105,
+          103,
+          104,
+          0,
+          0,
+          10,
+          191,
+          1,
+          6,
+          4,
+          0,
+          35,
+          0,
+          11,
+          36,
+          1,
+          1,
+          126,
+          32,
+          0,
+          173,
+          32,
+          1,
+          173,
+          66,
+          32,
+          134,
+          132,
+          32,
+          2,
+          173,
+          32,
+          3,
+          173,
+          66,
+          32,
+          134,
+          132,
+          126,
+          34,
+          4,
+          66,
+          32,
+          135,
+          167,
+          36,
+          0,
+          32,
+          4,
+          167,
+          11,
+          36,
+          1,
+          1,
+          126,
+          32,
+          0,
+          173,
+          32,
+          1,
+          173,
+          66,
+          32,
+          134,
+          132,
+          32,
+          2,
+          173,
+          32,
+          3,
+          173,
+          66,
+          32,
+          134,
+          132,
+          127,
+          34,
+          4,
+          66,
+          32,
+          135,
+          167,
+          36,
+          0,
+          32,
+          4,
+          167,
+          11,
+          36,
+          1,
+          1,
+          126,
+          32,
+          0,
+          173,
+          32,
+          1,
+          173,
+          66,
+          32,
+          134,
+          132,
+          32,
+          2,
+          173,
+          32,
+          3,
+          173,
+          66,
+          32,
+          134,
+          132,
+          128,
+          34,
+          4,
+          66,
+          32,
+          135,
+          167,
+          36,
+          0,
+          32,
+          4,
+          167,
+          11,
+          36,
+          1,
+          1,
+          126,
+          32,
+          0,
+          173,
+          32,
+          1,
+          173,
+          66,
+          32,
+          134,
+          132,
+          32,
+          2,
+          173,
+          32,
+          3,
+          173,
+          66,
+          32,
+          134,
+          132,
+          129,
+          34,
+          4,
+          66,
+          32,
+          135,
+          167,
+          36,
+          0,
+          32,
+          4,
+          167,
+          11,
+          36,
+          1,
+          1,
+          126,
+          32,
+          0,
+          173,
+          32,
+          1,
+          173,
+          66,
+          32,
+          134,
+          132,
+          32,
+          2,
+          173,
+          32,
+          3,
+          173,
+          66,
+          32,
+          134,
+          132,
+          130,
+          34,
+          4,
+          66,
+          32,
+          135,
+          167,
+          36,
+          0,
+          32,
+          4,
+          167,
+          11
+        ])), {}).exports;
+      } catch (e) {
+      }
+      Long.prototype.__isLong__;
+      Object.defineProperty(Long.prototype, "__isLong__", { value: true });
+      Long.isLong = isLong;
+      INT_CACHE = {};
+      UINT_CACHE = {};
+      Long.fromInt = fromInt;
+      Long.fromNumber = fromNumber;
+      Long.fromBits = fromBits;
+      pow_dbl = Math.pow;
+      Long.fromString = fromString;
+      Long.fromValue = fromValue;
+      TWO_PWR_16_DBL = 1 << 16;
+      TWO_PWR_24_DBL = 1 << 24;
+      TWO_PWR_32_DBL = TWO_PWR_16_DBL * TWO_PWR_16_DBL;
+      TWO_PWR_64_DBL = TWO_PWR_32_DBL * TWO_PWR_32_DBL;
+      TWO_PWR_63_DBL = TWO_PWR_64_DBL / 2;
+      TWO_PWR_24 = fromInt(TWO_PWR_24_DBL);
+      ZERO4 = fromInt(0);
+      Long.ZERO = ZERO4;
+      UZERO = fromInt(0, true);
+      Long.UZERO = UZERO;
+      ONE = fromInt(1);
+      Long.ONE = ONE;
+      UONE = fromInt(1, true);
+      Long.UONE = UONE;
+      NEG_ONE = fromInt(-1);
+      Long.NEG_ONE = NEG_ONE;
+      MAX_VALUE = fromBits(4294967295 | 0, 2147483647 | 0, false);
+      Long.MAX_VALUE = MAX_VALUE;
+      MAX_UNSIGNED_VALUE = fromBits(4294967295 | 0, 4294967295 | 0, true);
+      Long.MAX_UNSIGNED_VALUE = MAX_UNSIGNED_VALUE;
+      MIN_VALUE = fromBits(0, 2147483648 | 0, false);
+      Long.MIN_VALUE = MIN_VALUE;
+      LongPrototype = Long.prototype;
+      LongPrototype.toInt = function toInt() {
+        return this.unsigned ? this.low >>> 0 : this.low;
+      };
+      LongPrototype.toNumber = function toNumber() {
+        if (this.unsigned)
+          return (this.high >>> 0) * TWO_PWR_32_DBL + (this.low >>> 0);
+        return this.high * TWO_PWR_32_DBL + (this.low >>> 0);
+      };
+      LongPrototype.toString = function toString(radix) {
+        radix = radix || 10;
+        if (radix < 2 || 36 < radix)
+          throw RangeError("radix");
+        if (this.isZero())
+          return "0";
+        if (this.isNegative()) {
+          if (this.eq(MIN_VALUE)) {
+            var radixLong = fromNumber(radix), div = this.div(radixLong), rem1 = div.mul(radixLong).sub(this);
+            return div.toString(radix) + rem1.toInt().toString(radix);
+          } else
+            return "-" + this.neg().toString(radix);
+        }
+        var radixToPower = fromNumber(pow_dbl(radix, 6), this.unsigned), rem = this;
+        var result = "";
+        while (true) {
+          var remDiv = rem.div(radixToPower), intval = rem.sub(remDiv.mul(radixToPower)).toInt() >>> 0, digits = intval.toString(radix);
+          rem = remDiv;
+          if (rem.isZero())
+            return digits + result;
+          else {
+            while (digits.length < 6)
+              digits = "0" + digits;
+            result = "" + digits + result;
+          }
+        }
+      };
+      LongPrototype.getHighBits = function getHighBits() {
+        return this.high;
+      };
+      LongPrototype.getHighBitsUnsigned = function getHighBitsUnsigned() {
+        return this.high >>> 0;
+      };
+      LongPrototype.getLowBits = function getLowBits() {
+        return this.low;
+      };
+      LongPrototype.getLowBitsUnsigned = function getLowBitsUnsigned() {
+        return this.low >>> 0;
+      };
+      LongPrototype.getNumBitsAbs = function getNumBitsAbs() {
+        if (this.isNegative())
+          return this.eq(MIN_VALUE) ? 64 : this.neg().getNumBitsAbs();
+        var val = this.high != 0 ? this.high : this.low;
+        for (var bit = 31; bit > 0; bit--)
+          if ((val & 1 << bit) != 0)
+            break;
+        return this.high != 0 ? bit + 33 : bit + 1;
+      };
+      LongPrototype.isZero = function isZero() {
+        return this.high === 0 && this.low === 0;
+      };
+      LongPrototype.eqz = LongPrototype.isZero;
+      LongPrototype.isNegative = function isNegative() {
+        return !this.unsigned && this.high < 0;
+      };
+      LongPrototype.isPositive = function isPositive() {
+        return this.unsigned || this.high >= 0;
+      };
+      LongPrototype.isOdd = function isOdd() {
+        return (this.low & 1) === 1;
+      };
+      LongPrototype.isEven = function isEven() {
+        return (this.low & 1) === 0;
+      };
+      LongPrototype.equals = function equals3(other) {
+        if (!isLong(other))
+          other = fromValue(other);
+        if (this.unsigned !== other.unsigned && this.high >>> 31 === 1 && other.high >>> 31 === 1)
+          return false;
+        return this.high === other.high && this.low === other.low;
+      };
+      LongPrototype.eq = LongPrototype.equals;
+      LongPrototype.notEquals = function notEquals(other) {
+        return !this.eq(other);
+      };
+      LongPrototype.neq = LongPrototype.notEquals;
+      LongPrototype.ne = LongPrototype.notEquals;
+      LongPrototype.lessThan = function lessThan(other) {
+        return this.comp(other) < 0;
+      };
+      LongPrototype.lt = LongPrototype.lessThan;
+      LongPrototype.lessThanOrEqual = function lessThanOrEqual(other) {
+        return this.comp(other) <= 0;
+      };
+      LongPrototype.lte = LongPrototype.lessThanOrEqual;
+      LongPrototype.le = LongPrototype.lessThanOrEqual;
+      LongPrototype.greaterThan = function greaterThan(other) {
+        return this.comp(other) > 0;
+      };
+      LongPrototype.gt = LongPrototype.greaterThan;
+      LongPrototype.greaterThanOrEqual = function greaterThanOrEqual(other) {
+        return this.comp(other) >= 0;
+      };
+      LongPrototype.gte = LongPrototype.greaterThanOrEqual;
+      LongPrototype.ge = LongPrototype.greaterThanOrEqual;
+      LongPrototype.compare = function compare(other) {
+        if (!isLong(other))
+          other = fromValue(other);
+        if (this.eq(other))
+          return 0;
+        var thisNeg = this.isNegative(), otherNeg = other.isNegative();
+        if (thisNeg && !otherNeg)
+          return -1;
+        if (!thisNeg && otherNeg)
+          return 1;
+        if (!this.unsigned)
+          return this.sub(other).isNegative() ? -1 : 1;
+        return other.high >>> 0 > this.high >>> 0 || other.high === this.high && other.low >>> 0 > this.low >>> 0 ? -1 : 1;
+      };
+      LongPrototype.comp = LongPrototype.compare;
+      LongPrototype.negate = function negate() {
+        if (!this.unsigned && this.eq(MIN_VALUE))
+          return MIN_VALUE;
+        return this.not().add(ONE);
+      };
+      LongPrototype.neg = LongPrototype.negate;
+      LongPrototype.add = function add3(addend) {
+        if (!isLong(addend))
+          addend = fromValue(addend);
+        var a48 = this.high >>> 16;
+        var a32 = this.high & 65535;
+        var a16 = this.low >>> 16;
+        var a00 = this.low & 65535;
+        var b48 = addend.high >>> 16;
+        var b32 = addend.high & 65535;
+        var b16 = addend.low >>> 16;
+        var b00 = addend.low & 65535;
+        var c48 = 0, c32 = 0, c16 = 0, c00 = 0;
+        c00 += a00 + b00;
+        c16 += c00 >>> 16;
+        c00 &= 65535;
+        c16 += a16 + b16;
+        c32 += c16 >>> 16;
+        c16 &= 65535;
+        c32 += a32 + b32;
+        c48 += c32 >>> 16;
+        c32 &= 65535;
+        c48 += a48 + b48;
+        c48 &= 65535;
+        return fromBits(c16 << 16 | c00, c48 << 16 | c32, this.unsigned);
+      };
+      LongPrototype.subtract = function subtract(subtrahend) {
+        if (!isLong(subtrahend))
+          subtrahend = fromValue(subtrahend);
+        return this.add(subtrahend.neg());
+      };
+      LongPrototype.sub = LongPrototype.subtract;
+      LongPrototype.multiply = function multiply4(multiplier) {
+        if (this.isZero())
+          return this;
+        if (!isLong(multiplier))
+          multiplier = fromValue(multiplier);
+        if (wasm) {
+          var low = wasm["mul"](this.low, this.high, multiplier.low, multiplier.high);
+          return fromBits(low, wasm["get_high"](), this.unsigned);
+        }
+        if (multiplier.isZero())
+          return this.unsigned ? UZERO : ZERO4;
+        if (this.eq(MIN_VALUE))
+          return multiplier.isOdd() ? MIN_VALUE : ZERO4;
+        if (multiplier.eq(MIN_VALUE))
+          return this.isOdd() ? MIN_VALUE : ZERO4;
+        if (this.isNegative()) {
+          if (multiplier.isNegative())
+            return this.neg().mul(multiplier.neg());
+          else
+            return this.neg().mul(multiplier).neg();
+        } else if (multiplier.isNegative())
+          return this.mul(multiplier.neg()).neg();
+        if (this.lt(TWO_PWR_24) && multiplier.lt(TWO_PWR_24))
+          return fromNumber(this.toNumber() * multiplier.toNumber(), this.unsigned);
+        var a48 = this.high >>> 16;
+        var a32 = this.high & 65535;
+        var a16 = this.low >>> 16;
+        var a00 = this.low & 65535;
+        var b48 = multiplier.high >>> 16;
+        var b32 = multiplier.high & 65535;
+        var b16 = multiplier.low >>> 16;
+        var b00 = multiplier.low & 65535;
+        var c48 = 0, c32 = 0, c16 = 0, c00 = 0;
+        c00 += a00 * b00;
+        c16 += c00 >>> 16;
+        c00 &= 65535;
+        c16 += a16 * b00;
+        c32 += c16 >>> 16;
+        c16 &= 65535;
+        c16 += a00 * b16;
+        c32 += c16 >>> 16;
+        c16 &= 65535;
+        c32 += a32 * b00;
+        c48 += c32 >>> 16;
+        c32 &= 65535;
+        c32 += a16 * b16;
+        c48 += c32 >>> 16;
+        c32 &= 65535;
+        c32 += a00 * b32;
+        c48 += c32 >>> 16;
+        c32 &= 65535;
+        c48 += a48 * b00 + a32 * b16 + a16 * b32 + a00 * b48;
+        c48 &= 65535;
+        return fromBits(c16 << 16 | c00, c48 << 16 | c32, this.unsigned);
+      };
+      LongPrototype.mul = LongPrototype.multiply;
+      LongPrototype.divide = function divide(divisor) {
+        if (!isLong(divisor))
+          divisor = fromValue(divisor);
+        if (divisor.isZero())
+          throw Error("division by zero");
+        if (wasm) {
+          if (!this.unsigned && this.high === -2147483648 && divisor.low === -1 && divisor.high === -1) {
+            return this;
+          }
+          var low = (this.unsigned ? wasm["div_u"] : wasm["div_s"])(this.low, this.high, divisor.low, divisor.high);
+          return fromBits(low, wasm["get_high"](), this.unsigned);
+        }
+        if (this.isZero())
+          return this.unsigned ? UZERO : ZERO4;
+        var approx, rem, res;
+        if (!this.unsigned) {
+          if (this.eq(MIN_VALUE)) {
+            if (divisor.eq(ONE) || divisor.eq(NEG_ONE))
+              return MIN_VALUE;
+            else if (divisor.eq(MIN_VALUE))
+              return ONE;
+            else {
+              var halfThis = this.shr(1);
+              approx = halfThis.div(divisor).shl(1);
+              if (approx.eq(ZERO4)) {
+                return divisor.isNegative() ? ONE : NEG_ONE;
+              } else {
+                rem = this.sub(divisor.mul(approx));
+                res = approx.add(rem.div(divisor));
+                return res;
+              }
+            }
+          } else if (divisor.eq(MIN_VALUE))
+            return this.unsigned ? UZERO : ZERO4;
+          if (this.isNegative()) {
+            if (divisor.isNegative())
+              return this.neg().div(divisor.neg());
+            return this.neg().div(divisor).neg();
+          } else if (divisor.isNegative())
+            return this.div(divisor.neg()).neg();
+          res = ZERO4;
+        } else {
+          if (!divisor.unsigned)
+            divisor = divisor.toUnsigned();
+          if (divisor.gt(this))
+            return UZERO;
+          if (divisor.gt(this.shru(1)))
+            return UONE;
+          res = UZERO;
+        }
+        rem = this;
+        while (rem.gte(divisor)) {
+          approx = Math.max(1, Math.floor(rem.toNumber() / divisor.toNumber()));
+          var log2 = Math.ceil(Math.log(approx) / Math.LN2), delta = log2 <= 48 ? 1 : pow_dbl(2, log2 - 48), approxRes = fromNumber(approx), approxRem = approxRes.mul(divisor);
+          while (approxRem.isNegative() || approxRem.gt(rem)) {
+            approx -= delta;
+            approxRes = fromNumber(approx, this.unsigned);
+            approxRem = approxRes.mul(divisor);
+          }
+          if (approxRes.isZero())
+            approxRes = ONE;
+          res = res.add(approxRes);
+          rem = rem.sub(approxRem);
+        }
+        return res;
+      };
+      LongPrototype.div = LongPrototype.divide;
+      LongPrototype.modulo = function modulo(divisor) {
+        if (!isLong(divisor))
+          divisor = fromValue(divisor);
+        if (wasm) {
+          var low = (this.unsigned ? wasm["rem_u"] : wasm["rem_s"])(this.low, this.high, divisor.low, divisor.high);
+          return fromBits(low, wasm["get_high"](), this.unsigned);
+        }
+        return this.sub(this.div(divisor).mul(divisor));
+      };
+      LongPrototype.mod = LongPrototype.modulo;
+      LongPrototype.rem = LongPrototype.modulo;
+      LongPrototype.not = function not() {
+        return fromBits(~this.low, ~this.high, this.unsigned);
+      };
+      LongPrototype.countLeadingZeros = function countLeadingZeros() {
+        return this.high ? Math.clz32(this.high) : Math.clz32(this.low) + 32;
+      };
+      LongPrototype.clz = LongPrototype.countLeadingZeros;
+      LongPrototype.countTrailingZeros = function countTrailingZeros() {
+        return this.low ? ctz32(this.low) : ctz32(this.high) + 32;
+      };
+      LongPrototype.ctz = LongPrototype.countTrailingZeros;
+      LongPrototype.and = function and(other) {
+        if (!isLong(other))
+          other = fromValue(other);
+        return fromBits(this.low & other.low, this.high & other.high, this.unsigned);
+      };
+      LongPrototype.or = function or(other) {
+        if (!isLong(other))
+          other = fromValue(other);
+        return fromBits(this.low | other.low, this.high | other.high, this.unsigned);
+      };
+      LongPrototype.xor = function xor(other) {
+        if (!isLong(other))
+          other = fromValue(other);
+        return fromBits(this.low ^ other.low, this.high ^ other.high, this.unsigned);
+      };
+      LongPrototype.shiftLeft = function shiftLeft(numBits) {
+        if (isLong(numBits))
+          numBits = numBits.toInt();
+        if ((numBits &= 63) === 0)
+          return this;
+        else if (numBits < 32)
+          return fromBits(this.low << numBits, this.high << numBits | this.low >>> 32 - numBits, this.unsigned);
+        else
+          return fromBits(0, this.low << numBits - 32, this.unsigned);
+      };
+      LongPrototype.shl = LongPrototype.shiftLeft;
+      LongPrototype.shiftRight = function shiftRight(numBits) {
+        if (isLong(numBits))
+          numBits = numBits.toInt();
+        if ((numBits &= 63) === 0)
+          return this;
+        else if (numBits < 32)
+          return fromBits(this.low >>> numBits | this.high << 32 - numBits, this.high >> numBits, this.unsigned);
+        else
+          return fromBits(this.high >> numBits - 32, this.high >= 0 ? 0 : -1, this.unsigned);
+      };
+      LongPrototype.shr = LongPrototype.shiftRight;
+      LongPrototype.shiftRightUnsigned = function shiftRightUnsigned(numBits) {
+        if (isLong(numBits))
+          numBits = numBits.toInt();
+        if ((numBits &= 63) === 0)
+          return this;
+        if (numBits < 32)
+          return fromBits(this.low >>> numBits | this.high << 32 - numBits, this.high >>> numBits, this.unsigned);
+        if (numBits === 32)
+          return fromBits(this.high, 0, this.unsigned);
+        return fromBits(this.high >>> numBits - 32, 0, this.unsigned);
+      };
+      LongPrototype.shru = LongPrototype.shiftRightUnsigned;
+      LongPrototype.shr_u = LongPrototype.shiftRightUnsigned;
+      LongPrototype.rotateLeft = function rotateLeft(numBits) {
+        var b;
+        if (isLong(numBits))
+          numBits = numBits.toInt();
+        if ((numBits &= 63) === 0)
+          return this;
+        if (numBits === 32)
+          return fromBits(this.high, this.low, this.unsigned);
+        if (numBits < 32) {
+          b = 32 - numBits;
+          return fromBits(this.low << numBits | this.high >>> b, this.high << numBits | this.low >>> b, this.unsigned);
+        }
+        numBits -= 32;
+        b = 32 - numBits;
+        return fromBits(this.high << numBits | this.low >>> b, this.low << numBits | this.high >>> b, this.unsigned);
+      };
+      LongPrototype.rotl = LongPrototype.rotateLeft;
+      LongPrototype.rotateRight = function rotateRight(numBits) {
+        var b;
+        if (isLong(numBits))
+          numBits = numBits.toInt();
+        if ((numBits &= 63) === 0)
+          return this;
+        if (numBits === 32)
+          return fromBits(this.high, this.low, this.unsigned);
+        if (numBits < 32) {
+          b = 32 - numBits;
+          return fromBits(this.high << b | this.low >>> numBits, this.low << b | this.high >>> numBits, this.unsigned);
+        }
+        numBits -= 32;
+        b = 32 - numBits;
+        return fromBits(this.low << b | this.high >>> numBits, this.high << b | this.low >>> numBits, this.unsigned);
+      };
+      LongPrototype.rotr = LongPrototype.rotateRight;
+      LongPrototype.toSigned = function toSigned() {
+        if (!this.unsigned)
+          return this;
+        return fromBits(this.low, this.high, false);
+      };
+      LongPrototype.toUnsigned = function toUnsigned() {
+        if (this.unsigned)
+          return this;
+        return fromBits(this.low, this.high, true);
+      };
+      LongPrototype.toBytes = function toBytes(le) {
+        return le ? this.toBytesLE() : this.toBytesBE();
+      };
+      LongPrototype.toBytesLE = function toBytesLE() {
+        var hi = this.high, lo = this.low;
+        return [
+          lo & 255,
+          lo >>> 8 & 255,
+          lo >>> 16 & 255,
+          lo >>> 24,
+          hi & 255,
+          hi >>> 8 & 255,
+          hi >>> 16 & 255,
+          hi >>> 24
+        ];
+      };
+      LongPrototype.toBytesBE = function toBytesBE() {
+        var hi = this.high, lo = this.low;
+        return [
+          hi >>> 24,
+          hi >>> 16 & 255,
+          hi >>> 8 & 255,
+          hi & 255,
+          lo >>> 24,
+          lo >>> 16 & 255,
+          lo >>> 8 & 255,
+          lo & 255
+        ];
+      };
+      Long.fromBytes = function fromBytes(bytes, unsigned, le) {
+        return le ? Long.fromBytesLE(bytes, unsigned) : Long.fromBytesBE(bytes, unsigned);
+      };
+      Long.fromBytesLE = function fromBytesLE(bytes, unsigned) {
+        return new Long(bytes[0] | bytes[1] << 8 | bytes[2] << 16 | bytes[3] << 24, bytes[4] | bytes[5] << 8 | bytes[6] << 16 | bytes[7] << 24, unsigned);
+      };
+      Long.fromBytesBE = function fromBytesBE(bytes, unsigned) {
+        return new Long(bytes[4] << 24 | bytes[5] << 16 | bytes[6] << 8 | bytes[7], bytes[0] << 24 | bytes[1] << 16 | bytes[2] << 8 | bytes[3], unsigned);
+      };
+      long_default = Long;
+    }
+  });
+
+  // src/lib/utils/s2/s2-token-functions.ts
+  function getS2CellIdFromToken(token) {
+    if (token === "X") {
+      token = "";
+    }
+    const paddedToken = token.padEnd(MAXIMUM_TOKEN_LENGTH, "0");
+    return long_default.fromString(paddedToken, true, 16);
+  }
+  function getS2TokenFromCellId(cellId) {
+    if (cellId.isZero()) {
+      return "X";
+    }
+    let numZeroDigits = cellId.countTrailingZeros();
+    const remainder = numZeroDigits % 4;
+    numZeroDigits = (numZeroDigits - remainder) / 4;
+    const trailingZeroHexChars = numZeroDigits;
+    numZeroDigits *= 4;
+    const x = cellId.shiftRightUnsigned(numZeroDigits);
+    const hexString = x.toString(16).replace(/0+$/, "");
+    const zeroString = Array(17 - trailingZeroHexChars - hexString.length).join("0");
+    return zeroString + hexString;
+  }
+  function getS2ChildCellId(cellId, index) {
+    const newLsb = lsb(cellId).shiftRightUnsigned(2);
+    const childCellId = cellId.add(long_default.fromNumber(2 * index + 1 - 4).multiply(newLsb));
+    return childCellId;
+  }
+  function lsb(cellId) {
+    return cellId.and(cellId.not().add(1));
+  }
+  var MAXIMUM_TOKEN_LENGTH;
+  var init_s2_token_functions = __esm({
+    "src/lib/utils/s2/s2-token-functions.ts"() {
+      init_long();
+      MAXIMUM_TOKEN_LENGTH = 16;
+    }
+  });
+
+  // src/lib/utils/s2/s2geometry/s2-geometry.ts
+  function getS2CellFromQuadKey(hilbertQuadkey) {
+    if (hilbertQuadkey.length === 0) {
+      throw new Error(`Invalid Hilbert quad key ${hilbertQuadkey}`);
+    }
+    const parts = hilbertQuadkey.split("/");
+    const face = parseInt(parts[0], 10);
+    const position = parts[1];
+    const maxLevel = position.length;
+    let level = 0;
+    const point = [0, 0];
+    for (let i2 = maxLevel - 1; i2 >= 0; i2--) {
+      level = maxLevel - i2;
+      const bit = position[i2];
+      let rx = 0;
+      let ry = 0;
+      if (bit === "1") {
+        ry = 1;
+      } else if (bit === "2") {
+        rx = 1;
+        ry = 1;
+      } else if (bit === "3") {
+        rx = 1;
+      }
+      const val = Math.pow(2, level - 1);
+      rotateAndFlipQuadrant(val, point, rx, ry);
+      point[0] += val * rx;
+      point[1] += val * ry;
+    }
+    if (face % 2 === 1) {
+      const t2 = point[0];
+      point[0] = point[1];
+      point[1] = t2;
+    }
+    return { face, ij: point, level };
+  }
+  function getS2QuadkeyFromCellId(cellId) {
+    if (cellId.isZero()) {
+      return "";
+    }
+    let bin = cellId.toString(2);
+    while (bin.length < FACE_BITS + POS_BITS) {
+      bin = "0" + bin;
+    }
+    const lsbIndex = bin.lastIndexOf("1");
+    const faceB = bin.substring(0, 3);
+    const posB = bin.substring(3, lsbIndex);
+    const levelN = posB.length / 2;
+    const faceS = long_default.fromString(faceB, true, 2).toString(10);
+    let posS = "";
+    if (levelN !== 0) {
+      posS = long_default.fromString(posB, true, 2).toString(4);
+      while (posS.length < levelN) {
+        posS = "0" + posS;
+      }
+    }
+    return `${faceS}/${posS}`;
+  }
+  function IJToST(ij, level, offsets) {
+    const maxSize = 1 << level;
+    return [(ij[0] + offsets[0]) / maxSize, (ij[1] + offsets[1]) / maxSize];
+  }
+  function singleSTtoUV(st) {
+    if (st >= 0.5) {
+      return 1 / 3 * (4 * st * st - 1);
+    }
+    return 1 / 3 * (1 - 4 * (1 - st) * (1 - st));
+  }
+  function STToUV(st) {
+    return [singleSTtoUV(st[0]), singleSTtoUV(st[1])];
+  }
+  function FaceUVToXYZ(face, [u, v]) {
+    switch (face) {
+      case 0:
+        return [1, u, v];
+      case 1:
+        return [-u, 1, v];
+      case 2:
+        return [-u, -v, 1];
+      case 3:
+        return [-1, -v, -u];
+      case 4:
+        return [v, -1, -u];
+      case 5:
+        return [v, u, -1];
+      default:
+        throw new Error("Invalid face");
+    }
+  }
+  function XYZToLngLat([x, y, z]) {
+    const lat = Math.atan2(z, Math.sqrt(x * x + y * y));
+    const lng = Math.atan2(y, x);
+    return [lng * RADIAN_TO_DEGREE, lat * RADIAN_TO_DEGREE];
+  }
+  function rotateAndFlipQuadrant(n2, point, rx, ry) {
+    if (ry === 0) {
+      if (rx === 1) {
+        point[0] = n2 - 1 - point[0];
+        point[1] = n2 - 1 - point[1];
+      }
+      const x = point[0];
+      point[0] = point[1];
+      point[1] = x;
+    }
+  }
+  function getS2LngLatFromS2Cell(s2Cell) {
+    const st = IJToST(s2Cell.ij, s2Cell.level, [0.5, 0.5]);
+    const uv = STToUV(st);
+    const xyz = FaceUVToXYZ(s2Cell.face, uv);
+    return XYZToLngLat(xyz);
+  }
+  var FACE_BITS, MAX_LEVEL, POS_BITS, RADIAN_TO_DEGREE;
+  var init_s2_geometry = __esm({
+    "src/lib/utils/s2/s2geometry/s2-geometry.ts"() {
+      init_long();
+      FACE_BITS = 3;
+      MAX_LEVEL = 30;
+      POS_BITS = 2 * MAX_LEVEL + 1;
+      RADIAN_TO_DEGREE = 180 / Math.PI;
+    }
+  });
+
+  // src/lib/utils/s2/converters/s2-to-boundary.ts
+  function getS2BoundaryFlatFromS2Cell(s2cell) {
+    const { face, ij, level } = s2cell;
+    const offsets = [
+      [0, 0],
+      [0, 1],
+      [1, 1],
+      [1, 0],
+      [0, 0]
+    ];
+    const resolution = Math.max(1, Math.ceil(MAX_RESOLUTION * Math.pow(2, -level)));
+    const result = new Float64Array(4 * resolution * 2 + 2);
+    let ptIndex = 0;
+    let prevLng = 0;
+    for (let i2 = 0; i2 < 4; i2++) {
+      const offset = offsets[i2].slice(0);
+      const nextOffset = offsets[i2 + 1];
+      const stepI = (nextOffset[0] - offset[0]) / resolution;
+      const stepJ = (nextOffset[1] - offset[1]) / resolution;
+      for (let j = 0; j < resolution; j++) {
+        offset[0] += stepI;
+        offset[1] += stepJ;
+        const st = IJToST(ij, level, offset);
+        const uv = STToUV(st);
+        const xyz = FaceUVToXYZ(face, uv);
+        const lngLat = XYZToLngLat(xyz);
+        if (Math.abs(lngLat[1]) > 89.999) {
+          lngLat[0] = prevLng;
+        }
+        const deltaLng = lngLat[0] - prevLng;
+        lngLat[0] += deltaLng > 180 ? -360 : deltaLng < -180 ? 360 : 0;
+        result[ptIndex++] = lngLat[0];
+        result[ptIndex++] = lngLat[1];
+        prevLng = lngLat[0];
+      }
+    }
+    result[ptIndex++] = result[0];
+    result[ptIndex++] = result[1];
+    return result;
+  }
+  var MAX_RESOLUTION;
+  var init_s2_to_boundary = __esm({
+    "src/lib/utils/s2/converters/s2-to-boundary.ts"() {
+      init_s2_geometry();
+      MAX_RESOLUTION = 100;
+    }
+  });
+
+  // src/lib/utils/s2/s2geometry/s2-cell-utils.ts
+  function getS2Cell(tokenOrKey) {
+    const key = getS2QuadKey(tokenOrKey);
+    const s2cell = getS2CellFromQuadKey(key);
+    return s2cell;
+  }
+  function getS2QuadKey(tokenOrKey) {
+    if (tokenOrKey.indexOf("/") > 0) {
+      return tokenOrKey;
+    }
+    const id = getS2CellIdFromToken(tokenOrKey);
+    return getS2QuadkeyFromCellId(id);
+  }
+  var init_s2_cell_utils = __esm({
+    "src/lib/utils/s2/s2geometry/s2-cell-utils.ts"() {
+      init_s2_geometry();
+      init_s2_token_functions();
+    }
+  });
+
+  // src/lib/utils/s2/s2-geometry-functions.ts
+  function getS2LngLat(s2Token) {
+    const s2cell = getS2Cell(s2Token);
+    return getS2LngLatFromS2Cell(s2cell);
+  }
+  var init_s2_geometry_functions = __esm({
+    "src/lib/utils/s2/s2-geometry-functions.ts"() {
+      init_s2_geometry();
+      init_s2_cell_utils();
+    }
+  });
+
+  // src/lib/utils/s2/converters/s2-to-region.ts
+  function getS2Region(s2cell) {
+    let region;
+    if (s2cell.face === 2 || s2cell.face === 5) {
+      let corners = null;
+      let len2 = 0;
+      for (let i2 = 0; i2 < 4; i2++) {
+        const key = `${s2cell.face}/${i2}`;
+        const cell = getS2Cell(key);
+        const corns = getS2BoundaryFlatFromS2Cell(cell);
+        if (typeof corners === "undefined" || corners === null)
+          corners = new Float64Array(4 * corns.length);
+        corners.set(corns, len2);
+        len2 += corns.length;
+      }
+      region = get2DRegionFromS2Corners(corners);
+    } else {
+      const corners = getS2BoundaryFlatFromS2Cell(s2cell);
+      region = get2DRegionFromS2Corners(corners);
+    }
+    return region;
+  }
+  function get2DRegionFromS2Corners(corners) {
+    if (corners.length % 2 !== 0) {
+      throw new Error("Invalid corners");
+    }
+    const longitudes = [];
+    const latitudes = [];
+    for (let i2 = 0; i2 < corners.length; i2 += 2) {
+      longitudes.push(corners[i2]);
+      latitudes.push(corners[i2 + 1]);
+    }
+    longitudes.sort((a2, b) => a2 - b);
+    latitudes.sort((a2, b) => a2 - b);
+    return {
+      west: longitudes[0],
+      east: longitudes[longitudes.length - 1],
+      north: latitudes[latitudes.length - 1],
+      south: latitudes[0]
+    };
+  }
+  var init_s2_to_region = __esm({
+    "src/lib/utils/s2/converters/s2-to-region.ts"() {
+      init_s2_to_boundary();
+      init_s2_cell_utils();
+    }
+  });
+
+  // src/lib/utils/s2/converters/s2-to-obb-points.ts
+  function getS2OrientedBoundingBoxCornerPoints(tokenOrKey, heightInfo) {
+    const min = heightInfo?.minimumHeight || 0;
+    const max = heightInfo?.maximumHeight || 0;
+    const s2cell = getS2Cell(tokenOrKey);
+    const region = getS2Region(s2cell);
+    const W = region.west;
+    const S = region.south;
+    const E = region.east;
+    const N = region.north;
+    const points = [];
+    points.push(new Vector3(W, N, min));
+    points.push(new Vector3(E, N, min));
+    points.push(new Vector3(E, S, min));
+    points.push(new Vector3(W, S, min));
+    points.push(new Vector3(W, N, max));
+    points.push(new Vector3(E, N, max));
+    points.push(new Vector3(E, S, max));
+    points.push(new Vector3(W, S, max));
+    return points;
+  }
+  var init_s2_to_obb_points = __esm({
+    "src/lib/utils/s2/converters/s2-to-obb-points.ts"() {
+      init_s2_cell_utils();
+      init_s2_to_region();
+      init_esm();
+    }
+  });
+
+  // src/lib/utils/s2/index.ts
+  var init_s2 = __esm({
+    "src/lib/utils/s2/index.ts"() {
+      init_s2_token_functions();
+      init_s2_geometry_functions();
+      init_s2_to_obb_points();
+    }
+  });
+
+  // src/lib/utils/obb/s2-corners-to-obb.ts
+  function convertS2BoundingVolumetoOBB(s2VolumeInfo) {
+    const token = s2VolumeInfo.token;
+    const heightInfo = {
+      minimumHeight: s2VolumeInfo.minimumHeight,
+      maximumHeight: s2VolumeInfo.maximumHeight
+    };
+    const corners = getS2OrientedBoundingBoxCornerPoints(token, heightInfo);
+    const center = getS2LngLat(token);
+    const centerLng = center[0];
+    const centerLat = center[1];
+    const point = Ellipsoid.WGS84.cartographicToCartesian([
+      centerLng,
+      centerLat,
+      heightInfo.maximumHeight
+    ]);
+    const centerPointAdditional = new Vector3(point[0], point[1], point[2]);
+    corners.push(centerPointAdditional);
+    const obb = makeOrientedBoundingBoxFromPoints(corners);
+    const box = [...obb.center, ...obb.halfAxes];
+    return box;
+  }
+  var init_s2_corners_to_obb = __esm({
+    "src/lib/utils/obb/s2-corners-to-obb.ts"() {
+      init_esm();
+      init_esm3();
+      init_s2();
+      init_s2();
+      init_esm2();
+    }
+  });
+
   // src/lib/parsers/helpers/parse-3d-implicit-tiles.ts
+  function getChildS2VolumeBox(s2VolumeBox, index, subdivisionScheme) {
+    if (s2VolumeBox?.box) {
+      const cellId = getS2CellIdFromToken(s2VolumeBox.s2VolumeInfo.token);
+      const childCellId = getS2ChildCellId(cellId, index);
+      const childToken = getS2TokenFromCellId(childCellId);
+      const s2ChildVolumeInfo = { ...s2VolumeBox.s2VolumeInfo };
+      s2ChildVolumeInfo.token = childToken;
+      switch (subdivisionScheme) {
+        case "OCTREE":
+          const s2VolumeInfo = s2VolumeBox.s2VolumeInfo;
+          const delta = s2VolumeInfo.maximumHeight - s2VolumeInfo.minimumHeight;
+          const sizeZ = delta / 2;
+          const midZ = s2VolumeInfo.minimumHeight + delta / 2;
+          s2VolumeInfo.minimumHeight = midZ - sizeZ;
+          s2VolumeInfo.maximumHeight = midZ + sizeZ;
+          break;
+        default:
+          break;
+      }
+      const box = convertS2BoundingVolumetoOBB(s2ChildVolumeInfo);
+      const childS2VolumeBox = {
+        box,
+        s2VolumeInfo: s2ChildVolumeInfo
+      };
+      return childS2VolumeBox;
+    }
+    return void 0;
+  }
   async function parseImplicitTiles(params) {
     const {
       options,
@@ -12051,7 +14231,8 @@
         x: 0,
         y: 0,
         z: 0
-      }
+      },
+      s2VolumeBox
     } = params;
     let { subtree, level = 0 } = params;
     const {
@@ -12109,18 +14290,20 @@
     const childTileLevel = level + 1;
     const pData = { mortonIndex: childTileMortonIndex, x: childTileX, y: childTileY, z: childTileZ };
     for (let index = 0; index < childrenPerTile; index++) {
-      const currentTile = await parseImplicitTiles({
+      const childS2VolumeBox = getChildS2VolumeBox(s2VolumeBox, index, subdivisionScheme);
+      const childTileParsed = await parseImplicitTiles({
         subtree,
         options,
         parentData: pData,
         childIndex: index,
         level: childTileLevel,
-        globalData
+        globalData,
+        s2VolumeBox: childS2VolumeBox
       });
-      if (currentTile.contentUrl || currentTile.children.length) {
+      if (childTileParsed.contentUrl || childTileParsed.children.length) {
         const globalLevel = lev + 1;
         const childCoordinates = { childTileX, childTileY, childTileZ };
-        const formattedTile = formatTileData(currentTile, globalLevel, childCoordinates, options);
+        const formattedTile = formatTileData(childTileParsed, globalLevel, childCoordinates, options, s2VolumeBox);
         tile.children.push(formattedTile);
       }
     }
@@ -12135,7 +14318,7 @@
     }
     return false;
   }
-  function formatTileData(tile, level, childCoordinates, options) {
+  function formatTileData(tile, level, childCoordinates, options, s2VolumeBox) {
     const {
       basePath,
       refine,
@@ -12147,7 +14330,8 @@
     } = options;
     const uri = tile.contentUrl && tile.contentUrl.replace(`${basePath}/`, "");
     const lodMetricValue = rootLodMetricValue / 2 ** level;
-    const boundingVolume = calculateBoundingVolumeForChildTile(level, rootBoundingVolume, childCoordinates);
+    const boundingVolume = s2VolumeBox?.box ? { box: s2VolumeBox.box } : rootBoundingVolume;
+    const boundingVolumeForChildTile = calculateBoundingVolumeForChildTile(level, boundingVolume, childCoordinates);
     return {
       children: tile.children,
       contentUrl: tile.contentUrl,
@@ -12159,7 +14343,7 @@
       lodMetricValue,
       geometricError: lodMetricValue,
       transform: tile.transform,
-      boundingVolume
+      boundingVolume: boundingVolumeForChildTile
     };
   }
   function calculateBoundingVolumeForChildTile(level, rootBoundingVolume, childCoordinates) {
@@ -12180,8 +14364,10 @@
         region: [childWest, childSouth, childEast, childNorth, childMinimumHeight, childMaximumHeight]
       };
     }
-    console.warn("Unsupported bounding volume type: ", rootBoundingVolume);
-    return null;
+    if (rootBoundingVolume.box) {
+      return rootBoundingVolume;
+    }
+    throw new Error(`Unsupported bounding volume type ${rootBoundingVolume}`);
   }
   function concatBits(first, second) {
     return parseInt(first.toString(2) + second.toString(2), 2);
@@ -12208,6 +14394,8 @@
     "src/lib/parsers/helpers/parse-3d-implicit-tiles.ts"() {
       init_tile_3d_subtree_loader();
       init_src3();
+      init_s2();
+      init_s2_corners_to_obb();
       QUADTREE_DEVISION_COUNT = 4;
       OCTREE_DEVISION_COUNT = 8;
       SUBDIVISION_COUNT_MAP = {
@@ -12314,6 +14502,12 @@
     const contentUrlTemplate = resolveUri(tile.content.uri, basePath);
     const refine = tileset?.root?.refine;
     const rootLodMetricValue = tile.geometricError;
+    const s2VolumeInfo = tile.boundingVolume.extensions?.["3DTILES_bounding_volume_S2"];
+    if (s2VolumeInfo) {
+      const box = convertS2BoundingVolumetoOBB(s2VolumeInfo);
+      const s2VolumeBox = { box, s2VolumeInfo };
+      tile.boundingVolume = s2VolumeBox;
+    }
     const rootBoundingVolume = tile.boundingVolume;
     const implicitOptions = {
       contentUrlTemplate,
@@ -12338,7 +14532,11 @@
     tile.lodMetricType = LOD_METRIC_TYPE.GEOMETRIC_ERROR;
     tile.lodMetricValue = tile.geometricError;
     tile.transformMatrix = tile.transform;
-    const { children, contentUrl } = await parseImplicitTiles({ subtree: rootSubtree, options });
+    const { children, contentUrl } = await parseImplicitTiles({
+      subtree: rootSubtree,
+      options,
+      s2VolumeBox: tile
+    });
     if (contentUrl) {
       tile.contentUrl = contentUrl;
       tile.content = { uri: contentUrl.replace(`${options.basePath}/`, "") };
@@ -12358,6 +14556,7 @@
       init_src3();
       init_src4();
       init_parse_3d_implicit_tiles();
+      init_s2_corners_to_obb();
     }
   });
 
@@ -12570,7 +14769,7 @@
   }
   var init_encode_3d_tile_composite = __esm({
     "src/lib/encoders/encode-3d-tile-composite.ts"() {
-      init_constants3();
+      init_constants4();
       init_encode_3d_tile_header();
     }
   });
@@ -12609,7 +14808,7 @@
   var init_encode_3d_tile_batched_model = __esm({
     "src/lib/encoders/encode-3d-tile-batched-model.ts"() {
       init_src2();
-      init_constants3();
+      init_constants4();
       init_encode_3d_tile_header();
     }
   });
@@ -12643,7 +14842,7 @@
   var init_encode_3d_tile_instanced_model = __esm({
     "src/lib/encoders/encode-3d-tile-instanced-model.ts"() {
       init_src2();
-      init_constants3();
+      init_constants4();
       init_encode_3d_tile_header();
     }
   });
@@ -12674,7 +14873,7 @@
   var DEFAULT_FEATURE_TABLE_JSON;
   var init_encode_3d_tile_point_cloud = __esm({
     "src/lib/encoders/encode-3d-tile-point-cloud.ts"() {
-      init_constants3();
+      init_constants4();
       init_encode_3d_tile_header();
       init_src2();
       DEFAULT_FEATURE_TABLE_JSON = {
@@ -12711,7 +14910,7 @@
   }
   var init_encode_3d_tile = __esm({
     "src/lib/encoders/encode-3d-tile.ts"() {
-      init_constants3();
+      init_constants4();
       init_src2();
       init_encode_3d_tile_composite();
       init_encode_3d_tile_batched_model();
@@ -12765,7 +14964,7 @@
       init_tile_3d_writer();
       init_tile_3d_feature_table();
       init_tile_3d_batch_table();
-      init_constants3();
+      init_constants4();
       init_ion();
     }
   });
@@ -12780,3 +14979,22 @@
   });
   require_bundle();
 })();
+/**
+ * @license
+ * Copyright 2009 The Closure Library Authors
+ * Copyright 2020 Daniel Wirtz / The long.js Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */