@loaders.gl/tile-converter 3.4.0-alpha.4 → 3.4.0

package/dist/dist.min.js

@@ -9363,7 +9363,7 @@ var require_perspective_frustum = __commonJS({
     var _defineProperty2 = _interopRequireDefault(require_defineProperty());
     var _core = require_es5();
     var _perspectiveOffCenterFrustum = _interopRequireDefault(require_perspective_off_center_frustum());
-    var defined6 = function defined7(val) {
+    var defined5 = function defined6(val) {
       return val !== null && typeof val !== "undefined";
     };
     var PerspectiveFrustum = function() {
@@ -9406,7 +9406,7 @@ var require_perspective_frustum = __commonJS({
       }, {
         key: "equals",
         value: function equals2(other) {
-          if (!defined6(other) || !(other instanceof PerspectiveFrustum2)) {
+          if (!defined5(other) || !(other instanceof PerspectiveFrustum2)) {
             return false;
           }
           this._update();
@@ -48098,40 +48098,55 @@ function parseMIMETypeFromURL(url) {
   return "";
 }
 
-// ../core/src/lib/utils/resource-utils.ts
+// ../core/src/lib/utils/url-utils.ts
 var QUERY_STRING_PATTERN = /\?.*/;
-function getResourceUrlAndType(resource) {
+function extractQueryString(url) {
+  const matches3 = url.match(QUERY_STRING_PATTERN);
+  return matches3 && matches3[0];
+}
+function stripQueryString(url) {
+  return url.replace(QUERY_STRING_PATTERN, "");
+}
+
+// ../core/src/lib/utils/resource-utils.ts
+function getResourceUrl(resource) {
   if (isResponse(resource)) {
-    const url = stripQueryString(resource.url || "");
-    const contentTypeHeader = resource.headers.get("content-type") || "";
-    return {
-      url,
-      type: parseMIMEType(contentTypeHeader) || parseMIMETypeFromURL(url)
-    };
+    const response = resource;
+    return response.url;
   }
   if (isBlob(resource)) {
-    return {
-      url: stripQueryString(resource.name || ""),
-      type: resource.type || ""
-    };
+    const blob = resource;
+    return blob.name || "";
   }
   if (typeof resource === "string") {
-    return {
-      url: stripQueryString(resource),
-      type: parseMIMETypeFromURL(resource)
-    };
+    return resource;
   }
-  return {
-    url: "",
-    type: ""
-  };
+  return "";
+}
+function getResourceMIMEType(resource) {
+  if (isResponse(resource)) {
+    const response = resource;
+    const contentTypeHeader = response.headers.get("content-type") || "";
+    const noQueryUrl = stripQueryString(response.url);
+    return parseMIMEType(contentTypeHeader) || parseMIMETypeFromURL(noQueryUrl);
+  }
+  if (isBlob(resource)) {
+    const blob = resource;
+    return blob.type || "";
+  }
+  if (typeof resource === "string") {
+    return parseMIMETypeFromURL(resource);
+  }
+  return "";
 }
 function getResourceContentLength(resource) {
   if (isResponse(resource)) {
-    return resource.headers["content-length"] || -1;
+    const response = resource;
+    return response.headers["content-length"] || -1;
   }
   if (isBlob(resource)) {
-    return resource.size;
+    const blob = resource;
+    return blob.size;
   }
   if (typeof resource === "string") {
     return resource.length;
@@ -48144,9 +48159,6 @@ function getResourceContentLength(resource) {
   }
   return -1;
 }
-function stripQueryString(url) {
-  return url.replace(QUERY_STRING_PATTERN, "");
-}
 
 // ../core/src/lib/utils/response-utils.ts
 async function makeResponse(resource) {
@@ -48158,7 +48170,8 @@ async function makeResponse(resource) {
   if (contentLength >= 0) {
     headers["content-length"] = String(contentLength);
   }
-  const { url, type } = getResourceUrlAndType(resource);
+  const url = getResourceUrl(resource);
+  const type = getResourceMIMEType(resource);
   if (type) {
     headers["content-type"] = type;
   }
@@ -49027,8 +49040,9 @@ function selectLoaderSync(data, loaders = [], options, context) {
   return loader;
 }
 function selectLoaderInternal(data, loaders, options, context) {
-  const { url, type } = getResourceUrlAndType(data);
-  const testUrl = url || context?.url;
+  const url = getResourceUrl(data);
+  const type = getResourceMIMEType(data);
+  const testUrl = stripQueryString(url) || context?.url;
   let loader = null;
   let reason = "";
   if (options?.mimeType) {
@@ -49057,7 +49071,8 @@ function validHTTPResponse(data) {
   return true;
 }
 function getNoValidLoaderMessage(data) {
-  const { url, type } = getResourceUrlAndType(data);
+  const url = getResourceUrl(data);
+  const type = getResourceMIMEType(data);
   let message = "No valid loader found (";
   message += url ? `${path_exports.filename(url)}, ` : "no url provided, ";
   message += `MIME type: ${type ? `"${type}"` : "not provided"}, `;
@@ -49331,18 +49346,25 @@ function getFetchFunction(options, context) {
 }
 
 // ../core/src/lib/loader-utils/loader-context.ts
-function getLoaderContext(context, options, previousContext = null) {
-  if (previousContext) {
-    return previousContext;
+function getLoaderContext(context, options, parentContext) {
+  if (parentContext) {
+    return parentContext;
   }
-  const resolvedContext = {
+  const newContext = {
     fetch: getFetchFunction(options, context),
     ...context
   };
-  if (!Array.isArray(resolvedContext.loaders)) {
-    resolvedContext.loaders = null;
+  if (newContext.url) {
+    const baseUrl = stripQueryString(newContext.url);
+    newContext.baseUrl = baseUrl;
+    newContext.queryString = extractQueryString(newContext.url);
+    newContext.filename = path_exports.filename(baseUrl);
+    newContext.baseUrl = path_exports.dirname(baseUrl);
+  }
+  if (!Array.isArray(newContext.loaders)) {
+    newContext.loaders = null;
   }
-  return resolvedContext;
+  return newContext;
 }
 function getLoadersFromContext(loaders, context) {
   if (!context && loaders && !Array.isArray(loaders)) {
@@ -49369,7 +49391,7 @@ async function parse(data, loaders, options, context) {
   }
   data = await data;
   options = options || {};
-  const { url } = getResourceUrlAndType(data);
+  const url = getResourceUrl(data);
   const typedLoaders = loaders;
   const candidateLoaders = getLoadersFromContext(typedLoaders, context);
   const loader = await selectLoader(data, candidateLoaders, options);
@@ -49377,7 +49399,7 @@ async function parse(data, loaders, options, context) {
     return null;
   }
   options = normalizeOptions(options, loader, candidateLoaders, url);
-  context = getLoaderContext({ url, parse, loaders: candidateLoaders }, options, context);
+  context = getLoaderContext({ url, parse, loaders: candidateLoaders }, options, context || null);
   return await parseWithLoader(loader, data, options, context);
 }
 async function parseWithLoader(loader, data, options, context) {
@@ -49560,9 +49582,6 @@ var DoublyLinkedList = class {
 };
 
 // ../tiles/src/tileset/tileset-cache.ts
-function defined(x) {
-  return x !== void 0 && x !== null;
-}
 var TilesetCache = class {
   constructor() {
     this._list = new DoublyLinkedList();
@@ -49574,12 +49593,12 @@ var TilesetCache = class {
   }
   touch(tile) {
     const node2 = tile._cacheNode;
-    if (defined(node2)) {
+    if (node2) {
       this._list.splice(this._sentinel, node2);
     }
   }
   add(tileset, tile, addCallback) {
-    if (!defined(tile._cacheNode)) {
+    if (!tile._cacheNode) {
       tile._cacheNode = this._list.add(tile);
       if (addCallback) {
         addCallback(tileset, tile);
@@ -49588,11 +49607,11 @@ var TilesetCache = class {
   }
   unloadTile(tileset, tile, unloadCallback) {
     const node2 = tile._cacheNode;
-    if (!defined(node2)) {
+    if (!node2) {
       return;
     }
     this._list.remove(node2);
-    tile._cacheNode = void 0;
+    tile._cacheNode = null;
     if (unloadCallback) {
       unloadCallback(tileset, tile);
     }
@@ -49843,7 +49862,7 @@ var TILE3D_OPTIMIZATION_HINT = {
 var import_core4 = __toModule(require_es5());
 var import_culling3 = __toModule(require_es53());
 var import_geospatial4 = __toModule(require_es52());
-function defined2(x) {
+function defined(x) {
   return x !== void 0 && x !== null;
 }
 var scratchPoint = new import_core4.Vector3();
@@ -49919,7 +49938,7 @@ function createBox(box, transform11, result) {
     zAxis[1],
     zAxis[2]
   ]);
-  if (defined2(result)) {
+  if (defined(result)) {
     result.center = center;
     result.halfAxes = halfAxes;
     return result;
@@ -49932,7 +49951,7 @@ function createSphere(sphere, transform11, result) {
   const scale = transform11.getScale(scratchScale);
   const uniformScale = Math.max(Math.max(scale[0], scale[1]), scale[2]);
   const radius = sphere[3] * uniformScale;
-  if (defined2(result)) {
+  if (defined(result)) {
     result.center = center;
     result.radius = radius;
     return result;
@@ -50196,16 +50215,16 @@ var DEFAULT_PROPS4 = {
 };
 var TilesetTraverser = class {
   constructor(options) {
+    this.root = null;
+    this.selectedTiles = {};
+    this.requestedTiles = {};
+    this.emptyTiles = {};
     this.lastUpdate = new Date().getTime();
     this.updateDebounceTime = 1e3;
-    this.options = { ...DEFAULT_PROPS4, ...options };
     this._traversalStack = new ManagedArray();
     this._emptyTraversalStack = new ManagedArray();
     this._frameNumber = null;
-    this.root = null;
-    this.selectedTiles = {};
-    this.requestedTiles = {};
-    this.emptyTiles = {};
+    this.options = { ...DEFAULT_PROPS4, ...options };
   }
   traversalFinished(frameState) {
     return true;
@@ -50219,9 +50238,6 @@ var TilesetTraverser = class {
     this.executeTraversal(root, frameState);
   }
   reset() {
-    this.requestedTiles = {};
-    this.selectedTiles = {};
-    this.emptyTiles = {};
     this._traversalStack.reset();
     this._emptyTraversalStack.reset();
   }
@@ -50268,7 +50284,6 @@ var TilesetTraverser = class {
     for (const child of children) {
       this.updateTile(child, frameState);
     }
-    return true;
   }
   updateAndPushChildren(tile, frameState, stack2, depth) {
     const { loadSiblings, skipLevelOfDetail } = this.options;
@@ -50347,7 +50362,7 @@ var TilesetTraverser = class {
   shouldSelectTile(tile) {
     return tile.contentAvailable && !this.options.skipLevelOfDetail;
   }
-  shouldRefine(tile, frameState, useParentMetric) {
+  shouldRefine(tile, frameState, useParentMetric = false) {
     let screenSpaceError = tile._screenSpaceError;
     if (useParentMetric) {
       screenSpaceError = tile.getScreenSpaceError(frameState, true);
@@ -50409,19 +50424,11 @@ var TilesetTraverser = class {
 
 // ../tiles/src/tileset/tile-3d.ts
 var scratchVector3 = new import_core7.Vector3();
-function defined3(x) {
+function defined2(x) {
   return x !== void 0 && x !== null;
 }
 var Tile3D = class {
   constructor(tileset, header, parentHeader, extendedId = "") {
-    this.header = header;
-    this.tileset = tileset;
-    this.id = extendedId || header.id;
-    this.url = header.url;
-    this.parent = parentHeader;
-    this.refine = this._getRefine(header.refine);
-    this.type = header.type;
-    this.contentUrl = header.contentUrl;
     this.lodMetricType = "geometricError";
     this.lodMetricValue = 0;
     this.boundingVolume = null;
@@ -50429,40 +50436,46 @@ var Tile3D = class {
     this.contentState = TILE_CONTENT_STATE.UNLOADED;
     this.gpuMemoryUsageInBytes = 0;
     this.children = [];
-    this.hasEmptyContent = false;
-    this.hasTilesetContent = false;
     this.depth = 0;
     this.viewportIds = [];
-    this.userData = {};
+    this.transform = new import_core7.Matrix4();
     this.extensions = null;
-    this._priority = 0;
-    this._touchedFrame = 0;
-    this._visitedFrame = 0;
-    this._selectedFrame = 0;
-    this._requestedFrame = 0;
-    this._screenSpaceError = 0;
+    this.implicitTiling = null;
+    this.userData = {};
+    this.hasEmptyContent = false;
+    this.hasTilesetContent = false;
+    this.traverser = new TilesetTraverser({});
     this._cacheNode = null;
     this._frameNumber = null;
-    this._cacheNode = null;
-    this.traverser = new TilesetTraverser({});
-    this._shouldRefine = false;
+    this._expireDate = null;
+    this._expiredContent = null;
     this._distanceToCamera = 0;
-    this._centerZDepth = 0;
+    this._screenSpaceError = 0;
     this._visible = void 0;
-    this._inRequestVolume = false;
-    this._stackLength = 0;
-    this._selectionDepth = 0;
     this._initialTransform = new import_core7.Matrix4();
-    this.transform = new import_core7.Matrix4();
+    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.header = header;
+    this.tileset = tileset;
+    this.id = extendedId || header.id;
+    this.url = header.url;
+    this.parent = parentHeader;
+    this.refine = this._getRefine(header.refine);
+    this.type = header.type;
+    this.contentUrl = header.contentUrl;
     this._initializeLodMetric(header);
     this._initializeTransforms(header);
     this._initializeBoundingVolumes(header);
     this._initializeContent(header);
     this._initializeRenderingState(header);
-    this._lodJudge = null;
-    this._expireDate = null;
-    this._expiredContent = null;
-    this.implicitTiling = null;
     Object.seal(this);
   }
   destroy() {
@@ -50529,6 +50542,9 @@ var Tile3D = class {
   unselect() {
     this._selectedFrame = 0;
   }
+  _getGpuMemoryUsageInBytes() {
+    return this.content.gpuMemoryUsageInBytes || this.content.byteLength || 0;
+  }
   _getPriority() {
     const traverser = this.tileset._traverser;
     const { skipLevelOfDetail } = traverser.options;
@@ -50645,7 +50661,7 @@ var Tile3D = class {
     return !viewerRequestVolume || viewerRequestVolume.distanceSquaredTo(frameState.camera.position) <= 0;
   }
   updateExpiration() {
-    if (defined3(this._expireDate) && this.contentReady && !this.hasEmptyContent) {
+    if (defined2(this._expireDate) && this.contentReady && !this.hasEmptyContent) {
       const now = Date.now();
       if (Date.lessThan(this._expireDate, now)) {
         this.contentState = TILE_CONTENT_STATE.EXPIRED;
@@ -50728,6 +50744,8 @@ var Tile3D = class {
     }
     if (this._isTileset()) {
       this.hasTilesetContent = true;
+    } else {
+      this.gpuMemoryUsageInBytes = this._getGpuMemoryUsageInBytes();
     }
   }
   _updateBoundingVolume(header) {
@@ -51005,57 +51023,56 @@ var TILES_LOAD_FAILED = "Failed Tile Loads";
 var POINTS_COUNT = "Points/Vertices";
 var TILES_GPU_MEMORY = "Tile Memory Use";
 var Tileset3D = class {
-  constructor(json, options) {
-    this.contentFormats = { draco: false, meshopt: false, dds: false, ktx2: false };
-    this.updatePromise = null;
-    assert2(json);
-    this.options = { ...DEFAULT_PROPS5, ...options };
-    this.tileset = json;
-    this.loader = json.loader;
-    this.type = json.type;
-    this.url = json.url;
-    this.basePath = json.basePath || path_exports.dirname(this.url);
-    this.modelMatrix = this.options.modelMatrix;
-    this.ellipsoid = this.options.ellipsoid;
-    this.lodMetricType = json.lodMetricType;
-    this.lodMetricValue = json.lodMetricValue;
-    this.refine = json.root.refine;
-    this.loadOptions = this.options.loadOptions || {};
+  constructor(tileset, options) {
     this.root = null;
     this.roots = {};
+    this.asset = {};
+    this.description = "";
+    this.extras = null;
+    this.attributions = {};
+    this.credits = {};
+    this.contentFormats = { draco: false, meshopt: false, dds: false, ktx2: false };
     this.cartographicCenter = null;
     this.cartesianCenter = null;
     this.zoom = 1;
     this.boundingVolume = null;
+    this.dynamicScreenSpaceErrorComputedDensity = 0;
+    this.maximumMemoryUsage = 32;
+    this.gpuMemoryUsageInBytes = 0;
+    this._frameNumber = 0;
+    this._queryParams = {};
+    this._extensionsUsed = [];
+    this._tiles = {};
+    this._pendingCount = 0;
+    this.selectedTiles = [];
     this.traverseCounter = 0;
     this.geometricError = 0;
-    this._traverser = this._initializeTraverser();
+    this.lastUpdatedVieports = null;
+    this._requestedTiles = [];
+    this._emptyTiles = [];
+    this.frameStateData = {};
     this._cache = new TilesetCache();
+    this.updatePromise = null;
+    this.options = { ...DEFAULT_PROPS5, ...options };
+    this.tileset = tileset;
+    this.loader = tileset.loader;
+    this.type = tileset.type;
+    this.url = tileset.url;
+    this.basePath = tileset.basePath || path_exports.dirname(this.url);
+    this.modelMatrix = this.options.modelMatrix;
+    this.ellipsoid = this.options.ellipsoid;
+    this.lodMetricType = tileset.lodMetricType;
+    this.lodMetricValue = tileset.lodMetricValue;
+    this.refine = tileset.root.refine;
+    this.loadOptions = this.options.loadOptions || {};
+    this._traverser = this._initializeTraverser();
     this._requestScheduler = new RequestScheduler({
       throttleRequests: this.options.throttleRequests,
       maxRequests: this.options.maxRequests
     });
-    this._frameNumber = 0;
-    this._pendingCount = 0;
-    this._tiles = {};
-    this.selectedTiles = [];
-    this._emptyTiles = [];
-    this._requestedTiles = [];
-    this.frameStateData = {};
-    this.lastUpdatedVieports = null;
-    this._queryParams = {};
-    this._queryParamsString = "";
-    this.maximumMemoryUsage = this.options.maximumMemoryUsage || 32;
-    this.gpuMemoryUsageInBytes = 0;
     this.stats = new Stats({ id: this.url });
     this._initializeStats();
-    this._extensionsUsed = void 0;
-    this.dynamicScreenSpaceErrorComputedDensity = 0;
-    this.extras = null;
-    this.asset = {};
-    this.credits = {};
-    this.description = this.options.description || "";
-    this.tilesetInitializationPromise = this._initializeTileSet(json);
+    this.tilesetInitializationPromise = this._initializeTileSet(tileset);
   }
   destroy() {
     this._destroy();
@@ -51070,10 +51087,8 @@ var Tileset3D = class {
     return this._frameNumber;
   }
   get queryParams() {
-    if (!this._queryParamsString) {
-      this._queryParamsString = getQueryParamString(this._queryParams);
-    }
-    return this._queryParamsString;
+    const search = new URLSearchParams(this._queryParams).toString();
+    return search ? `?${search}` : "";
   }
   setProps(props) {
     this.options = { ...this.options, ...props };
@@ -51086,10 +51101,10 @@ var Tileset3D = class {
     if (isDataUrl) {
       return tilePath;
     }
-    return `${tilePath}${this.queryParams}`;
+    return `${tilePath}${tilePath.includes("?") ? "&" : "?"}${this.queryParams}`;
   }
   hasExtension(extensionName) {
-    return Boolean(this._extensionsUsed && this._extensionsUsed.indexOf(extensionName) > -1);
+    return Boolean(this._extensionsUsed.indexOf(extensionName) > -1);
   }
   update(viewports = null) {
     this.tilesetInitializationPromise.then(() => {
@@ -51276,7 +51291,6 @@ var Tileset3D = class {
   }
   calculateViewPropsTiles3D() {
     const root = this.root;
-    assert2(root);
     const { center } = root.boundingVolume;
     if (!center) {
       console.warn("center was not pre-calculated for the root tile");
@@ -51319,6 +51333,13 @@ var Tileset3D = class {
         const children = tile.header.children || [];
         for (const childHeader of children) {
           const childTile = new Tile3D(this, childHeader, tile);
+          if (childTile.contentUrl?.includes("?session=")) {
+            const url = new URL(childTile.contentUrl);
+            const session = url.searchParams.get("session");
+            if (session) {
+              this._queryParams.session = session;
+            }
+          }
           tile.children.push(childTile);
           childTile.depth = tile.depth + 1;
           stack2.push(childTile);
@@ -51354,7 +51375,7 @@ var Tileset3D = class {
       this._onStartTileLoading();
       loaded = await tile.loadContent();
     } catch (error) {
-      this._onTileLoadError(tile, error);
+      this._onTileLoadError(tile, error instanceof Error ? error : new Error("load failed"));
     } finally {
       this._onEndTileLoading();
       this._onTileLoad(tile, loaded);
@@ -51424,11 +51445,11 @@ var Tileset3D = class {
   _updateCacheStats(tile) {
     this.stats.get(TILES_LOADED).incrementCount();
     this.stats.get(TILES_IN_MEMORY).incrementCount();
-    this.gpuMemoryUsageInBytes += tile.content.byteLength || 0;
+    this.gpuMemoryUsageInBytes += tile.gpuMemoryUsageInBytes || 0;
     this.stats.get(TILES_GPU_MEMORY).count = this.gpuMemoryUsageInBytes;
   }
   _unloadTile(tile) {
-    this.gpuMemoryUsageInBytes -= tile.content && tile.content.byteLength || 0;
+    this.gpuMemoryUsageInBytes -= tile.gpuMemoryUsageInBytes || 0;
     this.stats.get(TILES_IN_MEMORY).decrementCount();
     this.stats.get(TILES_UNLOADED).incrementCount();
     this.stats.get(TILES_GPU_MEMORY).count = this.gpuMemoryUsageInBytes;
@@ -51470,6 +51491,11 @@ var Tileset3D = class {
     tile.destroy();
   }
   _initializeTiles3DTileset(tilesetJson) {
+    if (tilesetJson.queryString) {
+      const searchParams = new URLSearchParams(tilesetJson.queryString);
+      const queryParams = Object.fromEntries(searchParams.entries());
+      this._queryParams = { ...this._queryParams, ...queryParams };
+    }
     this.asset = tilesetJson.asset;
     if (!this.asset) {
       throw new Error("Tileset must have an asset property.");
@@ -51486,7 +51512,7 @@ var Tileset3D = class {
     this.description = this.options.description || "";
     this.properties = tilesetJson.properties;
     this.geometricError = tilesetJson.geometricError;
-    this._extensionsUsed = tilesetJson.extensionsUsed;
+    this._extensionsUsed = tilesetJson.extensionsUsed || [];
     this.extras = tilesetJson.extras;
   }
   _initializeI3STileset() {
@@ -51495,20 +51521,6 @@ var Tileset3D = class {
     }
   }
 };
-function getQueryParamString(queryParams) {
-  const queryParamStrings = [];
-  for (const key of Object.keys(queryParams)) {
-    queryParamStrings.push(`${key}=${queryParams[key]}`);
-  }
-  switch (queryParamStrings.length) {
-    case 0:
-      return "";
-    case 1:
-      return `?${queryParamStrings[0]}`;
-    default:
-      return `?${queryParamStrings.join("&")}`;
-  }
-}
 
 // ../3d-tiles/src/lib/utils/version.ts
 var VERSION6 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
@@ -52875,7 +52887,7 @@ function createTypedArrayFromAccessor(tile3DAccessor, buffer, byteOffset, length
 }
 
 // ../3d-tiles/src/lib/classes/tile-3d-batch-table-hierarchy.ts
-var defined4 = (x) => x !== void 0;
+var defined3 = (x) => x !== void 0;
 function initializeHierarchy(batchTable, jsonHeader, binaryBody) {
   if (!jsonHeader) {
     return null;
@@ -52903,15 +52915,15 @@ function initializeHierarchyValues(hierarchyJson, binaryBody) {
   let parentCounts = hierarchyJson.parentCounts;
   let parentIds = hierarchyJson.parentIds;
   let parentIdsLength = instancesLength;
-  if (defined4(classIds.byteOffset)) {
+  if (defined3(classIds.byteOffset)) {
     classIds.componentType = defaultValue(classIds.componentType, GL.UNSIGNED_SHORT);
     classIds.type = AttributeType.SCALAR;
     binaryAccessor = getBinaryAccessor(classIds);
     classIds = binaryAccessor.createArrayBufferView(binaryBody.buffer, binaryBody.byteOffset + classIds.byteOffset, instancesLength);
   }
   let parentIndexes;
-  if (defined4(parentCounts)) {
-    if (defined4(parentCounts.byteOffset)) {
+  if (defined3(parentCounts)) {
+    if (defined3(parentCounts.byteOffset)) {
       parentCounts.componentType = defaultValue(parentCounts.componentType, GL.UNSIGNED_SHORT);
       parentCounts.type = AttributeType.SCALAR;
       binaryAccessor = getBinaryAccessor(parentCounts);
@@ -52924,7 +52936,7 @@ function initializeHierarchyValues(hierarchyJson, binaryBody) {
       parentIdsLength += parentCounts[i];
     }
   }
-  if (defined4(parentIds) && defined4(parentIds.byteOffset)) {
+  if (defined3(parentIds) && defined3(parentIds.byteOffset)) {
     parentIds.componentType = defaultValue(parentIds.componentType, GL.UNSIGNED_SHORT);
     parentIds.type = AttributeType.SCALAR;
     binaryAccessor = getBinaryAccessor(parentIds);
@@ -52988,7 +53000,7 @@ function traverseHierarchyMultipleParents(hierarchy, instanceIndex, endCondition
     }
     visited[instanceIndex] = visitedMarker;
     const result = endConditionCallback(hierarchy, instanceIndex);
-    if (defined4(result)) {
+    if (defined3(result)) {
       return result;
     }
     const parentCount = parentCounts[instanceIndex];
@@ -53006,7 +53018,7 @@ function traverseHierarchySingleParent(hierarchy, instanceIndex, endConditionCal
   let hasParent = true;
   while (hasParent) {
     const result = endConditionCallback(hierarchy, instanceIndex);
-    if (defined4(result)) {
+    if (defined3(result)) {
       return result;
     }
     const parentId = hierarchy.parentIds[instanceIndex];
@@ -53029,14 +53041,14 @@ function validateInstance(hierarchy, instanceIndex, stack2) {
   const parentIndexes = hierarchy.parentIndexes;
   const classIds = hierarchy.classIds;
   const instancesLength = classIds.length;
-  if (!defined4(parentIds)) {
+  if (!defined3(parentIds)) {
     return;
   }
   assert(instanceIndex < instancesLength, `Parent index ${instanceIndex} exceeds the total number of instances: ${instancesLength}`);
   assert(stack2.indexOf(instanceIndex) === -1, "Circular dependency detected in the batch table hierarchy.");
   stack2.push(instanceIndex);
-  const parentCount = defined4(parentCounts) ? parentCounts[instanceIndex] : 1;
-  const parentIndex = defined4(parentCounts) ? parentIndexes[instanceIndex] : instanceIndex;
+  const parentCount = defined3(parentCounts) ? parentCounts[instanceIndex] : 1;
+  const parentIndex = defined3(parentCounts) ? parentIndexes[instanceIndex] : instanceIndex;
   for (let i = 0; i < parentCount; ++i) {
     const parentId = parentIds[parentIndex + i];
     if (parentId !== instanceIndex) {
@@ -53047,7 +53059,7 @@ function validateInstance(hierarchy, instanceIndex, stack2) {
 }
 
 // ../3d-tiles/src/lib/classes/tile-3d-batch-table.ts
-function defined5(x) {
+function defined4(x) {
   return x !== void 0 && x !== null;
 }
 var clone = (x, y) => x;
@@ -53089,7 +53101,7 @@ var Tile3DBatchTableParser = class {
         const instanceClass = hierarchy.classes[classId];
         return instanceClass.name === className;
       });
-      return defined5(result);
+      return defined4(result);
     }
     return false;
   }
@@ -53109,11 +53121,11 @@ var Tile3DBatchTableParser = class {
   hasProperty(batchId, name10) {
     this._checkBatchId(batchId);
     assert2(typeof name10 === "string", name10);
-    return defined5(this._properties[name10]) || this._hasPropertyInHierarchy(batchId, name10);
+    return defined4(this._properties[name10]) || this._hasPropertyInHierarchy(batchId, name10);
   }
   getPropertyNames(batchId, results) {
     this._checkBatchId(batchId);
-    results = defined5(results) ? results : [];
+    results = defined4(results) ? results : [];
     results.length = 0;
     const propertyNames = Object.keys(this._properties);
     results.push(...propertyNames);
@@ -53127,17 +53139,17 @@ var Tile3DBatchTableParser = class {
     assert2(typeof name10 === "string", name10);
     if (this._binaryProperties) {
       const binaryProperty = this._binaryProperties[name10];
-      if (defined5(binaryProperty)) {
+      if (defined4(binaryProperty)) {
         return this._getBinaryProperty(binaryProperty, batchId);
       }
     }
     const propertyValues = this._properties[name10];
-    if (defined5(propertyValues)) {
+    if (defined4(propertyValues)) {
       return clone(propertyValues[batchId], true);
     }
     if (this._hierarchy) {
       const hierarchyProperty = this._getHierarchyProperty(batchId, name10);
-      if (defined5(hierarchyProperty)) {
+      if (defined4(hierarchyProperty)) {
         return hierarchyProperty;
       }
     }
@@ -53160,7 +53172,7 @@ var Tile3DBatchTableParser = class {
       }
     }
     let propertyValues = this._properties[name10];
-    if (!defined5(propertyValues)) {
+    if (!defined4(propertyValues)) {
       this._properties[name10] = new Array(featureCount);
       propertyValues = this._properties[name10];
     }
@@ -53212,9 +53224,9 @@ var Tile3DBatchTableParser = class {
     const result = traverseHierarchy(this._hierarchy, batchId, (hierarchy, instanceIndex) => {
       const classId = hierarchy.classIds[instanceIndex];
       const instances = hierarchy.classes[classId].instances;
-      return defined5(instances[name10]);
+      return defined4(instances[name10]);
     });
-    return defined5(result);
+    return defined4(result);
   }
   _getPropertyNamesInHierarchy(batchId, results) {
     traverseHierarchy(this._hierarchy, batchId, (hierarchy, instanceIndex) => {
@@ -53235,8 +53247,8 @@ var Tile3DBatchTableParser = class {
       const instanceClass = hierarchy.classes[classId];
       const indexInClass = hierarchy.classIndexes[instanceIndex];
       const propertyValues = instanceClass.instances[name10];
-      if (defined5(propertyValues)) {
-        if (defined5(propertyValues.typedArray)) {
+      if (defined4(propertyValues)) {
+        if (defined4(propertyValues.typedArray)) {
           return this._getBinaryProperty(propertyValues, indexInClass);
         }
         return clone(propertyValues[indexInClass], true);
@@ -53250,9 +53262,9 @@ var Tile3DBatchTableParser = class {
       const instanceClass = hierarchy.classes[classId];
       const indexInClass = hierarchy.classIndexes[instanceIndex];
       const propertyValues = instanceClass.instances[name10];
-      if (defined5(propertyValues)) {
+      if (defined4(propertyValues)) {
         assert2(instanceIndex === batchId, `Inherited property "${name10}" is read-only.`);
-        if (defined5(propertyValues.typedArray)) {
+        if (defined4(propertyValues.typedArray)) {
           this._setBinaryProperty(propertyValues, indexInClass, value);
         } else {
           propertyValues[indexInClass] = clone(value, true);
@@ -53261,7 +53273,7 @@ var Tile3DBatchTableParser = class {
       }
       return false;
     });
-    return defined5(result);
+    return defined4(result);
   }
 };
 
@@ -55114,6 +55126,19 @@ function getAccessorArrayTypeAndLength(accessor, bufferView) {
   assert7(byteLength >= 0 && byteLength <= bufferView.byteLength);
   return { ArrayType, length, byteLength };
 }
+function getMemoryUsageGLTF(gltf) {
+  let { images, bufferViews } = gltf;
+  images = images || [];
+  bufferViews = bufferViews || [];
+  const imageBufferViews = images.map((i) => i.bufferView);
+  bufferViews = bufferViews.filter((view) => !imageBufferViews.includes(view));
+  const bufferMemory = bufferViews.reduce((acc, view) => acc + view.byteLength, 0);
+  const pixelCount = images.reduce((acc, image) => {
+    const { width, height } = image.image;
+    return acc + width * height;
+  }, 0);
+  return bufferMemory + Math.ceil(4 * pixelCount * 1.33);
+}
 
 // ../gltf/src/lib/api/gltf-scenegraph.ts
 var DEFAULT_GLTF_JSON = {
@@ -57199,6 +57224,7 @@ async function extractGLTF(tile, gltfFormat, options, context) {
     }
     if (tile.gltfArrayBuffer) {
       tile.gltf = await parse9(tile.gltfArrayBuffer, GLTFLoader, options, context);
+      tile.gpuMemoryUsageInBytes = getMemoryUsageGLTF(tile.gltf);
       delete tile.gltfArrayBuffer;
       delete tile.gltfByteOffset;
       delete tile.gltfByteLength;
@@ -57406,6 +57432,7 @@ async function parseGltf3DTile(tile, arrayBuffer, options, context) {
   tile.gltfUpAxis = options["3d-tiles"] && options["3d-tiles"].assetGltfUpAxis ? options["3d-tiles"].assetGltfUpAxis : "Y";
   const { parse: parse9 } = context;
   tile.gltf = await parse9(arrayBuffer, GLTFLoader, options, context);
+  tile.gpuMemoryUsageInBytes = getMemoryUsageGLTF(tile.gltf);
 }
 
 // ../3d-tiles/src/lib/parsers/parse-3d-tile.ts
@@ -58887,7 +58914,7 @@ function getTileType(tile) {
   if (!tile.contentUrl) {
     return TILE_TYPE.EMPTY;
   }
-  const contentUrl = tile.contentUrl;
+  const contentUrl = tile.contentUrl.split("?")[0];
   const fileExtension = contentUrl.split(".").pop();
   switch (fileExtension) {
     case "pnts":
@@ -59064,6 +59091,7 @@ async function parseTileset(data, options, context) {
   const tilesetJson = JSON.parse(new TextDecoder().decode(data));
   tilesetJson.loader = options.loader || Tiles3DLoader;
   tilesetJson.url = context.url;
+  tilesetJson.queryString = context.queryString;
   tilesetJson.basePath = getBaseUri(tilesetJson);
   tilesetJson.root = await normalizeTileHeaders(tilesetJson, options);
   tilesetJson.type = TILESET_TYPE.TILES3D;