@loaders.gl/tiles 4.2.0-alpha.3 → 4.2.0-alpha.5

package/dist/dist.dev.js

@@ -2,8 +2,8 @@
   if (typeof exports === 'object' && typeof module === 'object')
     module.exports = factory();
   else if (typeof define === 'function' && define.amd) define([], factory);
-        else if (typeof exports === 'object') exports['loader'] = factory();
-  else root['loader'] = factory();})(globalThis, function () {
+        else if (typeof exports === 'object') exports['loaders'] = factory();
+  else root['loaders'] = factory();})(globalThis, function () {
 "use strict";
 var __exports__ = (() => {
   var __create = Object.create;
@@ -27,6 +27,7 @@ var __exports__ = (() => {
     }
     return to;
   };
+  var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
   var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
     // If the importer is in node compatibility mode or this is not an ESM
     // file that has been converted to a CommonJS file using a Babel-
@@ -44,9 +45,9 @@ var __exports__ = (() => {
     }
   });
 
-  // src/index.ts
-  var src_exports = {};
-  __export(src_exports, {
+  // bundle.ts
+  var bundle_exports = {};
+  __export(bundle_exports, {
     LOD_METRIC_TYPE: () => LOD_METRIC_TYPE,
     TILESET_TYPE: () => TILESET_TYPE,
     TILE_CONTENT_STATE: () => TILE_CONTENT_STATE,
@@ -61,6 +62,7 @@ var __exports__ = (() => {
     getFrameState: () => getFrameState,
     getLodStatus: () => getLodStatus
   });
+  __reExport(bundle_exports, __toESM(require_core(), 1));
 
   // ../../node_modules/@math.gl/core/dist/lib/common.js
   var RADIANS_TO_DEGREES = 1 / Math.PI * 180;
@@ -4949,43 +4951,56 @@ var __exports__ = (() => {
   var STAT_ACTIVE_REQUESTS_EVER = "Active Requests Ever";
   var DEFAULT_PROPS = {
     id: "request-scheduler",
+    /** Specifies if the request scheduler should throttle incoming requests, mainly for comparative testing. */
     throttleRequests: true,
-    maxRequests: 6
+    /** The maximum number of simultaneous active requests. Un-throttled requests do not observe this limit. */
+    maxRequests: 6,
+    /**
+     * Specifies a debounce time, in milliseconds. All requests are queued, until no new requests have
+     * been added to the queue for this amount of time.
+     */
+    debounceTime: 0
   };
   var RequestScheduler = class {
-    activeRequestCount = 0;
-    requestQueue = [];
-    requestMap = /* @__PURE__ */ new Map();
-    deferredUpdate = null;
     constructor(props = {}) {
-      this.props = {
-        ...DEFAULT_PROPS,
-        ...props
-      };
-      this.stats = new Stats2({
-        id: this.props.id
-      });
+      this.activeRequestCount = 0;
+      /** Tracks the number of active requests and prioritizes/cancels queued requests. */
+      this.requestQueue = [];
+      this.requestMap = /* @__PURE__ */ new Map();
+      this.updateTimer = null;
+      this.props = { ...DEFAULT_PROPS, ...props };
+      this.stats = new Stats2({ id: this.props.id });
       this.stats.get(STAT_QUEUED_REQUESTS);
       this.stats.get(STAT_ACTIVE_REQUESTS);
       this.stats.get(STAT_CANCELLED_REQUESTS);
       this.stats.get(STAT_QUEUED_REQUESTS_EVER);
       this.stats.get(STAT_ACTIVE_REQUESTS_EVER);
     }
+    /**
+     * Called by an application that wants to issue a request, without having it deeply queued by the browser
+     *
+     * When the returned promise resolved, it is OK for the application to issue a request.
+     * The promise resolves to an object that contains a `done` method.
+     * When the application's request has completed (or failed), the application must call the `done` function
+     *
+     * @param handle
+     * @param getPriority will be called when request "slots" open up,
+     *    allowing the caller to update priority or cancel the request
+     *    Highest priority executes first, priority < 0 cancels the request
+     * @returns a promise
+     *   - resolves to a object (with a `done` field) when the request can be issued without queueing,
+     *   - resolves to `null` if the request has been cancelled (by the callback return < 0).
+     *     In this case the application should not issue the request
+     */
     scheduleRequest(handle, getPriority = () => 0) {
       if (!this.props.throttleRequests) {
-        return Promise.resolve({
-          done: () => {
-          }
-        });
+        return Promise.resolve({ done: () => {
+        } });
       }
       if (this.requestMap.has(handle)) {
         return this.requestMap.get(handle);
       }
-      const request = {
-        handle,
-        priority: 0,
-        getPriority
-      };
+      const request = { handle, priority: 0, getPriority };
       const promise = new Promise((resolve2) => {
         request.resolve = resolve2;
         return request;
@@ -4995,11 +5010,9 @@ var __exports__ = (() => {
       this._issueNewRequests();
       return promise;
     }
+    // PRIVATE
     _issueRequest(request) {
-      const {
-        handle,
-        resolve: resolve2
-      } = request;
+      const { handle, resolve: resolve2 } = request;
       let isDone = false;
       const done = () => {
         if (!isDone) {
@@ -5010,19 +5023,21 @@ var __exports__ = (() => {
         }
       };
       this.activeRequestCount++;
-      return resolve2 ? resolve2({
-        done
-      }) : Promise.resolve({
-        done
-      });
+      return resolve2 ? resolve2({ done }) : Promise.resolve({ done });
     }
+    /** We check requests asynchronously, to prevent multiple updates */
     _issueNewRequests() {
-      if (!this.deferredUpdate) {
-        this.deferredUpdate = setTimeout(() => this._issueNewRequestsAsync(), 0);
+      if (this.updateTimer !== null) {
+        clearTimeout(this.updateTimer);
       }
+      this.updateTimer = setTimeout(() => this._issueNewRequestsAsync(), this.props.debounceTime);
     }
+    /** Refresh all requests  */
     _issueNewRequestsAsync() {
-      this.deferredUpdate = null;
+      if (this.updateTimer !== null) {
+        clearTimeout(this.updateTimer);
+      }
+      this.updateTimer = null;
       const freeSlots = Math.max(this.props.maxRequests - this.activeRequestCount, 0);
       if (freeSlots === 0) {
         return;
@@ -5035,6 +5050,7 @@ var __exports__ = (() => {
         }
       }
     }
+    /** Ensure all requests have updated priorities, and that no longer valid requests are cancelled */
     _updateAllRequests() {
       const requestQueue = this.requestQueue;
       for (let i = 0; i < requestQueue.length; ++i) {
@@ -5047,6 +5063,7 @@ var __exports__ = (() => {
       }
       requestQueue.sort((a, b) => a.priority - b.priority);
     }
+    /** Update a single request by calling the callback */
     _updateRequest(request) {
       request.priority = request.getPriority(request.handle);
       if (request.priority < 0) {
@@ -5211,12 +5228,19 @@ var __exports__ = (() => {
 
   // src/utils/doubly-linked-list.ts
   var DoublyLinkedList = class {
-    head = null;
-    tail = null;
-    _length = 0;
+    constructor() {
+      this.head = null;
+      this.tail = null;
+      this._length = 0;
+    }
     get length() {
       return this._length;
     }
+    /**
+     * Adds the item to the end of the list
+     * @param {*} [item]
+     * @return {DoublyLinkedListNode}
+     */
     add(item) {
       const node = new DoublyLinkedListNode(item, this.tail, null);
       if (this.tail) {
@@ -5229,6 +5253,10 @@ var __exports__ = (() => {
       ++this._length;
       return node;
     }
+    /**
+     * Removes the given node from the list
+     * @param {DoublyLinkedListNode} node
+     */
     remove(node) {
       if (!node) {
         return;
@@ -5250,6 +5278,11 @@ var __exports__ = (() => {
       node.previous = null;
       --this._length;
     }
+    /**
+     * Moves nextNode after node
+     * @param {DoublyLinkedListNode} node
+     * @param {DoublyLinkedListNode} nextNode
+     */
     splice(node, nextNode) {
       if (node === nextNode) {
         return;
@@ -5328,15 +5361,10 @@ var __exports__ = (() => {
   function calculateTransformProps(tileHeader, tile) {
     assert2(tileHeader);
     assert2(tile);
-    const {
-      rtcCenter,
-      gltfUpAxis
-    } = tile;
+    const { rtcCenter, gltfUpAxis } = tile;
     const {
       computedTransform,
-      boundingVolume: {
-        center
-      }
+      boundingVolume: { center }
     } = tileHeader;
     let modelMatrix = new Matrix4(computedTransform);
     if (rtcCenter) {
@@ -5362,7 +5390,10 @@ var __exports__ = (() => {
     const cartesianOrigin = new Vector3(center);
     tile.cartesianModelMatrix = modelMatrix;
     tile.cartesianOrigin = cartesianOrigin;
-    const cartographicOrigin = Ellipsoid.WGS84.cartesianToCartographic(cartesianOrigin, new Vector3());
+    const cartographicOrigin = Ellipsoid.WGS84.cartesianToCartographic(
+      cartesianOrigin,
+      new Vector3()
+    );
     const fromFixedFrameMatrix = Ellipsoid.WGS84.eastNorthUpToFixedFrame(cartesianOrigin);
     const toFixedFrameMatrix = fromFixedFrameMatrix.invert();
     tile.cartographicModelMatrix = toFixedFrameMatrix.multiplyRight(modelMatrix);
@@ -5825,31 +5856,35 @@ var __exports__ = (() => {
   // src/tileset/helpers/frame-state.ts
   var scratchVector8 = new Vector3();
   var scratchPosition3 = new Vector3();
-  var cullingVolume = new CullingVolume([new Plane(), new Plane(), new Plane(), new Plane(), new Plane(), new Plane()]);
+  var cullingVolume = new CullingVolume([
+    new Plane(),
+    new Plane(),
+    new Plane(),
+    new Plane(),
+    new Plane(),
+    new Plane()
+  ]);
   function getFrameState(viewport, frameNumber) {
-    const {
-      cameraDirection,
-      cameraUp,
-      height
-    } = viewport;
-    const {
-      metersPerUnit
-    } = viewport.distanceScales;
+    const { cameraDirection, cameraUp, height } = viewport;
+    const { metersPerUnit } = viewport.distanceScales;
     const viewportCenterCartesian = worldToCartesian(viewport, viewport.center);
     const enuToFixedTransform = Ellipsoid.WGS84.eastNorthUpToFixedFrame(viewportCenterCartesian);
     const cameraPositionCartographic = viewport.unprojectPosition(viewport.cameraPosition);
-    const cameraPositionCartesian2 = Ellipsoid.WGS84.cartographicToCartesian(cameraPositionCartographic, new Vector3());
-    const cameraDirectionCartesian = new Vector3(enuToFixedTransform.transformAsVector(new Vector3(cameraDirection).scale(metersPerUnit))).normalize();
-    const cameraUpCartesian = new Vector3(enuToFixedTransform.transformAsVector(new Vector3(cameraUp).scale(metersPerUnit))).normalize();
+    const cameraPositionCartesian2 = Ellipsoid.WGS84.cartographicToCartesian(
+      cameraPositionCartographic,
+      new Vector3()
+    );
+    const cameraDirectionCartesian = new Vector3(
+      // @ts-ignore
+      enuToFixedTransform.transformAsVector(new Vector3(cameraDirection).scale(metersPerUnit))
+    ).normalize();
+    const cameraUpCartesian = new Vector3(
+      // @ts-ignore
+      enuToFixedTransform.transformAsVector(new Vector3(cameraUp).scale(metersPerUnit))
+    ).normalize();
     commonSpacePlanesToWGS84(viewport);
     const ViewportClass = viewport.constructor;
-    const {
-      longitude,
-      latitude,
-      width,
-      bearing,
-      zoom
-    } = viewport;
+    const { longitude, latitude, width, bearing, zoom } = viewport;
     const topDownViewport = new ViewportClass({
       longitude,
       latitude,
@@ -5870,7 +5905,9 @@ var __exports__ = (() => {
       height,
       cullingVolume,
       frameNumber,
+      // TODO: This can be the same between updates, what number is unique for between updates?
       sseDenominator: 1.15
+      // Assumes fovy = 60 degrees
     };
   }
   function limitSelectedTiles(tiles, frameState, maximumTilesSelected) {
@@ -5878,10 +5915,7 @@ var __exports__ = (() => {
       return [tiles, []];
     }
     const tuples = [];
-    const {
-      longitude: viewportLongitude,
-      latitude: viewportLatitude
-    } = frameState.viewport;
+    const { longitude: viewportLongitude, latitude: viewportLatitude } = frameState.viewport;
     for (const [index, tile] of tiles.entries()) {
       const [longitude, latitude] = tile.header.mbs;
       const deltaLon = Math.abs(viewportLongitude - longitude);
@@ -5906,7 +5940,10 @@ var __exports__ = (() => {
     const nearCenterCartesian = worldToCartesian(viewport, nearCenterCommon);
     const cameraCartesian = worldToCartesian(viewport, viewport.cameraPosition, scratchPosition3);
     let i = 0;
-    cullingVolume.planes[i++].fromPointNormal(nearCenterCartesian, scratchVector8.copy(nearCenterCartesian).subtract(cameraCartesian));
+    cullingVolume.planes[i++].fromPointNormal(
+      nearCenterCartesian,
+      scratchVector8.copy(nearCenterCartesian).subtract(cameraCartesian)
+    );
     for (const dir in frustumPlanes) {
       if (dir === "near") {
         continue;
@@ -5914,7 +5951,11 @@ var __exports__ = (() => {
       const plane = frustumPlanes[dir];
       const posCommon = closestPointOnPlane(plane, nearCenterCommon, scratchPosition3);
       const cartesianPos = worldToCartesian(viewport, posCommon, scratchPosition3);
-      cullingVolume.planes[i++].fromPointNormal(cartesianPos, scratchVector8.copy(nearCenterCartesian).subtract(cartesianPos));
+      cullingVolume.planes[i++].fromPointNormal(
+        cartesianPos,
+        // Want the normal to point into the frustum since that's what culling expects
+        scratchVector8.copy(nearCenterCartesian).subtract(cartesianPos)
+      );
     }
   }
   function closestPointOnPlane(plane, refPoint, out = new Vector3()) {
@@ -5934,21 +5975,14 @@ var __exports__ = (() => {
   var scratchVector9 = new Vector3();
   function getZoomFromBoundingVolume(boundingVolume, cartorgraphicCenter) {
     if (boundingVolume instanceof OrientedBoundingBox) {
-      const {
-        halfAxes
-      } = boundingVolume;
+      const { halfAxes } = boundingVolume;
       const obbSize = getObbSize(halfAxes);
       return Math.log2(WGS84_RADIUS_Z2 / (obbSize + cartorgraphicCenter[2]));
     } else if (boundingVolume instanceof BoundingSphere) {
-      const {
-        radius
-      } = boundingVolume;
+      const { radius } = boundingVolume;
       return Math.log2(WGS84_RADIUS_Z2 / (radius + cartorgraphicCenter[2]));
     } else if (boundingVolume.width && boundingVolume.height) {
-      const {
-        width,
-        height
-      } = boundingVolume;
+      const { width, height } = boundingVolume;
       const zoomX = Math.log2(WGS84_RADIUS_X2 / width);
       const zoomY = Math.log2(WGS84_RADIUS_Y2 / height);
       return (zoomX + zoomY) / 2;
@@ -5956,20 +5990,22 @@ var __exports__ = (() => {
     return 1;
   }
   function getZoomFromFullExtent(fullExtent, cartorgraphicCenter, cartesianCenter) {
-    Ellipsoid.WGS84.cartographicToCartesian([fullExtent.xmax, fullExtent.ymax, fullExtent.zmax], scratchVector9);
-    const extentSize = Math.sqrt(Math.pow(scratchVector9[0] - cartesianCenter[0], 2) + Math.pow(scratchVector9[1] - cartesianCenter[1], 2) + Math.pow(scratchVector9[2] - cartesianCenter[2], 2));
+    Ellipsoid.WGS84.cartographicToCartesian(
+      [fullExtent.xmax, fullExtent.ymax, fullExtent.zmax],
+      scratchVector9
+    );
+    const extentSize = Math.sqrt(
+      Math.pow(scratchVector9[0] - cartesianCenter[0], 2) + Math.pow(scratchVector9[1] - cartesianCenter[1], 2) + Math.pow(scratchVector9[2] - cartesianCenter[2], 2)
+    );
     return Math.log2(WGS84_RADIUS_Z2 / (extentSize + cartorgraphicCenter[2]));
   }
   function getZoomFromExtent(extent, cartorgraphicCenter, cartesianCenter) {
     const [xmin, ymin, xmax, ymax] = extent;
-    return getZoomFromFullExtent({
-      xmin,
-      xmax,
-      ymin,
-      ymax,
-      zmin: 0,
-      zmax: 0
-    }, cartorgraphicCenter, cartesianCenter);
+    return getZoomFromFullExtent(
+      { xmin, xmax, ymin, ymax, zmin: 0, zmax: 0 },
+      cartorgraphicCenter,
+      cartesianCenter
+    );
   }
   function getObbSize(halfAxes) {
     halfAxes.getColumn(0, scratchVector9);
@@ -5986,34 +6022,40 @@ var __exports__ = (() => {
   // src/constants.ts
   var TILE_CONTENT_STATE = {
     UNLOADED: 0,
+    // Has never been requested
     LOADING: 1,
+    // Is waiting on a pending request
     PROCESSING: 2,
+    // Request received.  Contents are being processed for rendering.  Depending on the content, it might make its own requests for external data.
     READY: 3,
+    // Ready to render.
     EXPIRED: 4,
+    // Is expired and will be unloaded once new content is loaded.
     FAILED: 5
+    // Request failed.
   };
-  var TILE_REFINEMENT = function(TILE_REFINEMENT2) {
+  var TILE_REFINEMENT = /* @__PURE__ */ ((TILE_REFINEMENT2) => {
     TILE_REFINEMENT2[TILE_REFINEMENT2["ADD"] = 1] = "ADD";
     TILE_REFINEMENT2[TILE_REFINEMENT2["REPLACE"] = 2] = "REPLACE";
     return TILE_REFINEMENT2;
-  }({});
-  var TILE_TYPE = function(TILE_TYPE2) {
+  })(TILE_REFINEMENT || {});
+  var TILE_TYPE = /* @__PURE__ */ ((TILE_TYPE2) => {
     TILE_TYPE2["EMPTY"] = "empty";
     TILE_TYPE2["SCENEGRAPH"] = "scenegraph";
     TILE_TYPE2["POINTCLOUD"] = "pointcloud";
     TILE_TYPE2["MESH"] = "mesh";
     return TILE_TYPE2;
-  }({});
-  var TILESET_TYPE = function(TILESET_TYPE2) {
+  })(TILE_TYPE || {});
+  var TILESET_TYPE = /* @__PURE__ */ ((TILESET_TYPE2) => {
     TILESET_TYPE2["I3S"] = "I3S";
     TILESET_TYPE2["TILES3D"] = "TILES3D";
     return TILESET_TYPE2;
-  }({});
-  var LOD_METRIC_TYPE = function(LOD_METRIC_TYPE2) {
+  })(TILESET_TYPE || {});
+  var LOD_METRIC_TYPE = /* @__PURE__ */ ((LOD_METRIC_TYPE2) => {
     LOD_METRIC_TYPE2["GEOMETRIC_ERROR"] = "geometricError";
     LOD_METRIC_TYPE2["MAX_SCREEN_THRESHOLD"] = "maxScreenThreshold";
     return LOD_METRIC_TYPE2;
-  }({});
+  })(LOD_METRIC_TYPE || {});
   var TILE3D_OPTIMIZATION_HINT = {
     NOT_COMPUTED: -1,
     USE_OPTIMIZATION: 1,
@@ -6051,7 +6093,10 @@ var __exports__ = (() => {
     }
     if (boundingVolumeHeader.region) {
       const [west, south, east, north, minHeight, maxHeight] = boundingVolumeHeader.region;
-      return [[degrees(west), degrees(south), minHeight], [degrees(east), degrees(north), maxHeight]];
+      return [
+        [degrees(west), degrees(south), minHeight],
+        [degrees(east), degrees(north), maxHeight]
+      ];
     }
     if (boundingVolumeHeader.sphere) {
       return boundingSphereToCartographicBounds(boundingVolume);
@@ -6082,7 +6127,17 @@ var __exports__ = (() => {
     const xAxis = transform.transformAsVector(origin.slice(0, 3));
     const yAxis = transform.transformAsVector(origin.slice(3, 6));
     const zAxis = transform.transformAsVector(origin.slice(6, 9));
-    const halfAxes = new Matrix3([xAxis[0], xAxis[1], xAxis[2], yAxis[0], yAxis[1], yAxis[2], zAxis[0], zAxis[1], zAxis[2]]);
+    const halfAxes = new Matrix3([
+      xAxis[0],
+      xAxis[1],
+      xAxis[2],
+      yAxis[0],
+      yAxis[1],
+      yAxis[2],
+      zAxis[0],
+      zAxis[1],
+      zAxis[2]
+    ]);
     if (defined(result)) {
       result.center = center;
       result.halfAxes = halfAxes;
@@ -6105,20 +6160,41 @@ var __exports__ = (() => {
   }
   function createObbFromRegion(region) {
     const [west, south, east, north, minHeight, maxHeight] = region;
-    const northWest = Ellipsoid.WGS84.cartographicToCartesian([degrees(west), degrees(north), minHeight], scratchNorthWest);
-    const southEast = Ellipsoid.WGS84.cartographicToCartesian([degrees(east), degrees(south), maxHeight], scratchSouthEast);
+    const northWest = Ellipsoid.WGS84.cartographicToCartesian(
+      [degrees(west), degrees(north), minHeight],
+      scratchNorthWest
+    );
+    const southEast = Ellipsoid.WGS84.cartographicToCartesian(
+      [degrees(east), degrees(south), maxHeight],
+      scratchSouthEast
+    );
     const centerInCartesian = new Vector3().addVectors(northWest, southEast).multiplyByScalar(0.5);
     Ellipsoid.WGS84.cartesianToCartographic(centerInCartesian, scratchCenter);
-    Ellipsoid.WGS84.cartographicToCartesian([degrees(east), scratchCenter[1], scratchCenter[2]], scratchXAxis);
-    Ellipsoid.WGS84.cartographicToCartesian([scratchCenter[0], degrees(north), scratchCenter[2]], scratchYAxis);
-    Ellipsoid.WGS84.cartographicToCartesian([scratchCenter[0], scratchCenter[1], maxHeight], scratchZAxis);
-    return createBox([...centerInCartesian, ...scratchXAxis.subtract(centerInCartesian), ...scratchYAxis.subtract(centerInCartesian), ...scratchZAxis.subtract(centerInCartesian)], new Matrix4());
+    Ellipsoid.WGS84.cartographicToCartesian(
+      [degrees(east), scratchCenter[1], scratchCenter[2]],
+      scratchXAxis
+    );
+    Ellipsoid.WGS84.cartographicToCartesian(
+      [scratchCenter[0], degrees(north), scratchCenter[2]],
+      scratchYAxis
+    );
+    Ellipsoid.WGS84.cartographicToCartesian(
+      [scratchCenter[0], scratchCenter[1], maxHeight],
+      scratchZAxis
+    );
+    return createBox(
+      [
+        ...centerInCartesian,
+        ...scratchXAxis.subtract(centerInCartesian),
+        ...scratchYAxis.subtract(centerInCartesian),
+        ...scratchZAxis.subtract(centerInCartesian)
+      ],
+      new Matrix4()
+    );
   }
   function orientedBoundingBoxToCartographicBounds(boundingVolume) {
     const result = emptyCartographicBounds();
-    const {
-      halfAxes
-    } = boundingVolume;
+    const { halfAxes } = boundingVolume;
     const xAxis = new Vector3(halfAxes.getColumn(0));
     const yAxis = new Vector3(halfAxes.getColumn(1));
     const zAxis = new Vector3(halfAxes.getColumn(2));
@@ -6140,10 +6216,7 @@ var __exports__ = (() => {
   }
   function boundingSphereToCartographicBounds(boundingVolume) {
     const result = emptyCartographicBounds();
-    const {
-      center,
-      radius
-    } = boundingVolume;
+    const { center, radius } = boundingVolume;
     const point = Ellipsoid.WGS84.scaleToGeodeticSurface(center, scratchPoint);
     let zAxis;
     if (point) {
@@ -6170,7 +6243,10 @@ var __exports__ = (() => {
     return result;
   }
   function emptyCartographicBounds() {
-    return [[Infinity, Infinity, Infinity], [-Infinity, -Infinity, -Infinity]];
+    return [
+      [Infinity, Infinity, Infinity],
+      [-Infinity, -Infinity, -Infinity]
+    ];
   }
   function addToCartographicBounds(target, cartesian) {
     Ellipsoid.WGS84.cartesianToCartographic(cartesian, scratchPoint);
@@ -6210,13 +6286,8 @@ var __exports__ = (() => {
       return 0;
     }
     const distance2 = Math.max(tile._distanceToCamera, 1e-7);
-    const {
-      height,
-      sseDenominator
-    } = frameState;
-    const {
-      viewDistanceScale
-    } = tileset.options;
+    const { height, sseDenominator } = frameState;
+    const { viewDistanceScale } = tileset.options;
     let error = lodMetricValue * height * (viewDistanceScale || 1) / (distance2 * sseDenominator);
     error -= getDynamicScreenSpaceError(tileset, distance2);
     return error;
@@ -6246,9 +6317,7 @@ var __exports__ = (() => {
     return "OUT";
   }
   function getProjectedRadius(tile, frameState) {
-    const {
-      topDownViewport: viewport
-    } = frameState;
+    const { topDownViewport: viewport } = frameState;
     const mbsLat = tile.header.mbs[1];
     const mbsLon = tile.header.mbs[0];
     const mbsZ = tile.header.mbs[2];
@@ -6260,16 +6329,22 @@ var __exports__ = (() => {
     Ellipsoid.WGS84.eastNorthUpToFixedFrame(mbsCenterCartesian, enuToCartesianMatrix);
     cartesianToEnuMatrix.copy(enuToCartesianMatrix).invert();
     cameraPositionEnu.copy(cameraPositionCartesian).transform(cartesianToEnuMatrix);
-    const projection = Math.sqrt(cameraPositionEnu[0] * cameraPositionEnu[0] + cameraPositionEnu[1] * cameraPositionEnu[1]);
+    const projection = Math.sqrt(
+      cameraPositionEnu[0] * cameraPositionEnu[0] + cameraPositionEnu[1] * cameraPositionEnu[1]
+    );
     const extraZ = projection * projection / cameraPositionEnu[2];
     extraVertexEnu.copy([cameraPositionEnu[0], cameraPositionEnu[1], extraZ]);
     const extraVertexCartesian = extraVertexEnu.transform(enuToCartesianMatrix);
     const extraVectorCartesian = extraVertexCartesian.subtract(mbsCenterCartesian).normalize();
     const radiusVector = toEye.cross(extraVectorCartesian).normalize().scale(mbsR);
     const sphereMbsBorderVertexCartesian = radiusVector.add(mbsCenterCartesian);
-    const sphereMbsBorderVertexCartographic = Ellipsoid.WGS84.cartesianToCartographic(sphereMbsBorderVertexCartesian);
+    const sphereMbsBorderVertexCartographic = Ellipsoid.WGS84.cartesianToCartographic(
+      sphereMbsBorderVertexCartesian
+    );
     const projectedOrigin = viewport.project([mbsLon, mbsLat, mbsZ]);
-    const projectedMbsBorderVertex = viewport.project(sphereMbsBorderVertexCartographic);
+    const projectedMbsBorderVertex = viewport.project(
+      sphereMbsBorderVertexCartographic
+    );
     const projectedRadius = projectedOriginVector.copy(projectedOrigin).subtract(projectedMbsBorderVertex).magnitude();
     return projectedRadius;
   }
@@ -6283,11 +6358,18 @@ var __exports__ = (() => {
 
   // src/utils/managed-array.ts
   var ManagedArray = class {
-    _map = /* @__PURE__ */ new Map();
     constructor(length4 = 0) {
+      this._map = /* @__PURE__ */ new Map();
       this._array = new Array(length4);
       this._length = length4;
     }
+    /**
+     * Gets or sets the length of the array.
+     * If the set length is greater than the length of the internal array, the internal array is resized.
+     *
+     * @memberof ManagedArray.prototype
+     * @type Number
+     */
     get length() {
       return this._length;
     }
@@ -6297,13 +6379,31 @@ var __exports__ = (() => {
         this._array.length = length4;
       }
     }
+    /**
+     * Gets the internal array.
+     *
+     * @memberof ManagedArray.prototype
+     * @type Array
+     * @readonly
+     */
     get values() {
       return this._array;
     }
+    /**
+     * Gets the element at an index.
+     *
+     * @param {Number} index The index to get.
+     */
     get(index) {
       assert2(index < this._array.length);
       return this._array[index];
     }
+    /**
+     * Sets the element at an index. Resizes the array if index is greater than the length of the array.
+     *
+     * @param {Number} index The index to set.
+     * @param {*} element The element to set at index.
+     */
     set(index, element) {
       assert2(index >= 0);
       if (index >= this.length) {
@@ -6323,9 +6423,19 @@ var __exports__ = (() => {
         this.length--;
       }
     }
+    /**
+     * Returns the last element in the array without modifying the array.
+     *
+     * @returns {*} The last element in the array.
+     */
     peek() {
       return this._array[this._length - 1];
     }
+    /**
+     * Push an element into the array.
+     *
+     * @param {*} element The element to push.
+     */
     push(element) {
       if (!this._map.has(element)) {
         const index = this.length++;
@@ -6333,21 +6443,41 @@ var __exports__ = (() => {
         this._map.set(element, index);
       }
     }
+    /**
+     * Pop an element from the array.
+     *
+     * @returns {*} The last element in the array.
+     */
     pop() {
       const element = this._array[--this.length];
       this._map.delete(element);
       return element;
     }
+    /**
+     * Resize the internal array if length > _array.length.
+     *
+     * @param {Number} length The length.
+     */
     reserve(length4) {
       assert2(length4 >= 0);
       if (length4 > this._array.length) {
         this._array.length = length4;
       }
     }
+    /**
+     * Resize the array.
+     *
+     * @param {Number} length The length.
+     */
     resize(length4) {
       assert2(length4 >= 0);
       this.length = length4;
     }
+    /**
+     * Trim the internal array to the specified length. Defaults to the current length.
+     *
+     * @param {Number} [length] The length.
+     */
     trim(length4) {
       if (length4 === null || length4 === void 0) {
         length4 = this.length;
@@ -6375,30 +6505,33 @@ var __exports__ = (() => {
     basePath: ""
   };
   var TilesetTraverser = class {
-    root = null;
-    selectedTiles = {};
-    requestedTiles = {};
-    emptyTiles = {};
-    lastUpdate = new Date().getTime();
-    updateDebounceTime = 1e3;
-    _traversalStack = new ManagedArray();
-    _emptyTraversalStack = new ManagedArray();
-    _frameNumber = null;
+    // TODO nested props
+    constructor(options) {
+      // fulfill in traverse call
+      this.root = null;
+      // tiles should be rendered
+      this.selectedTiles = {};
+      // tiles should be loaded from server
+      this.requestedTiles = {};
+      // tiles does not have render content
+      this.emptyTiles = {};
+      this.lastUpdate = new Date().getTime();
+      this.updateDebounceTime = 1e3;
+      /** temporary storage to hold the traversed tiles during a traversal */
+      this._traversalStack = new ManagedArray();
+      this._emptyTraversalStack = new ManagedArray();
+      /** set in every traverse cycle */
+      this._frameNumber = null;
+      this.options = { ...DEFAULT_PROPS2, ...options };
+    }
+    // RESULT
     traversalFinished(frameState) {
       return true;
     }
-    constructor(options) {
-      this.options = {
-        ...DEFAULT_PROPS2,
-        ...options
-      };
-    }
+    // tiles should be visible
     traverse(root, frameState, options) {
       this.root = root;
-      this.options = {
-        ...this.options,
-        ...options
-      };
+      this.options = { ...this.options, ...options };
       this.reset();
       this.updateTile(root, frameState);
       this._frameNumber = frameState.frameNumber;
@@ -6411,6 +6544,16 @@ var __exports__ = (() => {
       this._traversalStack.reset();
       this._emptyTraversalStack.reset();
     }
+    /**
+     * Execute traverse
+     * Depth-first traversal that traverses all visible tiles and marks tiles for selection.
+     * If skipLevelOfDetail is off then a tile does not refine until all children are loaded.
+     * This is the traditional replacement refinement approach and is called the base traversal.
+     * Tiles that have a greater screen space error than the base screen space error are part of the base traversal,
+     * all other tiles are part of the skip traversal. The skip traversal allows for skipping levels of the tree
+     * and rendering children and parent tiles simultaneously.
+     */
+    /* eslint-disable-next-line complexity, max-statements */
     executeTraversal(root, frameState) {
       const stack = this._traversalStack;
       root._selectionDepth = 1;
@@ -6420,7 +6563,12 @@ var __exports__ = (() => {
         let shouldRefine = false;
         if (this.canTraverse(tile, frameState)) {
           this.updateChildTiles(tile, frameState);
-          shouldRefine = this.updateAndPushChildren(tile, frameState, stack, tile.hasRenderContent ? tile._selectionDepth + 1 : tile._selectionDepth);
+          shouldRefine = this.updateAndPushChildren(
+            tile,
+            frameState,
+            stack,
+            tile.hasRenderContent ? tile._selectionDepth + 1 : tile._selectionDepth
+          );
         }
         const parent = tile.parent;
         const parentRefines = Boolean(!parent || parent._shouldRefine);
@@ -6431,10 +6579,10 @@ var __exports__ = (() => {
           if (stoppedRefining) {
             this.selectTile(tile, frameState);
           }
-        } else if (tile.refine === TILE_REFINEMENT.ADD) {
+        } else if (tile.refine === 1 /* ADD */) {
           this.loadTile(tile, frameState);
           this.selectTile(tile, frameState);
-        } else if (tile.refine === TILE_REFINEMENT.REPLACE) {
+        } else if (tile.refine === 2 /* REPLACE */) {
           this.loadTile(tile, frameState);
           if (stoppedRefining) {
             this.selectTile(tile, frameState);
@@ -6455,14 +6603,12 @@ var __exports__ = (() => {
         this.updateTile(child, frameState);
       }
     }
+    /* eslint-disable complexity, max-statements */
     updateAndPushChildren(tile, frameState, stack, depth) {
-      const {
-        loadSiblings,
-        skipLevelOfDetail
-      } = this.options;
+      const { loadSiblings, skipLevelOfDetail } = this.options;
       const children = tile.children;
       children.sort(this.compareDistanceToCamera.bind(this));
-      const checkRefines = tile.refine === TILE_REFINEMENT.REPLACE && tile.hasRenderContent && !skipLevelOfDetail;
+      const checkRefines = tile.refine === 2 /* REPLACE */ && tile.hasRenderContent && !skipLevelOfDetail;
       let hasVisibleChild = false;
       let refines = true;
       for (const child of children) {
@@ -6497,15 +6643,18 @@ var __exports__ = (() => {
       }
       return refines;
     }
+    /* eslint-enable complexity, max-statements */
     updateTile(tile, frameState) {
       this.updateTileVisibility(tile, frameState);
     }
+    // tile to render in the browser
     selectTile(tile, frameState) {
       if (this.shouldSelectTile(tile)) {
         tile._selectedFrame = frameState.frameNumber;
         this.selectedTiles[tile.id] = tile;
       }
     }
+    // tile to load from server
     loadTile(tile, frameState) {
       if (this.shouldLoadTile(tile)) {
         tile._requestedFrame = frameState.frameNumber;
@@ -6513,10 +6662,14 @@ var __exports__ = (() => {
         this.requestedTiles[tile.id] = tile;
       }
     }
+    // cache tile
     touchTile(tile, frameState) {
       tile.tileset._cache.touch(tile);
       tile._touchedFrame = frameState.frameNumber;
     }
+    // tile should be visible
+    // tile should have children
+    // tile LoD (level of detail) is not sufficient under current viewport
     canTraverse(tile, frameState, useParentMetric = false, ignoreVisibility = false) {
       if (!tile.hasChildren) {
         return false;
@@ -6535,6 +6688,7 @@ var __exports__ = (() => {
     shouldSelectTile(tile) {
       return tile.contentAvailable && !this.options.skipLevelOfDetail;
     }
+    /** Decide if tile LoD (level of detail) is not sufficient under current viewport */
     shouldRefine(tile, frameState, useParentMetric = false) {
       let screenSpaceError = tile._screenSpaceError;
       if (useParentMetric) {
@@ -6556,6 +6710,7 @@ var __exports__ = (() => {
       }
       tile.updateVisibility(frameState, viewportIds);
     }
+    // UTILITIES
     compareDistanceToCamera(b, a) {
       return b._distanceToCamera - a._distanceToCamera;
     }
@@ -6567,6 +6722,8 @@ var __exports__ = (() => {
       }
       return anyVisible;
     }
+    // Depth-first traversal that checks if all nearest descendants with content are loaded.
+    // Ignores visibility.
     executeEmptyTraversal(root, frameState) {
       let allDescendantsLoaded = true;
       const stack = this._emptyTraversalStack;
@@ -6600,43 +6757,68 @@ var __exports__ = (() => {
     return x !== void 0 && x !== null;
   }
   var Tile3D = class {
-    lodMetricType = "geometricError";
-    lodMetricValue = 0;
-    boundingVolume = null;
-    content = null;
-    contentState = TILE_CONTENT_STATE.UNLOADED;
-    gpuMemoryUsageInBytes = 0;
-    children = [];
-    depth = 0;
-    viewportIds = [];
-    transform = new Matrix4();
-    extensions = null;
-    implicitTiling = null;
-    userData = {};
-    hasEmptyContent = false;
-    hasTilesetContent = false;
-    traverser = new TilesetTraverser({});
-    _cacheNode = null;
-    _frameNumber = null;
-    _expireDate = null;
-    _expiredContent = null;
-    _boundingBox = void 0;
-    _distanceToCamera = 0;
-    _screenSpaceError = 0;
-    _visible = void 0;
-    _initialTransform = new Matrix4();
-    _priority = 0;
-    _selectedFrame = 0;
-    _requestedFrame = 0;
-    _selectionDepth = 0;
-    _touchedFrame = 0;
-    _centerZDepth = 0;
-    _shouldRefine = false;
-    _stackLength = 0;
-    _visitedFrame = 0;
-    _inRequestVolume = false;
-    _lodJudge = null;
+    // TODO i3s specific, needs to remove
+    /**
+     * @constructs
+     * Create a Tile3D instance
+     * @param tileset - Tileset3D instance
+     * @param header - tile header - JSON loaded from a dataset
+     * @param parentHeader - parent Tile3D instance
+     * @param extendedId - optional ID to separate copies of a tile for different viewports.
+     *    const extendedId = `${tile.id}-${frameState.viewport.id}`;
+     */
+    // eslint-disable-next-line max-statements
     constructor(tileset, header, parentHeader, extendedId = "") {
+      /** Different refinement algorithms used by I3S and 3D tiles */
+      this.lodMetricType = "geometricError";
+      /** The error, in meters, introduced if this tile is rendered and its children are not. */
+      this.lodMetricValue = 0;
+      /** @todo math.gl is not exporting BoundingVolume base type? */
+      this.boundingVolume = null;
+      /**
+       * The tile's content.  This represents the actual tile's payload,
+       * not the content's metadata in the tileset JSON file.
+       */
+      this.content = null;
+      this.contentState = TILE_CONTENT_STATE.UNLOADED;
+      this.gpuMemoryUsageInBytes = 0;
+      /** The tile's children - an array of Tile3D objects. */
+      this.children = [];
+      this.depth = 0;
+      this.viewportIds = [];
+      this.transform = new Matrix4();
+      this.extensions = null;
+      /** TODO Cesium 3d tiles specific */
+      this.implicitTiling = null;
+      /** Container to store application specific data */
+      this.userData = {};
+      this.hasEmptyContent = false;
+      this.hasTilesetContent = false;
+      this.traverser = new TilesetTraverser({});
+      /** Used by TilesetCache */
+      this._cacheNode = null;
+      this._frameNumber = null;
+      // TODO Cesium 3d tiles specific
+      this._expireDate = null;
+      this._expiredContent = null;
+      this._boundingBox = void 0;
+      /** updated every frame for tree traversal and rendering optimizations: */
+      this._distanceToCamera = 0;
+      this._screenSpaceError = 0;
+      this._visible = void 0;
+      this._initialTransform = new Matrix4();
+      // Used by traverser, cannot be marked private
+      this._priority = 0;
+      this._selectedFrame = 0;
+      this._requestedFrame = 0;
+      this._selectionDepth = 0;
+      this._touchedFrame = 0;
+      this._centerZDepth = 0;
+      this._shouldRefine = false;
+      this._stackLength = 0;
+      this._visitedFrame = 0;
+      this._inRequestVolume = false;
+      this._lodJudge = null;
       this.header = header;
       this.tileset = tileset;
       this.id = extendedId || header.id;
@@ -6667,64 +6849,108 @@ var __exports__ = (() => {
     get isVisibleAndInRequestVolume() {
       return this._visible && this._inRequestVolume;
     }
+    /** Returns true if tile is not an empty tile and not an external tileset */
     get hasRenderContent() {
       return !this.hasEmptyContent && !this.hasTilesetContent;
     }
+    /** Returns true if tile has children */
     get hasChildren() {
       return this.children.length > 0 || this.header.children && this.header.children.length > 0;
     }
+    /**
+     * Determines if the tile's content is ready. This is automatically `true` for
+     * tiles with empty content.
+     */
     get contentReady() {
       return this.contentState === TILE_CONTENT_STATE.READY || this.hasEmptyContent;
     }
+    /**
+     * Determines if the tile has available content to render.  `true` if the tile's
+     * content is ready or if it has expired content this renders while new content loads; otherwise,
+     */
     get contentAvailable() {
-      return Boolean(this.contentReady && this.hasRenderContent || this._expiredContent && !this.contentFailed);
+      return Boolean(
+        this.contentReady && this.hasRenderContent || this._expiredContent && !this.contentFailed
+      );
     }
+    /** Returns true if tile has renderable content but it's unloaded */
     get hasUnloadedContent() {
       return this.hasRenderContent && this.contentUnloaded;
     }
+    /**
+     * Determines if the tile's content has not be requested. `true` if tile's
+     * content has not be requested; otherwise, `false`.
+     */
     get contentUnloaded() {
       return this.contentState === TILE_CONTENT_STATE.UNLOADED;
     }
+    /**
+     * Determines if the tile's content is expired. `true` if tile's
+     * content is expired; otherwise, `false`.
+     */
     get contentExpired() {
       return this.contentState === TILE_CONTENT_STATE.EXPIRED;
     }
+    // Determines if the tile's content failed to load.  `true` if the tile's
+    // content failed to load; otherwise, `false`.
     get contentFailed() {
       return this.contentState === TILE_CONTENT_STATE.FAILED;
     }
+    /**
+     * Distance from the tile's bounding volume center to the camera
+     */
     get distanceToCamera() {
       return this._distanceToCamera;
     }
+    /**
+     * Screen space error for LOD selection
+     */
     get screenSpaceError() {
       return this._screenSpaceError;
     }
+    /**
+     * Get bounding box in cartographic coordinates
+     * @returns [min, max] each in [longitude, latitude, altitude]
+     */
     get boundingBox() {
       if (!this._boundingBox) {
         this._boundingBox = getCartographicBounds(this.header.boundingVolume, this.boundingVolume);
       }
       return this._boundingBox;
     }
+    /** Get the tile's screen space error. */
     getScreenSpaceError(frameState, useParentLodMetric) {
       switch (this.tileset.type) {
-        case TILESET_TYPE.I3S:
+        case "I3S" /* I3S */:
           return getProjectedRadius(this, frameState);
-        case TILESET_TYPE.TILES3D:
+        case "TILES3D" /* TILES3D */:
           return getTiles3DScreenSpaceError(this, frameState, useParentLodMetric);
         default:
           throw new Error("Unsupported tileset type");
       }
     }
+    /**
+     * Make tile unselected than means it won't be shown
+     * but it can be still loaded in memory
+     */
     unselect() {
       this._selectedFrame = 0;
     }
+    /**
+     * Memory usage of tile on GPU
+     */
     _getGpuMemoryUsageInBytes() {
       return this.content.gpuMemoryUsageInBytes || this.content.byteLength || 0;
     }
+    /*
+     * If skipLevelOfDetail is off try to load child tiles as soon as possible so that their parent can refine sooner.
+     * Tiles are prioritized by screen space error.
+     */
+    // eslint-disable-next-line complexity
     _getPriority() {
       const traverser = this.tileset._traverser;
-      const {
-        skipLevelOfDetail
-      } = traverser.options;
-      const maySkipTile = this.refine === TILE_REFINEMENT.ADD || skipLevelOfDetail;
+      const { skipLevelOfDetail } = traverser.options;
+      const maySkipTile = this.refine === 1 /* ADD */ || skipLevelOfDetail;
       if (maySkipTile && !this.isVisible && this._visible !== void 0) {
         return -1;
       }
@@ -6740,6 +6966,11 @@ var __exports__ = (() => {
       const rootScreenSpaceError = traverser.root ? traverser.root._screenSpaceError : 0;
       return Math.max(rootScreenSpaceError - screenSpaceError, 0);
     }
+    /**
+     *  Requests the tile's content.
+     * The request may not be made if the Request Scheduler can't prioritize it.
+     */
+    // eslint-disable-next-line max-statements, complexity
     async loadContent() {
       if (this.hasEmptyContent) {
         return false;
@@ -6752,7 +6983,10 @@ var __exports__ = (() => {
         this._expireDate = null;
       }
       this.contentState = TILE_CONTENT_STATE.LOADING;
-      const requestToken = await this.tileset._requestScheduler.scheduleRequest(this.id, this._getPriority.bind(this));
+      const requestToken = await this.tileset._requestScheduler.scheduleRequest(
+        this.id,
+        this._getPriority.bind(this)
+      );
       if (!requestToken) {
         this.contentState = TILE_CONTENT_STATE.UNLOADED;
         return false;
@@ -6763,6 +6997,7 @@ var __exports__ = (() => {
         const options = {
           ...this.tileset.loadOptions,
           [loader.id]: {
+            // @ts-expect-error
             ...this.tileset.loadOptions[loader.id],
             isTileset: this.type === "json",
             ...this._getLoaderSpecificOptions(loader.id)
@@ -6785,6 +7020,7 @@ var __exports__ = (() => {
         requestToken.done();
       }
     }
+    // Unloads the tile's content.
     unloadContent() {
       if (this.content && this.content.destroy) {
         this.content.destroy();
@@ -6797,6 +7033,12 @@ var __exports__ = (() => {
       this.contentState = TILE_CONTENT_STATE.UNLOADED;
       return true;
     }
+    /**
+     * Update the tile's visibility
+     * @param {Object} frameState - frame state for tile culling
+     * @param {string[]} viewportIds - a list of viewport ids that show this tile
+     * @return {void}
+     */
     updateVisibility(frameState, viewportIds) {
       if (this._frameNumber === frameState.frameNumber) {
         return;
@@ -6815,33 +7057,52 @@ var __exports__ = (() => {
       this._frameNumber = frameState.frameNumber;
       this.viewportIds = viewportIds;
     }
+    // Determines whether the tile's bounding volume intersects the culling volume.
+    // @param {FrameState} frameState The frame state.
+    // @param {Number} parentVisibilityPlaneMask The parent's plane mask to speed up the visibility check.
+    // @returns {Number} A plane mask as described above in {@link CullingVolume#computeVisibilityWithPlaneMask}.
     visibility(frameState, parentVisibilityPlaneMask) {
-      const {
-        cullingVolume: cullingVolume2
-      } = frameState;
-      const {
-        boundingVolume
-      } = this;
+      const { cullingVolume: cullingVolume2 } = frameState;
+      const { boundingVolume } = this;
       return cullingVolume2.computeVisibilityWithPlaneMask(boundingVolume, parentVisibilityPlaneMask);
     }
+    // Assuming the tile's bounding volume intersects the culling volume, determines
+    // whether the tile's content's bounding volume intersects the culling volume.
+    // @param {FrameState} frameState The frame state.
+    // @returns {Intersect} The result of the intersection: the tile's content is completely outside, completely inside, or intersecting the culling volume.
     contentVisibility() {
       return true;
     }
+    /**
+     * Computes the (potentially approximate) distance from the closest point of the tile's bounding volume to the camera.
+     * @param frameState The frame state.
+     * @returns {Number} The distance, in meters, or zero if the camera is inside the bounding volume.
+     */
     distanceToTile(frameState) {
       const boundingVolume = this.boundingVolume;
       return Math.sqrt(Math.max(boundingVolume.distanceSquaredTo(frameState.camera.position), 0));
     }
-    cameraSpaceZDepth({
-      camera
-    }) {
+    /**
+     * Computes the tile's camera-space z-depth.
+     * @param frameState The frame state.
+     * @returns The distance, in meters.
+     */
+    cameraSpaceZDepth({ camera }) {
       const boundingVolume = this.boundingVolume;
       scratchVector10.subVectors(boundingVolume.center, camera.position);
       return camera.direction.dot(scratchVector10);
     }
+    /**
+     * Checks if the camera is inside the viewer request volume.
+     * @param {FrameState} frameState The frame state.
+     * @returns {Boolean} Whether the camera is inside the volume.
+     */
     insideViewerRequestVolume(frameState) {
       const viewerRequestVolume = this._viewerRequestVolume;
       return !viewerRequestVolume || viewerRequestVolume.distanceSquaredTo(frameState.camera.position) <= 0;
     }
+    // TODO Cesium specific
+    // Update whether the tile has expired.
     updateExpiration() {
       if (defined2(this._expireDate) && this.contentReady && !this.hasEmptyContent) {
         const now = Date.now();
@@ -6854,6 +7115,7 @@ var __exports__ = (() => {
     get extras() {
       return this.header.extras;
     }
+    // INTERNAL METHODS
     _initializeLodMetric(header) {
       if ("lodMetricType" in header) {
         this.lodMetricType = header.lodMetricType;
@@ -6865,7 +7127,9 @@ var __exports__ = (() => {
         this.lodMetricValue = header.lodMetricValue;
       } else {
         this.lodMetricValue = this.parent && this.parent.lodMetricValue || this.tileset.lodMetricValue;
-        console.warn("3D Tile: Required prop lodMetricValue is undefined. Using parent lodMetricValue");
+        console.warn(
+          "3D Tile: Required prop lodMetricValue is undefined. Using parent lodMetricValue"
+        );
       }
     }
     _initializeTransforms(tileHeader) {
@@ -6883,10 +7147,7 @@ var __exports__ = (() => {
       this._updateBoundingVolume(tileHeader);
     }
     _initializeContent(tileHeader) {
-      this.content = {
-        _tileset: this.tileset,
-        _tile: this
-      };
+      this.content = { _tileset: this.tileset, _tile: this };
       this.hasEmptyContent = true;
       this.contentState = TILE_CONTENT_STATE.UNLOADED;
       this.hasTilesetContent = false;
@@ -6895,6 +7156,7 @@ var __exports__ = (() => {
         this.hasEmptyContent = false;
       }
     }
+    // TODO - remove anything not related to basic visibility detection
     _initializeRenderingState(header) {
       this.depth = header.level || (this.parent ? this.parent.depth + 1 : 0);
       this._shouldRefine = false;
@@ -6914,7 +7176,7 @@ var __exports__ = (() => {
       this._priority = 0;
     }
     _getRefine(refine) {
-      return refine || this.parent && this.parent.refine || TILE_REFINEMENT.REPLACE;
+      return refine || this.parent && this.parent.refine || 2 /* REPLACE */;
     }
     _isTileset() {
       return this.contentUrl.indexOf(".json") !== -1;
@@ -6934,18 +7196,31 @@ var __exports__ = (() => {
       }
     }
     _updateBoundingVolume(header) {
-      this.boundingVolume = createBoundingVolume(header.boundingVolume, this.computedTransform, this.boundingVolume);
+      this.boundingVolume = createBoundingVolume(
+        header.boundingVolume,
+        this.computedTransform,
+        this.boundingVolume
+      );
       const content = header.content;
       if (!content) {
         return;
       }
       if (content.boundingVolume) {
-        this._contentBoundingVolume = createBoundingVolume(content.boundingVolume, this.computedTransform, this._contentBoundingVolume);
+        this._contentBoundingVolume = createBoundingVolume(
+          content.boundingVolume,
+          this.computedTransform,
+          this._contentBoundingVolume
+        );
       }
       if (header.viewerRequestVolume) {
-        this._viewerRequestVolume = createBoundingVolume(header.viewerRequestVolume, this.computedTransform, this._viewerRequestVolume);
+        this._viewerRequestVolume = createBoundingVolume(
+          header.viewerRequestVolume,
+          this.computedTransform,
+          this._viewerRequestVolume
+        );
       }
     }
+    // Update the tile's transform. The transform is applied to the tile's bounding volumes.
     _updateTransform(parentTransform = new Matrix4()) {
       const computedTransform = parentTransform.clone().multiplyRight(this.transform);
       const didTransformChange = !computedTransform.equals(this.computedTransform);
@@ -6955,6 +7230,7 @@ var __exports__ = (() => {
       this.computedTransform = computedTransform;
       this._updateBoundingVolume(this.header);
     }
+    // Get options which are applicable only for the particular loader
     _getLoaderSpecificOptions(loaderId) {
       switch (loaderId) {
         case "i3s":
@@ -7005,7 +7281,7 @@ var __exports__ = (() => {
         tile._visible = false;
         return;
       }
-      const replace = tile.refine === TILE_REFINEMENT.REPLACE;
+      const replace = tile.refine === 2 /* REPLACE */;
       const useOptimization = tile._optimChildrenWithinParent === TILE3D_OPTIMIZATION_HINT.USE_OPTIMIZATION;
       if (replace && useOptimization && hasChildren) {
         if (!this.anyChildrenVisible(tile, frameState)) {
@@ -7015,10 +7291,8 @@ var __exports__ = (() => {
       }
     }
     meetsScreenSpaceErrorEarly(tile, frameState) {
-      const {
-        parent
-      } = tile;
-      if (!parent || parent.hasTilesetContent || parent.refine !== TILE_REFINEMENT.ADD) {
+      const { parent } = tile;
+      if (!parent || parent.hasTilesetContent || parent.refine !== 1 /* ADD */) {
         return false;
       }
       return !this.shouldRefine(tile, frameState, true);
@@ -7030,13 +7304,25 @@ var __exports__ = (() => {
 
   // src/tileset/format-i3s/i3s-pending-tiles-register.ts
   var I3SPendingTilesRegister = class {
-    frameNumberMap = /* @__PURE__ */ new Map();
+    constructor() {
+      this.frameNumberMap = /* @__PURE__ */ new Map();
+    }
+    /**
+     * Register a new pending tile header for the particular frameNumber
+     * @param viewportId
+     * @param frameNumber
+     */
     register(viewportId, frameNumber) {
       const viewportMap = this.frameNumberMap.get(viewportId) || /* @__PURE__ */ new Map();
       const oldCount = viewportMap.get(frameNumber) || 0;
       viewportMap.set(frameNumber, oldCount + 1);
       this.frameNumberMap.set(viewportId, viewportMap);
     }
+    /**
+     * Deregister a pending tile header for the particular frameNumber
+     * @param viewportId
+     * @param frameNumber
+     */
     deregister(viewportId, frameNumber) {
       const viewportMap = this.frameNumberMap.get(viewportId);
       if (!viewportMap) {
@@ -7045,6 +7331,12 @@ var __exports__ = (() => {
       const oldCount = viewportMap.get(frameNumber) || 1;
       viewportMap.set(frameNumber, oldCount - 1);
     }
+    /**
+     * Check is there are no pending tile headers registered for the particular frameNumber
+     * @param viewportId
+     * @param frameNumber
+     * @returns
+     */
     isZero(viewportId, frameNumber) {
       const count = this.frameNumberMap.get(viewportId)?.get(frameNumber) || 0;
       return count === 0;
@@ -7058,33 +7350,30 @@ var __exports__ = (() => {
     ERROR: "ERROR"
   };
   var I3STileManager = class {
-    pendingTilesRegister = new I3SPendingTilesRegister();
     constructor() {
+      this.pendingTilesRegister = new I3SPendingTilesRegister();
       this._statusMap = {};
     }
+    /**
+     * Add request to map
+     * @param request - node metadata request
+     * @param key - unique key
+     * @param callback - callback after request completed
+     * @param frameState - frameState data
+     */
     add(request, key, callback, frameState) {
       if (!this._statusMap[key]) {
         const {
           frameNumber,
-          viewport: {
-            id
-          }
+          viewport: { id }
         } = frameState;
-        this._statusMap[key] = {
-          request,
-          callback,
-          key,
-          frameState,
-          status: STATUS.REQUESTED
-        };
+        this._statusMap[key] = { request, callback, key, frameState, status: STATUS.REQUESTED };
         this.pendingTilesRegister.register(id, frameNumber);
         request().then((data) => {
           this._statusMap[key].status = STATUS.COMPLETED;
           const {
             frameNumber: actualFrameNumber,
-            viewport: {
-              id: id2
-            }
+            viewport: { id: id2 }
           } = this._statusMap[key].frameState;
           this.pendingTilesRegister.deregister(id2, actualFrameNumber);
           this._statusMap[key].callback(data, frameState);
@@ -7092,37 +7381,47 @@ var __exports__ = (() => {
           this._statusMap[key].status = STATUS.ERROR;
           const {
             frameNumber: actualFrameNumber,
-            viewport: {
-              id: id2
-            }
+            viewport: { id: id2 }
           } = this._statusMap[key].frameState;
           this.pendingTilesRegister.deregister(id2, actualFrameNumber);
           callback(error);
         });
       }
     }
+    /**
+     * Update request if it is still actual for the new frameState
+     * @param key - unique key
+     * @param frameState - frameState data
+     */
     update(key, frameState) {
       if (this._statusMap[key]) {
         const {
           frameNumber,
-          viewport: {
-            id
-          }
+          viewport: { id }
         } = this._statusMap[key].frameState;
         this.pendingTilesRegister.deregister(id, frameNumber);
         const {
           frameNumber: newFrameNumber,
-          viewport: {
-            id: newViewportId
-          }
+          viewport: { id: newViewportId }
         } = frameState;
         this.pendingTilesRegister.register(newViewportId, newFrameNumber);
         this._statusMap[key].frameState = frameState;
       }
     }
+    /**
+     * Find request in the map
+     * @param key - unique key
+     * @returns
+     */
     find(key) {
       return this._statusMap[key];
     }
+    /**
+     * Check it there are pending tile headers for the particular frameNumber
+     * @param viewportId
+     * @param frameNumber
+     * @returns
+     */
     hasPendingTiles(viewportId, frameNumber) {
       return !this.pendingTilesRegister.isZero(viewportId, frameNumber);
     }
@@ -7134,6 +7433,11 @@ var __exports__ = (() => {
       super(options);
       this._tileManager = new I3STileManager();
     }
+    /**
+     * Check if there are no penging tile header requests,
+     * that means the traversal is finished and we can call
+     * following-up callbacks.
+     */
     traversalFinished(frameState) {
       return !this._tileManager.hasPendingTiles(frameState.viewport.id, this._frameNumber || 0);
     }
@@ -7155,7 +7459,12 @@ var __exports__ = (() => {
             if (tileset.tileset.nodePages) {
               request = () => tileset.tileset.nodePagesTile.formTileFromNodePages(child.id);
             }
-            this._tileManager.add(request, extendedId, (header) => this._onTileLoad(header, tile, extendedId), frameState);
+            this._tileManager.add(
+              request,
+              extendedId,
+              (header) => this._onTileLoad(header, tile, extendedId),
+              frameState
+            );
           } else {
             this._tileManager.update(extendedId, frameState);
           }
@@ -7166,9 +7475,7 @@ var __exports__ = (() => {
       return false;
     }
     async _loadTile(nodeId, tileset) {
-      const {
-        loader
-      } = tileset;
+      const { loader } = tileset;
       const nodeUrl = tileset.getTileUrl(`${tileset.url}/nodes/${nodeId}`);
       const options = {
         ...tileset.loadOptions,
@@ -7179,6 +7486,14 @@ var __exports__ = (() => {
       };
       return await (0, import_core22.load)(nodeUrl, loader, options);
     }
+    /**
+     * The callback to init Tile3D instance after loading the tile JSON
+     * @param {Object} header - the tile JSON from a dataset
+     * @param {Tile3D} tile - the parent Tile3D instance
+     * @param {string} extendedId - optional ID to separate copies of a tile for different viewports.
+     *                              const extendedId = `${tile.id}-${frameState.viewport.id}`;
+     * @return {void}
+     */
     _onTileLoad(header, tile, extendedId) {
       const childTile = new Tile3D(tile.tileset, header, tile, extendedId);
       tile.children.push(childTile);
@@ -7197,6 +7512,7 @@ var __exports__ = (() => {
     modelMatrix: new Matrix4(),
     throttleRequests: true,
     maxRequests: 64,
+    /** Default memory values optimized for viewing mesh-based 3D Tiles on both mobile and desktop devices */
     maximumMemoryUsage: 32,
     memoryCacheOverflow: 1,
     maximumTilesSelected: 0,
@@ -7215,9 +7531,7 @@ var __exports__ = (() => {
     loadTiles: true,
     updateTransforms: true,
     viewportTraversersMap: null,
-    loadOptions: {
-      fetch: {}
-    },
+    loadOptions: { fetch: {} },
     attributions: [],
     basePath: "",
     i3s: {}
@@ -7234,48 +7548,68 @@ var __exports__ = (() => {
   var TILES_GPU_MEMORY = "Tile Memory Use";
   var MAXIMUM_SSE = "Maximum Screen Space Error";
   var Tileset3D = class {
-    root = null;
-    roots = {};
-    asset = {};
-    description = "";
-    extras = null;
-    attributions = {};
-    credits = {};
-    contentFormats = {
-      draco: false,
-      meshopt: false,
-      dds: false,
-      ktx2: false
-    };
-    cartographicCenter = null;
-    cartesianCenter = null;
-    zoom = 1;
-    boundingVolume = null;
-    dynamicScreenSpaceErrorComputedDensity = 0;
-    maximumMemoryUsage = 32;
-    gpuMemoryUsageInBytes = 0;
-    memoryAdjustedScreenSpaceError = 0;
-    _cacheBytes = 0;
-    _cacheOverflowBytes = 0;
-    _frameNumber = 0;
-    _queryParams = {};
-    _extensionsUsed = [];
-    _tiles = {};
-    _pendingCount = 0;
-    selectedTiles = [];
-    traverseCounter = 0;
-    geometricError = 0;
-    lastUpdatedVieports = null;
-    _requestedTiles = [];
-    _emptyTiles = [];
-    frameStateData = {};
-    _cache = new TilesetCache();
-    updatePromise = null;
+    /**
+     * Create a new Tileset3D
+     * @param json
+     * @param props
+     */
+    // eslint-disable-next-line max-statements
     constructor(tileset, options) {
-      this.options = {
-        ...DEFAULT_PROPS3,
-        ...options
-      };
+      this.root = null;
+      this.roots = {};
+      /** @todo any->unknown */
+      this.asset = {};
+      // Metadata for the entire tileset
+      this.description = "";
+      this.extras = null;
+      this.attributions = {};
+      this.credits = {};
+      /** flags that contain information about data types in nested tiles */
+      this.contentFormats = { draco: false, meshopt: false, dds: false, ktx2: false };
+      // view props
+      this.cartographicCenter = null;
+      this.cartesianCenter = null;
+      this.zoom = 1;
+      this.boundingVolume = null;
+      /** Updated based on the camera position and direction */
+      this.dynamicScreenSpaceErrorComputedDensity = 0;
+      // METRICS
+      /**
+       * The maximum amount of GPU memory (in MB) that may be used to cache tiles
+       * Tiles not in view are unloaded to enforce private
+       */
+      this.maximumMemoryUsage = 32;
+      /** The total amount of GPU memory in bytes used by the tileset. */
+      this.gpuMemoryUsageInBytes = 0;
+      /**
+       * If loading the level of detail required by maximumScreenSpaceError
+       * results in the memory usage exceeding maximumMemoryUsage (GPU), level of detail refinement
+       * will instead use this (larger) adjusted screen space error to achieve the
+       * best possible visual quality within the available memory.
+       */
+      this.memoryAdjustedScreenSpaceError = 0;
+      this._cacheBytes = 0;
+      this._cacheOverflowBytes = 0;
+      /** Update tracker. increase in each update cycle. */
+      this._frameNumber = 0;
+      this._queryParams = {};
+      this._extensionsUsed = [];
+      this._tiles = {};
+      /** counter for tracking tiles requests */
+      this._pendingCount = 0;
+      /** Hold traversal results */
+      this.selectedTiles = [];
+      // TRAVERSAL
+      this.traverseCounter = 0;
+      this.geometricError = 0;
+      this.lastUpdatedVieports = null;
+      this._requestedTiles = [];
+      this._emptyTiles = [];
+      this.frameStateData = {};
+      this._cache = new TilesetCache();
+      // Promise tracking
+      this.updatePromise = null;
+      this.options = { ...DEFAULT_PROPS3, ...options };
       this.tileset = tileset;
       this.loader = tileset.loader;
       this.type = tileset.type;
@@ -7295,15 +7629,15 @@ var __exports__ = (() => {
       this.memoryAdjustedScreenSpaceError = this.options.maximumScreenSpaceError;
       this._cacheBytes = this.options.maximumMemoryUsage * 1024 * 1024;
       this._cacheOverflowBytes = this.options.memoryCacheOverflow * 1024 * 1024;
-      this.stats = new Stats({
-        id: this.url
-      });
+      this.stats = new Stats({ id: this.url });
       this._initializeStats();
       this.tilesetInitializationPromise = this._initializeTileSet(tileset);
     }
+    /** Release resources */
     destroy() {
       this._destroy();
     }
+    /** Is the tileset loaded (update needs to have been called at least once) */
     isLoaded() {
       return this._pendingCount === 0 && this._frameNumber !== 0 && this._requestedTiles.length === 0;
     }
@@ -7317,11 +7651,16 @@ var __exports__ = (() => {
       return new URLSearchParams(this._queryParams).toString();
     }
     setProps(props) {
-      this.options = {
-        ...this.options,
-        ...props
-      };
-    }
+      this.options = { ...this.options, ...props };
+    }
+    /** @deprecated */
+    // setOptions(options: Tileset3DProps): void {
+    //   this.options = {...this.options, ...options};
+    // }
+    /**
+     * Return a loadable tile url for a specific tile subpath
+     * @param tilePath a tile subpath
+     */
     getTileUrl(tilePath) {
       const isDataUrl = tilePath.startsWith("data:");
       if (isDataUrl) {
@@ -7333,9 +7672,15 @@ var __exports__ = (() => {
       }
       return tileUrl;
     }
+    // TODO CESIUM specific
     hasExtension(extensionName) {
       return Boolean(this._extensionsUsed.indexOf(extensionName) > -1);
     }
+    /**
+     * Update visible tiles relying on a list of viewports
+     * @param viewports - list of viewports
+     * @deprecated
+     */
     update(viewports = null) {
       this.tilesetInitializationPromise.then(() => {
         if (!viewports && this.lastUpdatedVieports) {
@@ -7348,6 +7693,12 @@ var __exports__ = (() => {
         }
       });
     }
+    /**
+     * Update visible tiles relying on a list of viewports.
+     * Do it with debounce delay to prevent update spam
+     * @param viewports viewports
+     * @returns Promise of new frameNumber
+     */
     async selectTiles(viewports = null) {
       await this.tilesetInitializationPromise;
       if (viewports) {
@@ -7368,11 +7719,19 @@ var __exports__ = (() => {
     }
     adjustScreenSpaceError() {
       if (this.gpuMemoryUsageInBytes < this._cacheBytes) {
-        this.memoryAdjustedScreenSpaceError = Math.max(this.memoryAdjustedScreenSpaceError / 1.02, this.options.maximumScreenSpaceError);
+        this.memoryAdjustedScreenSpaceError = Math.max(
+          this.memoryAdjustedScreenSpaceError / 1.02,
+          this.options.maximumScreenSpaceError
+        );
       } else if (this.gpuMemoryUsageInBytes > this._cacheBytes + this._cacheOverflowBytes) {
         this.memoryAdjustedScreenSpaceError *= 1.02;
       }
     }
+    /**
+     * Update visible tiles relying on a list of viewports
+     * @param viewports viewports
+     */
+    // eslint-disable-next-line max-statements, complexity
     doUpdate(viewports) {
       if ("loadTiles" in this.options && !this.options.loadTiles) {
         return;
@@ -7405,6 +7764,11 @@ var __exports__ = (() => {
         this._traverser.traverse(this.roots[id], frameState, this.options);
       }
     }
+    /**
+     * Check if traversal is needed for particular viewport
+     * @param {string} viewportId - id of a viewport
+     * @return {boolean}
+     */
     _needTraverse(viewportId) {
       let traverserId = viewportId;
       if (this.options.viewportTraversersMap) {
@@ -7415,18 +7779,22 @@ var __exports__ = (() => {
       }
       return true;
     }
+    /**
+     * The callback to post-process tiles after traversal procedure
+     * @param frameState - frame state for tile culling
+     */
     _onTraversalEnd(frameState) {
       const id = frameState.viewport.id;
       if (!this.frameStateData[id]) {
-        this.frameStateData[id] = {
-          selectedTiles: [],
-          _requestedTiles: [],
-          _emptyTiles: []
-        };
+        this.frameStateData[id] = { selectedTiles: [], _requestedTiles: [], _emptyTiles: [] };
       }
       const currentFrameStateData = this.frameStateData[id];
       const selectedTiles = Object.values(this._traverser.selectedTiles);
-      const [filteredSelectedTiles, unselectedTiles] = limitSelectedTiles(selectedTiles, frameState, this.options.maximumTilesSelected);
+      const [filteredSelectedTiles, unselectedTiles] = limitSelectedTiles(
+        selectedTiles,
+        frameState,
+        this.options.maximumTilesSelected
+      );
       currentFrameStateData.selectedTiles = filteredSelectedTiles;
       for (const tile of unselectedTiles) {
         tile.unselect();
@@ -7439,6 +7807,9 @@ var __exports__ = (() => {
       }
       this._updateTiles();
     }
+    /**
+     * Update tiles relying on data from all traversers
+     */
     _updateTiles() {
       this.selectedTiles = [];
       this._requestedTiles = [];
@@ -7496,31 +7867,34 @@ var __exports__ = (() => {
       this.stats.get(MAXIMUM_SSE).count = this.memoryAdjustedScreenSpaceError;
     }
     async _initializeTileSet(tilesetJson) {
-      if (this.type === TILESET_TYPE.I3S) {
+      if (this.type === "I3S" /* I3S */) {
         this.calculateViewPropsI3S();
         tilesetJson.root = await tilesetJson.root;
       }
       this.root = this._initializeTileHeaders(tilesetJson, null);
-      if (this.type === TILESET_TYPE.TILES3D) {
+      if (this.type === "TILES3D" /* TILES3D */) {
         this._initializeTiles3DTileset(tilesetJson);
         this.calculateViewPropsTiles3D();
       }
-      if (this.type === TILESET_TYPE.I3S) {
+      if (this.type === "I3S" /* I3S */) {
         this._initializeI3STileset();
       }
     }
+    /**
+     * Called during initialize Tileset to initialize the tileset's cartographic center (longitude, latitude) and zoom.
+     * These metrics help apps center view on tileset
+     * For I3S there is extent (<1.8 version) or fullExtent (>=1.8 version) to calculate view props
+     * @returns
+     */
     calculateViewPropsI3S() {
       const fullExtent = this.tileset.fullExtent;
       if (fullExtent) {
-        const {
-          xmin,
-          xmax,
-          ymin,
-          ymax,
-          zmin,
-          zmax
-        } = fullExtent;
-        this.cartographicCenter = new Vector3(xmin + (xmax - xmin) / 2, ymin + (ymax - ymin) / 2, zmin + (zmax - zmin) / 2);
+        const { xmin, xmax, ymin, ymax, zmin, zmax } = fullExtent;
+        this.cartographicCenter = new Vector3(
+          xmin + (xmax - xmin) / 2,
+          ymin + (ymax - ymin) / 2,
+          zmin + (zmax - zmin) / 2
+        );
         this.cartesianCenter = new Vector3();
         Ellipsoid.WGS84.cartographicToCartesian(this.cartographicCenter, this.cartesianCenter);
         this.zoom = getZoomFromFullExtent(fullExtent, this.cartographicCenter, this.cartesianCenter);
@@ -7540,11 +7914,15 @@ var __exports__ = (() => {
       this.zoom = 1;
       return;
     }
+    /**
+     * Called during initialize Tileset to initialize the tileset's cartographic center (longitude, latitude) and zoom.
+     * These metrics help apps center view on tileset.
+     * For 3DTiles the root tile data is used to calculate view props.
+     * @returns
+     */
     calculateViewPropsTiles3D() {
       const root = this.root;
-      const {
-        center
-      } = root.boundingVolume;
+      const { center } = root.boundingVolume;
       if (!center) {
         console.warn("center was not pre-calculated for the root tile");
         this.cartographicCenter = new Vector3();
@@ -7573,13 +7951,15 @@ var __exports__ = (() => {
       this.stats.get(TILES_GPU_MEMORY, "memory");
       this.stats.get(MAXIMUM_SSE);
     }
+    // Installs the main tileset JSON file or a tileset JSON file referenced from a tile.
+    // eslint-disable-next-line max-statements
     _initializeTileHeaders(tilesetJson, parentTileHeader) {
       const rootTile = new Tile3D(this, tilesetJson.root, parentTileHeader);
       if (parentTileHeader) {
         parentTileHeader.children.push(rootTile);
         rootTile.depth = parentTileHeader.depth + 1;
       }
-      if (this.type === TILESET_TYPE.TILES3D) {
+      if (this.type === "TILES3D" /* TILES3D */) {
         const stack = [];
         stack.push(rootTile);
         while (stack.length > 0) {
@@ -7607,10 +7987,10 @@ var __exports__ = (() => {
       let TraverserClass;
       const type = this.type;
       switch (type) {
-        case TILESET_TYPE.TILES3D:
+        case "TILES3D" /* TILES3D */:
           TraverserClass = Tileset3DTraverser;
           break;
-        case TILESET_TYPE.I3S:
+        case "I3S" /* I3S */:
           TraverserClass = I3STilesetTraverser;
           break;
         default:
@@ -7647,7 +8027,7 @@ var __exports__ = (() => {
       if (!loaded) {
         return;
       }
-      if (this.type === TILESET_TYPE.I3S) {
+      if (this.type === "I3S" /* I3S */) {
         const nodesInNodePages = this.tileset?.nodePagesTile?.nodesInNodePages || 0;
         this.stats.get(TILES_TOTAL).reset();
         this.stats.get(TILES_TOTAL).addCount(nodesInNodePages);
@@ -7659,8 +8039,12 @@ var __exports__ = (() => {
       this._addTileToCache(tile);
       this.options.onTileLoad(tile);
     }
+    /**
+     * Update information about data types in nested tiles
+     * @param tile instance of a nested Tile3D
+     */
     updateContentTypes(tile) {
-      if (this.type === TILESET_TYPE.I3S) {
+      if (this.type === "I3S" /* I3S */) {
         if (tile.header.isDracoGeometry) {
           this.contentFormats.draco = true;
         }
@@ -7673,10 +8057,8 @@ var __exports__ = (() => {
             break;
           default:
         }
-      } else if (this.type === TILESET_TYPE.TILES3D) {
-        const {
-          extensionsRemoved = []
-        } = tile.content?.gltf || {};
+      } else if (this.type === "TILES3D" /* TILES3D */) {
+        const { extensionsRemoved = [] } = tile.content?.gltf || {};
         if (extensionsRemoved.includes("KHR_draco_mesh_compression")) {
           this.contentFormats.draco = true;
         }
@@ -7716,6 +8098,7 @@ var __exports__ = (() => {
       this.options.onTileUnload(tile);
       tile.unloadContent();
     }
+    // Traverse the tree and destroy all tiles
     _destroy() {
       const stack = [];
       if (this.root) {
@@ -7730,6 +8113,7 @@ var __exports__ = (() => {
       }
       this.root = null;
     }
+    // Traverse the tree and destroy all sub tiles
     _destroySubtree(tile) {
       const root = tile;
       const stack = [];
@@ -7754,10 +8138,7 @@ var __exports__ = (() => {
       if (tilesetJson.queryString) {
         const searchParams = new URLSearchParams(tilesetJson.queryString);
         const queryParams = Object.fromEntries(searchParams.entries());
-        this._queryParams = {
-          ...this._queryParams,
-          ...queryParams
-        };
+        this._queryParams = { ...this._queryParams, ...queryParams };
       }
       this.asset = tilesetJson.asset;
       if (!this.asset) {
@@ -7784,7 +8165,7 @@ var __exports__ = (() => {
       }
     }
   };
-  return __toCommonJS(src_exports);
+  return __toCommonJS(bundle_exports);
 })();
       return __exports__;
       });