@loaders.gl/tile-converter 4.0.0-alpha.6 → 4.0.0-alpha.7

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();
@@ -46874,7 +46874,7 @@ var WorkerPool = class {
     }
   }
   returnWorkerToQueue(worker) {
-    const shouldDestroyWorker = this.isDestroyed || !this.reuseWorkers || this.count > this._getMaxConcurrency();
+    const shouldDestroyWorker = !isBrowser2 || this.isDestroyed || !this.reuseWorkers || this.count > this._getMaxConcurrency();
     if (shouldDestroyWorker) {
       worker.destroy();
       this.count--;
@@ -46969,7 +46969,7 @@ function getWorkerName(worker) {
 }
 function getWorkerURL(worker, options = {}) {
   const workerOptions = options[worker.id] || {};
-  const workerFile = `${worker.id}-worker.js`;
+  const workerFile = isBrowser2 ? `${worker.id}-worker.js` : `${worker.id}-worker-node.js`;
   let url = workerOptions.workerUrl;
   if (!url && worker.id === "compression") {
     url = options.workerUrl;
@@ -47485,7 +47485,7 @@ function _defineProperty(obj, key, value) {
   return obj;
 }
 
-// ../../node_modules/@probe.gl/stats/dist/utils/hi-res-timestamp.js
+// ../loader-utils/node_modules/@probe.gl/stats/dist/utils/hi-res-timestamp.js
 function getHiResTimestamp() {
   let timestamp;
   if (typeof window !== "undefined" && window.performance) {
@@ -47499,7 +47499,7 @@ function getHiResTimestamp() {
   return timestamp;
 }
 
-// ../../node_modules/@probe.gl/stats/dist/lib/stat.js
+// ../loader-utils/node_modules/@probe.gl/stats/dist/lib/stat.js
 var Stat = class {
   constructor(name10, type) {
     _defineProperty(this, "name", void 0);
@@ -47611,7 +47611,7 @@ var Stat = class {
   }
 };
 
-// ../../node_modules/@probe.gl/stats/dist/lib/stats.js
+// ../loader-utils/node_modules/@probe.gl/stats/dist/lib/stats.js
 var Stats = class {
   constructor(options) {
     _defineProperty(this, "id", void 0);
@@ -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;
   }
@@ -48244,7 +48257,7 @@ async function writeFile2(filePath, arrayBufferOrString, options) {
   assert2(false);
 }
 
-// ../../node_modules/@probe.gl/env/dist/lib/is-electron.js
+// ../../node_modules/@probe.gl/log/node_modules/@probe.gl/env/dist/lib/is-electron.js
 function isElectron(mockUserAgent) {
   if (typeof window !== "undefined" && typeof window.process === "object" && window.process.type === "renderer") {
     return true;
@@ -48260,13 +48273,13 @@ function isElectron(mockUserAgent) {
   return false;
 }
 
-// ../../node_modules/@probe.gl/env/dist/lib/is-browser.js
+// ../../node_modules/@probe.gl/log/node_modules/@probe.gl/env/dist/lib/is-browser.js
 function isBrowser3() {
   const isNode = typeof process === "object" && String(process) === "[object process]" && !process.browser;
   return !isNode || isElectron();
 }
 
-// ../../node_modules/@probe.gl/env/dist/lib/globals.js
+// ../../node_modules/@probe.gl/log/node_modules/@probe.gl/env/dist/lib/globals.js
 var self_3 = globalThis.self || globalThis.window || globalThis.global;
 var window_3 = globalThis.window || globalThis.self || globalThis.global;
 var document_3 = globalThis.document || {};
@@ -48274,7 +48287,7 @@ var process_ = globalThis.process || {};
 var console_ = globalThis.console;
 var navigator_ = globalThis.navigator || {};
 
-// ../../node_modules/@probe.gl/env/dist/utils/globals.js
+// ../../node_modules/@probe.gl/log/node_modules/@probe.gl/env/dist/utils/globals.js
 var VERSION5 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "untranspiled source";
 var isBrowser4 = isBrowser3();
 
@@ -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) {
@@ -49491,6 +49513,197 @@ function getTemporaryFilename(filename2) {
 var import_core10 = __toModule(require_es5());
 var import_geospatial6 = __toModule(require_es52());
 
+// ../tiles/node_modules/@probe.gl/stats/dist/utils/hi-res-timestamp.js
+function getHiResTimestamp3() {
+  let timestamp;
+  if (typeof window !== "undefined" && window.performance) {
+    timestamp = window.performance.now();
+  } else if (typeof process !== "undefined" && process.hrtime) {
+    const timeParts = process.hrtime();
+    timestamp = timeParts[0] * 1e3 + timeParts[1] / 1e6;
+  } else {
+    timestamp = Date.now();
+  }
+  return timestamp;
+}
+
+// ../tiles/node_modules/@probe.gl/stats/dist/lib/stat.js
+var Stat2 = class {
+  constructor(name10, type) {
+    _defineProperty(this, "name", void 0);
+    _defineProperty(this, "type", void 0);
+    _defineProperty(this, "sampleSize", 1);
+    _defineProperty(this, "time", 0);
+    _defineProperty(this, "count", 0);
+    _defineProperty(this, "samples", 0);
+    _defineProperty(this, "lastTiming", 0);
+    _defineProperty(this, "lastSampleTime", 0);
+    _defineProperty(this, "lastSampleCount", 0);
+    _defineProperty(this, "_count", 0);
+    _defineProperty(this, "_time", 0);
+    _defineProperty(this, "_samples", 0);
+    _defineProperty(this, "_startTime", 0);
+    _defineProperty(this, "_timerPending", false);
+    this.name = name10;
+    this.type = type;
+    this.reset();
+  }
+  reset() {
+    this.time = 0;
+    this.count = 0;
+    this.samples = 0;
+    this.lastTiming = 0;
+    this.lastSampleTime = 0;
+    this.lastSampleCount = 0;
+    this._count = 0;
+    this._time = 0;
+    this._samples = 0;
+    this._startTime = 0;
+    this._timerPending = false;
+    return this;
+  }
+  setSampleSize(samples) {
+    this.sampleSize = samples;
+    return this;
+  }
+  incrementCount() {
+    this.addCount(1);
+    return this;
+  }
+  decrementCount() {
+    this.subtractCount(1);
+    return this;
+  }
+  addCount(value) {
+    this._count += value;
+    this._samples++;
+    this._checkSampling();
+    return this;
+  }
+  subtractCount(value) {
+    this._count -= value;
+    this._samples++;
+    this._checkSampling();
+    return this;
+  }
+  addTime(time) {
+    this._time += time;
+    this.lastTiming = time;
+    this._samples++;
+    this._checkSampling();
+    return this;
+  }
+  timeStart() {
+    this._startTime = getHiResTimestamp3();
+    this._timerPending = true;
+    return this;
+  }
+  timeEnd() {
+    if (!this._timerPending) {
+      return this;
+    }
+    this.addTime(getHiResTimestamp3() - this._startTime);
+    this._timerPending = false;
+    this._checkSampling();
+    return this;
+  }
+  getSampleAverageCount() {
+    return this.sampleSize > 0 ? this.lastSampleCount / this.sampleSize : 0;
+  }
+  getSampleAverageTime() {
+    return this.sampleSize > 0 ? this.lastSampleTime / this.sampleSize : 0;
+  }
+  getSampleHz() {
+    return this.lastSampleTime > 0 ? this.sampleSize / (this.lastSampleTime / 1e3) : 0;
+  }
+  getAverageCount() {
+    return this.samples > 0 ? this.count / this.samples : 0;
+  }
+  getAverageTime() {
+    return this.samples > 0 ? this.time / this.samples : 0;
+  }
+  getHz() {
+    return this.time > 0 ? this.samples / (this.time / 1e3) : 0;
+  }
+  _checkSampling() {
+    if (this._samples === this.sampleSize) {
+      this.lastSampleTime = this._time;
+      this.lastSampleCount = this._count;
+      this.count += this._count;
+      this.time += this._time;
+      this.samples += this._samples;
+      this._time = 0;
+      this._count = 0;
+      this._samples = 0;
+    }
+  }
+};
+
+// ../tiles/node_modules/@probe.gl/stats/dist/lib/stats.js
+var Stats2 = class {
+  constructor(options) {
+    _defineProperty(this, "id", void 0);
+    _defineProperty(this, "stats", {});
+    this.id = options.id;
+    this.stats = {};
+    this._initializeStats(options.stats);
+    Object.seal(this);
+  }
+  get(name10) {
+    let type = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "count";
+    return this._getOrCreate({
+      name: name10,
+      type
+    });
+  }
+  get size() {
+    return Object.keys(this.stats).length;
+  }
+  reset() {
+    for (const stat2 of Object.values(this.stats)) {
+      stat2.reset();
+    }
+    return this;
+  }
+  forEach(fn) {
+    for (const stat2 of Object.values(this.stats)) {
+      fn(stat2);
+    }
+  }
+  getTable() {
+    const table = {};
+    this.forEach((stat2) => {
+      table[stat2.name] = {
+        time: stat2.time || 0,
+        count: stat2.count || 0,
+        average: stat2.getAverageTime() || 0,
+        hz: stat2.getHz() || 0
+      };
+    });
+    return table;
+  }
+  _initializeStats() {
+    let stats = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : [];
+    stats.forEach((stat2) => this._getOrCreate(stat2));
+  }
+  _getOrCreate(stat2) {
+    const {
+      name: name10,
+      type
+    } = stat2;
+    let result = this.stats[name10];
+    if (!result) {
+      if (stat2 instanceof Stat2) {
+        result = stat2;
+      } else {
+        result = new Stat2(name10, type);
+      }
+      this.stats[name10] = result;
+    }
+    return result;
+  }
+};
+
 // ../tiles/src/utils/doubly-linked-list-node.ts
 var DoublyLinkedListNode = class {
   constructor(item, previous, next) {
@@ -49565,9 +49778,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();
@@ -49579,12 +49789,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);
@@ -49593,11 +49803,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);
     }
@@ -49848,7 +50058,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();
@@ -49924,7 +50134,7 @@ function createBox(box, transform11, result) {
     zAxis[1],
     zAxis[2]
   ]);
-  if (defined2(result)) {
+  if (defined(result)) {
     result.center = center;
     result.halfAxes = halfAxes;
     return result;
@@ -49937,7 +50147,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;
@@ -50201,16 +50411,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;
@@ -50273,7 +50483,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;
@@ -50352,7 +50561,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);
@@ -50414,19 +50623,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;
@@ -50434,40 +50635,47 @@ 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._lodJudge = null;
+    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() {
@@ -50534,6 +50742,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;
@@ -50650,7 +50861,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;
@@ -50733,6 +50944,8 @@ var Tile3D = class {
     }
     if (this._isTileset()) {
       this.hasTilesetContent = true;
+    } else {
+      this.gpuMemoryUsageInBytes = this._getGpuMemoryUsageInBytes();
     }
   }
   _updateBoundingVolume(header) {
@@ -51010,57 +51223,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.stats = new Stats2({ 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();
@@ -51075,10 +51287,7 @@ var Tileset3D = class {
     return this._frameNumber;
   }
   get queryParams() {
-    if (!this._queryParamsString) {
-      this._queryParamsString = getQueryParamString(this._queryParams);
-    }
-    return this._queryParamsString;
+    return new URLSearchParams(this._queryParams).toString();
   }
   setProps(props) {
     this.options = { ...this.options, ...props };
@@ -51091,10 +51300,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(() => {
@@ -51281,7 +51490,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");
@@ -51324,6 +51532,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);
@@ -51359,7 +51574,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);
@@ -51429,11 +51644,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;
@@ -51475,11 +51690,16 @@ 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.");
     }
-    if (this.asset.version !== "0.0" && this.asset.version !== "1.0") {
+    if (this.asset.version !== "0.0" && this.asset.version !== "1.0" && this.asset.version !== "1.1") {
       throw new Error("The tileset must be 3D Tiles version 0.0 or 1.0.");
     }
     if ("tilesetVersion" in this.asset) {
@@ -51491,7 +51711,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() {
@@ -51500,20 +51720,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";
@@ -51557,7 +51763,7 @@ var DEFAULT_DRACO_OPTIONS = {
 };
 var DracoLoader = {
   name: "Draco",
-  id: isBrowser2 ? "draco" : "draco-nodejs",
+  id: "draco",
   module: "draco",
   version: VERSION7,
   worker: true,
@@ -52075,7 +52281,7 @@ function initializeDracoDecoder(DracoDecoderModule, wasmBinary) {
 
 // ../draco/src/index.ts
 var DracoWriterWorker = {
-  id: isBrowser2 ? "draco-writer" : "draco-writer-nodejs",
+  id: "draco-writer",
   name: "Draco compressed geometry writer",
   module: "draco",
   version: VERSION7,
@@ -52439,7 +52645,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;
@@ -52467,15 +52673,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);
@@ -52488,7 +52694,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);
@@ -52552,7 +52758,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];
@@ -52570,7 +52776,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];
@@ -52593,14 +52799,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) {
@@ -52611,7 +52817,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;
@@ -52653,7 +52859,7 @@ var Tile3DBatchTableParser = class {
         const instanceClass = hierarchy.classes[classId];
         return instanceClass.name === className;
       });
-      return defined5(result);
+      return defined4(result);
     }
     return false;
   }
@@ -52673,11 +52879,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);
@@ -52691,17 +52897,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;
       }
     }
@@ -52724,7 +52930,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];
     }
@@ -52776,9 +52982,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) => {
@@ -52799,8 +53005,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);
@@ -52814,9 +53020,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);
@@ -52825,7 +53031,7 @@ var Tile3DBatchTableParser = class {
       }
       return false;
     });
-    return defined5(result);
+    return defined4(result);
   }
 };
 
@@ -53215,326 +53421,825 @@ async function loadDraco(tile, dracoData, options, context) {
 // ../gltf/src/lib/utils/version.ts
 var VERSION8 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
 
-// ../textures/src/lib/utils/version.ts
-var VERSION9 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "beta";
+// ../images/src/lib/utils/version.ts
+var VERSION9 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
 
-// ../textures/src/lib/parsers/basis-module-loader.ts
-var VERSION10 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "beta";
-var BASIS_CDN_ENCODER_WASM = `https://unpkg.com/@loaders.gl/textures@${VERSION10}/dist/libs/basis_encoder.wasm`;
-var BASIS_CDN_ENCODER_JS = `https://unpkg.com/@loaders.gl/textures@${VERSION10}/dist/libs/basis_encoder.js`;
-var loadBasisTranscoderPromise;
-async function loadBasisTrascoderModule(options) {
-  const modules = options.modules || {};
-  if (modules.basis) {
-    return modules.basis;
+// ../images/src/lib/category-api/image-type.ts
+var { _parseImageNode } = globalThis;
+var IMAGE_SUPPORTED = typeof Image !== "undefined";
+var IMAGE_BITMAP_SUPPORTED = typeof ImageBitmap !== "undefined";
+var NODE_IMAGE_SUPPORTED = Boolean(_parseImageNode);
+var DATA_SUPPORTED = isBrowser ? true : NODE_IMAGE_SUPPORTED;
+function isImageTypeSupported(type) {
+  switch (type) {
+    case "auto":
+      return IMAGE_BITMAP_SUPPORTED || IMAGE_SUPPORTED || DATA_SUPPORTED;
+    case "imagebitmap":
+      return IMAGE_BITMAP_SUPPORTED;
+    case "image":
+      return IMAGE_SUPPORTED;
+    case "data":
+      return DATA_SUPPORTED;
+    default:
+      throw new Error(`@loaders.gl/images: image ${type} not supported in this environment`);
   }
-  loadBasisTranscoderPromise = loadBasisTranscoderPromise || loadBasisTrascoder(options);
-  return await loadBasisTranscoderPromise;
-}
-async function loadBasisTrascoder(options) {
-  let BASIS = null;
-  let wasmBinary = null;
-  [BASIS, wasmBinary] = await Promise.all([
-    await loadLibrary("basis_transcoder.js", "textures", options),
-    await loadLibrary("basis_transcoder.wasm", "textures", options)
-  ]);
-  BASIS = BASIS || globalThis.BASIS;
-  return await initializeBasisTrascoderModule(BASIS, wasmBinary);
 }
-function initializeBasisTrascoderModule(BasisModule, wasmBinary) {
-  const options = {};
-  if (wasmBinary) {
-    options.wasmBinary = wasmBinary;
+function getDefaultImageType() {
+  if (IMAGE_BITMAP_SUPPORTED) {
+    return "imagebitmap";
   }
-  return new Promise((resolve2) => {
-    BasisModule(options).then((module2) => {
-      const { BasisFile, initializeBasis } = module2;
-      initializeBasis();
-      resolve2({ BasisFile });
-    });
-  });
+  if (IMAGE_SUPPORTED) {
+    return "image";
+  }
+  if (DATA_SUPPORTED) {
+    return "data";
+  }
+  throw new Error("Install '@loaders.gl/polyfills' to parse images under Node.js");
 }
-var loadBasisEncoderPromise;
-async function loadBasisEncoderModule(options) {
-  const modules = options.modules || {};
-  if (modules.basisEncoder) {
-    return modules.basisEncoder;
+
+// ../images/src/lib/category-api/parsed-image-api.ts
+function getImageType(image) {
+  const format = getImageTypeOrNull(image);
+  if (!format) {
+    throw new Error("Not an image");
   }
-  loadBasisEncoderPromise = loadBasisEncoderPromise || loadBasisEncoder(options);
-  return await loadBasisEncoderPromise;
+  return format;
 }
-async function loadBasisEncoder(options) {
-  let BASIS_ENCODER = null;
-  let wasmBinary = null;
-  [BASIS_ENCODER, wasmBinary] = await Promise.all([
-    await loadLibrary(BASIS_CDN_ENCODER_JS, "textures", options),
-    await loadLibrary(BASIS_CDN_ENCODER_WASM, "textures", options)
-  ]);
-  BASIS_ENCODER = BASIS_ENCODER || globalThis.BASIS;
-  return await initializeBasisEncoderModule(BASIS_ENCODER, wasmBinary);
+function getImageSize(image) {
+  return getImageData(image);
 }
-function initializeBasisEncoderModule(BasisEncoderModule, wasmBinary) {
-  const options = {};
-  if (wasmBinary) {
-    options.wasmBinary = wasmBinary;
+function getImageData(image) {
+  switch (getImageType(image)) {
+    case "data":
+      return image;
+    case "image":
+    case "imagebitmap":
+      const canvas = document.createElement("canvas");
+      const context = canvas.getContext("2d");
+      if (!context) {
+        throw new Error("getImageData");
+      }
+      canvas.width = image.width;
+      canvas.height = image.height;
+      context.drawImage(image, 0, 0);
+      return context.getImageData(0, 0, image.width, image.height);
+    default:
+      throw new Error("getImageData");
   }
-  return new Promise((resolve2) => {
-    BasisEncoderModule(options).then((module2) => {
-      const { BasisFile, KTX2File, initializeBasis, BasisEncoder } = module2;
-      initializeBasis();
-      resolve2({ BasisFile, KTX2File, BasisEncoder });
-    });
-  });
+}
+function getImageTypeOrNull(image) {
+  if (typeof ImageBitmap !== "undefined" && image instanceof ImageBitmap) {
+    return "imagebitmap";
+  }
+  if (typeof Image !== "undefined" && image instanceof Image) {
+    return "image";
+  }
+  if (image && typeof image === "object" && image.data && image.width && image.height) {
+    return "data";
+  }
+  return null;
 }
 
-// ../textures/src/lib/gl-extensions.ts
-var GL_EXTENSIONS_CONSTANTS = {
-  COMPRESSED_RGB_S3TC_DXT1_EXT: 33776,
-  COMPRESSED_RGBA_S3TC_DXT1_EXT: 33777,
-  COMPRESSED_RGBA_S3TC_DXT3_EXT: 33778,
-  COMPRESSED_RGBA_S3TC_DXT5_EXT: 33779,
-  COMPRESSED_R11_EAC: 37488,
-  COMPRESSED_SIGNED_R11_EAC: 37489,
-  COMPRESSED_RG11_EAC: 37490,
-  COMPRESSED_SIGNED_RG11_EAC: 37491,
-  COMPRESSED_RGB8_ETC2: 37492,
-  COMPRESSED_RGBA8_ETC2_EAC: 37493,
-  COMPRESSED_SRGB8_ETC2: 37494,
-  COMPRESSED_SRGB8_ALPHA8_ETC2_EAC: 37495,
-  COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2: 37496,
-  COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2: 37497,
-  COMPRESSED_RGB_PVRTC_4BPPV1_IMG: 35840,
-  COMPRESSED_RGBA_PVRTC_4BPPV1_IMG: 35842,
-  COMPRESSED_RGB_PVRTC_2BPPV1_IMG: 35841,
-  COMPRESSED_RGBA_PVRTC_2BPPV1_IMG: 35843,
-  COMPRESSED_RGB_ETC1_WEBGL: 36196,
-  COMPRESSED_RGB_ATC_WEBGL: 35986,
-  COMPRESSED_RGBA_ATC_EXPLICIT_ALPHA_WEBGL: 35987,
-  COMPRESSED_RGBA_ATC_INTERPOLATED_ALPHA_WEBGL: 34798,
-  COMPRESSED_RGBA_ASTC_4X4_KHR: 37808,
-  COMPRESSED_RGBA_ASTC_5X4_KHR: 37809,
-  COMPRESSED_RGBA_ASTC_5X5_KHR: 37810,
-  COMPRESSED_RGBA_ASTC_6X5_KHR: 37811,
-  COMPRESSED_RGBA_ASTC_6X6_KHR: 37812,
-  COMPRESSED_RGBA_ASTC_8X5_KHR: 37813,
-  COMPRESSED_RGBA_ASTC_8X6_KHR: 37814,
-  COMPRESSED_RGBA_ASTC_8X8_KHR: 37815,
-  COMPRESSED_RGBA_ASTC_10X5_KHR: 37816,
-  COMPRESSED_RGBA_ASTC_10X6_KHR: 37817,
-  COMPRESSED_RGBA_ASTC_10X8_KHR: 37818,
-  COMPRESSED_RGBA_ASTC_10X10_KHR: 37819,
-  COMPRESSED_RGBA_ASTC_12X10_KHR: 37820,
-  COMPRESSED_RGBA_ASTC_12X12_KHR: 37821,
-  COMPRESSED_SRGB8_ALPHA8_ASTC_4X4_KHR: 37840,
-  COMPRESSED_SRGB8_ALPHA8_ASTC_5X4_KHR: 37841,
-  COMPRESSED_SRGB8_ALPHA8_ASTC_5X5_KHR: 37842,
-  COMPRESSED_SRGB8_ALPHA8_ASTC_6X5_KHR: 37843,
-  COMPRESSED_SRGB8_ALPHA8_ASTC_6X6_KHR: 37844,
-  COMPRESSED_SRGB8_ALPHA8_ASTC_8X5_KHR: 37845,
-  COMPRESSED_SRGB8_ALPHA8_ASTC_8X6_KHR: 37846,
-  COMPRESSED_SRGB8_ALPHA8_ASTC_8X8_KHR: 37847,
-  COMPRESSED_SRGB8_ALPHA8_ASTC_10X5_KHR: 37848,
-  COMPRESSED_SRGB8_ALPHA8_ASTC_10X6_KHR: 37849,
-  COMPRESSED_SRGB8_ALPHA8_ASTC_10X8_KHR: 37850,
-  COMPRESSED_SRGB8_ALPHA8_ASTC_10X10_KHR: 37851,
-  COMPRESSED_SRGB8_ALPHA8_ASTC_12X10_KHR: 37852,
-  COMPRESSED_SRGB8_ALPHA8_ASTC_12X12_KHR: 37853,
-  COMPRESSED_RED_RGTC1_EXT: 36283,
-  COMPRESSED_SIGNED_RED_RGTC1_EXT: 36284,
-  COMPRESSED_RED_GREEN_RGTC2_EXT: 36285,
-  COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT: 36286,
-  COMPRESSED_SRGB_S3TC_DXT1_EXT: 35916,
-  COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT: 35917,
-  COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT: 35918,
-  COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT: 35919
-};
-
-// ../textures/src/lib/utils/texture-formats.ts
-var BROWSER_PREFIXES = ["", "WEBKIT_", "MOZ_"];
-var WEBGL_EXTENSIONS = {
-  WEBGL_compressed_texture_s3tc: "dxt",
-  WEBGL_compressed_texture_s3tc_srgb: "dxt-srgb",
-  WEBGL_compressed_texture_etc1: "etc1",
-  WEBGL_compressed_texture_etc: "etc2",
-  WEBGL_compressed_texture_pvrtc: "pvrtc",
-  WEBGL_compressed_texture_atc: "atc",
-  WEBGL_compressed_texture_astc: "astc",
-  EXT_texture_compression_rgtc: "rgtc"
-};
-var formats = null;
-function getSupportedGPUTextureFormats(gl) {
-  if (!formats) {
-    gl = gl || getWebGLContext() || void 0;
-    formats = new Set();
-    for (const prefix of BROWSER_PREFIXES) {
-      for (const extension in WEBGL_EXTENSIONS) {
-        if (gl && gl.getExtension(`${prefix}${extension}`)) {
-          const gpuTextureFormat = WEBGL_EXTENSIONS[extension];
-          formats.add(gpuTextureFormat);
-        }
+// ../images/src/lib/parsers/svg-utils.ts
+var SVG_DATA_URL_PATTERN = /^data:image\/svg\+xml/;
+var SVG_URL_PATTERN = /\.svg((\?|#).*)?$/;
+function isSVG(url) {
+  return url && (SVG_DATA_URL_PATTERN.test(url) || SVG_URL_PATTERN.test(url));
+}
+function getBlobOrSVGDataUrl(arrayBuffer, url) {
+  if (isSVG(url)) {
+    const textDecoder = new TextDecoder();
+    let xmlText = textDecoder.decode(arrayBuffer);
+    try {
+      if (typeof unescape === "function" && typeof encodeURIComponent === "function") {
+        xmlText = unescape(encodeURIComponent(xmlText));
       }
+    } catch (error) {
+      throw new Error(error.message);
     }
+    const src = `data:image/svg+xml;base64,${btoa(xmlText)}`;
+    return src;
   }
-  return formats;
+  return getBlob(arrayBuffer, url);
 }
-function getWebGLContext() {
-  try {
-    const canvas = document.createElement("canvas");
-    return canvas.getContext("webgl");
-  } catch (error) {
-    return null;
+function getBlob(arrayBuffer, url) {
+  if (isSVG(url)) {
+    throw new Error("SVG cannot be parsed directly to imagebitmap");
   }
+  return new Blob([new Uint8Array(arrayBuffer)]);
 }
 
-// ../textures/src/lib/parsers/parse-ktx.ts
-var import_ktx_parse = __toModule(require_ktx_parse());
+// ../images/src/lib/parsers/parse-to-image.ts
+async function parseToImage(arrayBuffer, options, url) {
+  const blobOrDataUrl = getBlobOrSVGDataUrl(arrayBuffer, url);
+  const URL2 = self.URL || self.webkitURL;
+  const objectUrl = typeof blobOrDataUrl !== "string" && URL2.createObjectURL(blobOrDataUrl);
+  try {
+    return await loadToImage(objectUrl || blobOrDataUrl, options);
+  } finally {
+    if (objectUrl) {
+      URL2.revokeObjectURL(objectUrl);
+    }
+  }
+}
+async function loadToImage(url, options) {
+  const image = new Image();
+  image.src = url;
+  if (options.image && options.image.decode && image.decode) {
+    await image.decode();
+    return image;
+  }
+  return await new Promise((resolve2, reject) => {
+    try {
+      image.onload = () => resolve2(image);
+      image.onerror = (err) => reject(new Error(`Could not load image ${url}: ${err}`));
+    } catch (error) {
+      reject(error);
+    }
+  });
+}
 
-// ../textures/src/lib/utils/extract-mipmap-images.ts
-function extractMipmapImages(data, options) {
-  const images = new Array(options.mipMapLevels);
-  let levelWidth = options.width;
-  let levelHeight = options.height;
-  let offset = 0;
-  for (let i = 0; i < options.mipMapLevels; ++i) {
-    const levelSize = getLevelSize(options, levelWidth, levelHeight, data, i);
-    const levelData = getLevelData(data, i, offset, levelSize);
-    images[i] = {
-      compressed: true,
-      format: options.internalFormat,
-      data: levelData,
-      width: levelWidth,
-      height: levelHeight,
-      levelSize
-    };
-    levelWidth = Math.max(1, levelWidth >> 1);
-    levelHeight = Math.max(1, levelHeight >> 1);
-    offset += levelSize;
+// ../images/src/lib/parsers/parse-to-image-bitmap.ts
+var EMPTY_OBJECT = {};
+var imagebitmapOptionsSupported = true;
+async function parseToImageBitmap(arrayBuffer, options, url) {
+  let blob;
+  if (isSVG(url)) {
+    const image = await parseToImage(arrayBuffer, options, url);
+    blob = image;
+  } else {
+    blob = getBlob(arrayBuffer, url);
   }
-  return images;
+  const imagebitmapOptions = options && options.imagebitmap;
+  return await safeCreateImageBitmap(blob, imagebitmapOptions);
 }
-function getLevelData(data, index, offset, levelSize) {
-  if (!Array.isArray(data)) {
-    return new Uint8Array(data.buffer, data.byteOffset + offset, levelSize);
+async function safeCreateImageBitmap(blob, imagebitmapOptions = null) {
+  if (isEmptyObject(imagebitmapOptions) || !imagebitmapOptionsSupported) {
+    imagebitmapOptions = null;
   }
-  return data[index].levelData;
+  if (imagebitmapOptions) {
+    try {
+      return await createImageBitmap(blob, imagebitmapOptions);
+    } catch (error) {
+      console.warn(error);
+      imagebitmapOptionsSupported = false;
+    }
+  }
+  return await createImageBitmap(blob);
 }
-function getLevelSize(options, levelWidth, levelHeight, data, index) {
-  if (!Array.isArray(data)) {
-    return options.sizeFunction(levelWidth, levelHeight);
+function isEmptyObject(object) {
+  for (const key in object || EMPTY_OBJECT) {
+    return false;
   }
-  return options.sizeFunction(data[index]);
+  return true;
 }
 
-// ../textures/src/lib/utils/ktx-format-helper.ts
-var VULKAN_TO_WEBGL_FORMAT_MAP = {
-  131: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGB_S3TC_DXT1_EXT,
-  132: GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB_S3TC_DXT1_EXT,
-  133: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_S3TC_DXT1_EXT,
-  134: GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT,
-  135: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_S3TC_DXT3_EXT,
-  136: GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT,
-  137: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_S3TC_DXT5_EXT,
-  138: GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT,
-  139: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RED_RGTC1_EXT,
-  140: GL_EXTENSIONS_CONSTANTS.COMPRESSED_SIGNED_RED_RGTC1_EXT,
-  141: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RED_GREEN_RGTC2_EXT,
-  142: GL_EXTENSIONS_CONSTANTS.COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT,
-  147: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGB8_ETC2,
-  148: GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ETC2,
-  149: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2,
-  150: GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2,
-  151: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA8_ETC2_EAC,
-  152: GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ETC2_EAC,
-  153: GL_EXTENSIONS_CONSTANTS.COMPRESSED_R11_EAC,
-  154: GL_EXTENSIONS_CONSTANTS.COMPRESSED_SIGNED_R11_EAC,
-  155: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RG11_EAC,
-  156: GL_EXTENSIONS_CONSTANTS.COMPRESSED_SIGNED_RG11_EAC,
-  157: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_4x4_KHR,
-  158: GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR,
-  159: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_5x4_KHR,
-  160: GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_5X4_KHR,
-  161: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_5x5_KHR,
-  162: GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR,
-  163: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_6x5_KHR,
-  164: GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR,
-  165: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_6x6_KHR,
-  166: GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR,
-  167: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_8x5_KHR,
-  168: GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR,
-  169: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_8x6_KHR,
-  170: GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR,
-  171: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_8x8_KHR,
-  172: GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR,
-  173: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_10x5_KHR,
-  174: GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR,
-  175: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_10x6_KHR,
-  176: GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR,
-  177: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_10x8_KHR,
-  178: GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR,
-  179: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_10x10_KHR,
-  180: GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR,
-  181: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_12x10_KHR,
-  182: GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR,
-  183: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_12x12_KHR,
-  184: GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR,
-  1000054e3: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_PVRTC_2BPPV1_IMG,
-  1000054001: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_PVRTC_4BPPV1_IMG,
-  1000066e3: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_4x4_KHR,
-  1000066001: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_5x4_KHR,
-  1000066002: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_5x5_KHR,
-  1000066003: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_6x5_KHR,
-  1000066004: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_6x6_KHR,
-  1000066005: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_8x5_KHR,
-  1000066006: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_8x6_KHR,
-  1000066007: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_8x8_KHR,
-  1000066008: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_10x5_KHR,
-  1000066009: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_10x6_KHR,
-  1000066010: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_10x8_KHR,
-  1000066011: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_10x10_KHR,
-  1000066012: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_12x10_KHR,
-  1000066013: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_12x12_KHR
-};
-function mapVkFormatToWebGL(vkFormat) {
-  return VULKAN_TO_WEBGL_FORMAT_MAP[vkFormat];
+// ../images/src/lib/category-api/parse-isobmff-binary.ts
+function getISOBMFFMediaType(buffer) {
+  if (!checkString(buffer, "ftyp", 4)) {
+    return null;
+  }
+  if ((buffer[8] & 96) === 0) {
+    return null;
+  }
+  return decodeMajorBrand(buffer);
 }
-
-// ../textures/src/lib/parsers/parse-ktx.ts
-var KTX2_ID = [
-  171,
-  75,
-  84,
-  88,
-  32,
-  50,
-  48,
-  187,
-  13,
-  10,
-  26,
-  10
-];
-function isKTX(data) {
-  const id = new Uint8Array(data);
-  const notKTX = id.byteLength < KTX2_ID.length || id[0] !== KTX2_ID[0] || id[1] !== KTX2_ID[1] || id[2] !== KTX2_ID[2] || id[3] !== KTX2_ID[3] || id[4] !== KTX2_ID[4] || id[5] !== KTX2_ID[5] || id[6] !== KTX2_ID[6] || id[7] !== KTX2_ID[7] || id[8] !== KTX2_ID[8] || id[9] !== KTX2_ID[9] || id[10] !== KTX2_ID[10] || id[11] !== KTX2_ID[11];
-  return !notKTX;
+function decodeMajorBrand(buffer) {
+  const brandMajor = getUTF8String(buffer, 8, 12).replace("\0", " ").trim();
+  switch (brandMajor) {
+    case "avif":
+    case "avis":
+      return { extension: "avif", mimeType: "image/avif" };
+    default:
+      return null;
+  }
 }
-function parseKTX(arrayBuffer) {
-  const uint8Array = new Uint8Array(arrayBuffer);
-  const ktx = (0, import_ktx_parse.read)(uint8Array);
-  const mipMapLevels = Math.max(1, ktx.levels.length);
-  const width = ktx.pixelWidth;
-  const height = ktx.pixelHeight;
-  const internalFormat = mapVkFormatToWebGL(ktx.vkFormat);
-  return extractMipmapImages(ktx.levels, {
-    mipMapLevels,
-    width,
-    height,
-    sizeFunction: (level) => level.uncompressedByteLength,
-    internalFormat
-  });
+function getUTF8String(array, start, end) {
+  return String.fromCharCode(...array.slice(start, end));
 }
-
-// ../textures/src/lib/parsers/parse-basis.ts
+function stringToBytes(string) {
+  return [...string].map((character) => character.charCodeAt(0));
+}
+function checkString(buffer, header, offset = 0) {
+  const headerBytes = stringToBytes(header);
+  for (let i = 0; i < headerBytes.length; ++i) {
+    if (headerBytes[i] !== buffer[i + offset]) {
+      return false;
+    }
+  }
+  return true;
+}
+
+// ../images/src/lib/category-api/binary-image-api.ts
+var BIG_ENDIAN = false;
+var LITTLE_ENDIAN = true;
+function getBinaryImageMetadata(binaryData) {
+  const dataView = toDataView(binaryData);
+  return getPngMetadata(dataView) || getJpegMetadata(dataView) || getGifMetadata(dataView) || getBmpMetadata(dataView) || getISOBMFFMetadata(dataView);
+}
+function getISOBMFFMetadata(binaryData) {
+  const buffer = new Uint8Array(binaryData instanceof DataView ? binaryData.buffer : binaryData);
+  const mediaType = getISOBMFFMediaType(buffer);
+  if (!mediaType) {
+    return null;
+  }
+  return {
+    mimeType: mediaType.mimeType,
+    width: 0,
+    height: 0
+  };
+}
+function getPngMetadata(binaryData) {
+  const dataView = toDataView(binaryData);
+  const isPng = dataView.byteLength >= 24 && dataView.getUint32(0, BIG_ENDIAN) === 2303741511;
+  if (!isPng) {
+    return null;
+  }
+  return {
+    mimeType: "image/png",
+    width: dataView.getUint32(16, BIG_ENDIAN),
+    height: dataView.getUint32(20, BIG_ENDIAN)
+  };
+}
+function getGifMetadata(binaryData) {
+  const dataView = toDataView(binaryData);
+  const isGif = dataView.byteLength >= 10 && dataView.getUint32(0, BIG_ENDIAN) === 1195984440;
+  if (!isGif) {
+    return null;
+  }
+  return {
+    mimeType: "image/gif",
+    width: dataView.getUint16(6, LITTLE_ENDIAN),
+    height: dataView.getUint16(8, LITTLE_ENDIAN)
+  };
+}
+function getBmpMetadata(binaryData) {
+  const dataView = toDataView(binaryData);
+  const isBmp = dataView.byteLength >= 14 && dataView.getUint16(0, BIG_ENDIAN) === 16973 && dataView.getUint32(2, LITTLE_ENDIAN) === dataView.byteLength;
+  if (!isBmp) {
+    return null;
+  }
+  return {
+    mimeType: "image/bmp",
+    width: dataView.getUint32(18, LITTLE_ENDIAN),
+    height: dataView.getUint32(22, LITTLE_ENDIAN)
+  };
+}
+function getJpegMetadata(binaryData) {
+  const dataView = toDataView(binaryData);
+  const isJpeg = dataView.byteLength >= 3 && dataView.getUint16(0, BIG_ENDIAN) === 65496 && dataView.getUint8(2) === 255;
+  if (!isJpeg) {
+    return null;
+  }
+  const { tableMarkers, sofMarkers } = getJpegMarkers();
+  let i = 2;
+  while (i + 9 < dataView.byteLength) {
+    const marker2 = dataView.getUint16(i, BIG_ENDIAN);
+    if (sofMarkers.has(marker2)) {
+      return {
+        mimeType: "image/jpeg",
+        height: dataView.getUint16(i + 5, BIG_ENDIAN),
+        width: dataView.getUint16(i + 7, BIG_ENDIAN)
+      };
+    }
+    if (!tableMarkers.has(marker2)) {
+      return null;
+    }
+    i += 2;
+    i += dataView.getUint16(i, BIG_ENDIAN);
+  }
+  return null;
+}
+function getJpegMarkers() {
+  const tableMarkers = new Set([65499, 65476, 65484, 65501, 65534]);
+  for (let i = 65504; i < 65520; ++i) {
+    tableMarkers.add(i);
+  }
+  const sofMarkers = new Set([
+    65472,
+    65473,
+    65474,
+    65475,
+    65477,
+    65478,
+    65479,
+    65481,
+    65482,
+    65483,
+    65485,
+    65486,
+    65487,
+    65502
+  ]);
+  return { tableMarkers, sofMarkers };
+}
+function toDataView(data) {
+  if (data instanceof DataView) {
+    return data;
+  }
+  if (ArrayBuffer.isView(data)) {
+    return new DataView(data.buffer);
+  }
+  if (data instanceof ArrayBuffer) {
+    return new DataView(data);
+  }
+  throw new Error("toDataView");
+}
+
+// ../images/src/lib/parsers/parse-to-node-image.ts
+async function parseToNodeImage(arrayBuffer, options) {
+  const { mimeType } = getBinaryImageMetadata(arrayBuffer) || {};
+  const _parseImageNode2 = globalThis._parseImageNode;
+  assert2(_parseImageNode2);
+  return await _parseImageNode2(arrayBuffer, mimeType);
+}
+
+// ../images/src/lib/parsers/parse-image.ts
+async function parseImage(arrayBuffer, options, context) {
+  options = options || {};
+  const imageOptions = options.image || {};
+  const imageType = imageOptions.type || "auto";
+  const { url } = context || {};
+  const loadType = getLoadableImageType(imageType);
+  let image;
+  switch (loadType) {
+    case "imagebitmap":
+      image = await parseToImageBitmap(arrayBuffer, options, url);
+      break;
+    case "image":
+      image = await parseToImage(arrayBuffer, options, url);
+      break;
+    case "data":
+      image = await parseToNodeImage(arrayBuffer, options);
+      break;
+    default:
+      assert2(false);
+  }
+  if (imageType === "data") {
+    image = getImageData(image);
+  }
+  return image;
+}
+function getLoadableImageType(type) {
+  switch (type) {
+    case "auto":
+    case "data":
+      return getDefaultImageType();
+    default:
+      isImageTypeSupported(type);
+      return type;
+  }
+}
+
+// ../images/src/image-loader.ts
+var EXTENSIONS = ["png", "jpg", "jpeg", "gif", "webp", "bmp", "ico", "svg", "avif"];
+var MIME_TYPES = [
+  "image/png",
+  "image/jpeg",
+  "image/gif",
+  "image/webp",
+  "image/avif",
+  "image/bmp",
+  "image/vnd.microsoft.icon",
+  "image/svg+xml"
+];
+var DEFAULT_IMAGE_LOADER_OPTIONS = {
+  image: {
+    type: "auto",
+    decode: true
+  }
+};
+var ImageLoader = {
+  id: "image",
+  module: "images",
+  name: "Images",
+  version: VERSION9,
+  mimeTypes: MIME_TYPES,
+  extensions: EXTENSIONS,
+  parse: parseImage,
+  tests: [(arrayBuffer) => Boolean(getBinaryImageMetadata(new DataView(arrayBuffer)))],
+  options: DEFAULT_IMAGE_LOADER_OPTIONS
+};
+
+// ../images/src/lib/encoders/encode-image.ts
+var { _encodeImageNode } = globalThis;
+async function encodeImage(image, options) {
+  options = options || {};
+  options.image = options.image || {};
+  return _encodeImageNode ? _encodeImageNode(image, { type: options.image.mimeType }) : encodeImageInBrowser(image, options);
+}
+var qualityParamSupported = true;
+async function encodeImageInBrowser(image, options) {
+  const { mimeType, jpegQuality } = options.image;
+  const { width, height } = getImageSize(image);
+  const canvas = document.createElement("canvas");
+  canvas.width = width;
+  canvas.height = height;
+  drawImageToCanvas(image, canvas);
+  const blob = await new Promise((resolve2) => {
+    if (jpegQuality && qualityParamSupported) {
+      try {
+        canvas.toBlob(resolve2, mimeType, jpegQuality);
+        return;
+      } catch (error) {
+        qualityParamSupported = false;
+      }
+    }
+    canvas.toBlob(resolve2, mimeType);
+  });
+  if (!blob) {
+    throw new Error("image encoding failed");
+  }
+  return await blob.arrayBuffer();
+}
+function drawImageToCanvas(image, canvas, x = 0, y = 0) {
+  if (x === 0 && y === 0 && typeof ImageBitmap !== "undefined" && image instanceof ImageBitmap) {
+    const context2 = canvas.getContext("bitmaprenderer");
+    if (context2) {
+      context2.transferFromImageBitmap(image);
+      return canvas;
+    }
+  }
+  const context = canvas.getContext("2d");
+  if (image.data) {
+    const clampedArray = new Uint8ClampedArray(image.data);
+    const imageData = new ImageData(clampedArray, image.width, image.height);
+    context.putImageData(imageData, 0, 0);
+    return canvas;
+  }
+  context.drawImage(image, 0, 0);
+  return canvas;
+}
+
+// ../images/src/image-writer.ts
+var ImageWriter = {
+  name: "Images",
+  id: "image",
+  module: "images",
+  version: VERSION9,
+  extensions: ["jpeg"],
+  options: {
+    image: {
+      mimeType: "image/png",
+      jpegQuality: null
+    }
+  },
+  encode: encodeImage
+};
+
+// ../images/src/lib/category-api/image-format.ts
+var mimeTypeSupportedSync = {};
+function isImageFormatSupported(mimeType) {
+  if (mimeTypeSupportedSync[mimeType] === void 0) {
+    const supported = isBrowser ? checkBrowserImageFormatSupport(mimeType) : checkNodeImageFormatSupport(mimeType);
+    mimeTypeSupportedSync[mimeType] = supported;
+  }
+  return mimeTypeSupportedSync[mimeType];
+}
+function checkNodeImageFormatSupport(mimeType) {
+  const NODE_FORMAT_SUPPORT = ["image/png", "image/jpeg", "image/gif"];
+  const { _parseImageNode: _parseImageNode2, _imageFormatsNode = NODE_FORMAT_SUPPORT } = globalThis;
+  return Boolean(_parseImageNode2) && _imageFormatsNode.includes(mimeType);
+}
+function checkBrowserImageFormatSupport(mimeType) {
+  switch (mimeType) {
+    case "image/avif":
+    case "image/webp":
+      return testBrowserImageFormatSupport(mimeType);
+    default:
+      return true;
+  }
+}
+function testBrowserImageFormatSupport(mimeType) {
+  try {
+    const element = document.createElement("canvas");
+    const dataURL = element.toDataURL(mimeType);
+    return dataURL.indexOf(`data:${mimeType}`) === 0;
+  } catch {
+    return false;
+  }
+}
+
+// ../textures/src/lib/utils/version.ts
+var VERSION10 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "beta";
+
+// ../textures/src/lib/parsers/basis-module-loader.ts
+var VERSION11 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "beta";
+var BASIS_CDN_ENCODER_WASM = `https://unpkg.com/@loaders.gl/textures@${VERSION11}/dist/libs/basis_encoder.wasm`;
+var BASIS_CDN_ENCODER_JS = `https://unpkg.com/@loaders.gl/textures@${VERSION11}/dist/libs/basis_encoder.js`;
+var loadBasisTranscoderPromise;
+async function loadBasisTrascoderModule(options) {
+  const modules = options.modules || {};
+  if (modules.basis) {
+    return modules.basis;
+  }
+  loadBasisTranscoderPromise = loadBasisTranscoderPromise || loadBasisTrascoder(options);
+  return await loadBasisTranscoderPromise;
+}
+async function loadBasisTrascoder(options) {
+  let BASIS = null;
+  let wasmBinary = null;
+  [BASIS, wasmBinary] = await Promise.all([
+    await loadLibrary("basis_transcoder.js", "textures", options),
+    await loadLibrary("basis_transcoder.wasm", "textures", options)
+  ]);
+  BASIS = BASIS || globalThis.BASIS;
+  return await initializeBasisTrascoderModule(BASIS, wasmBinary);
+}
+function initializeBasisTrascoderModule(BasisModule, wasmBinary) {
+  const options = {};
+  if (wasmBinary) {
+    options.wasmBinary = wasmBinary;
+  }
+  return new Promise((resolve2) => {
+    BasisModule(options).then((module2) => {
+      const { BasisFile, initializeBasis } = module2;
+      initializeBasis();
+      resolve2({ BasisFile });
+    });
+  });
+}
+var loadBasisEncoderPromise;
+async function loadBasisEncoderModule(options) {
+  const modules = options.modules || {};
+  if (modules.basisEncoder) {
+    return modules.basisEncoder;
+  }
+  loadBasisEncoderPromise = loadBasisEncoderPromise || loadBasisEncoder(options);
+  return await loadBasisEncoderPromise;
+}
+async function loadBasisEncoder(options) {
+  let BASIS_ENCODER = null;
+  let wasmBinary = null;
+  [BASIS_ENCODER, wasmBinary] = await Promise.all([
+    await loadLibrary(BASIS_CDN_ENCODER_JS, "textures", options),
+    await loadLibrary(BASIS_CDN_ENCODER_WASM, "textures", options)
+  ]);
+  BASIS_ENCODER = BASIS_ENCODER || globalThis.BASIS;
+  return await initializeBasisEncoderModule(BASIS_ENCODER, wasmBinary);
+}
+function initializeBasisEncoderModule(BasisEncoderModule, wasmBinary) {
+  const options = {};
+  if (wasmBinary) {
+    options.wasmBinary = wasmBinary;
+  }
+  return new Promise((resolve2) => {
+    BasisEncoderModule(options).then((module2) => {
+      const { BasisFile, KTX2File, initializeBasis, BasisEncoder } = module2;
+      initializeBasis();
+      resolve2({ BasisFile, KTX2File, BasisEncoder });
+    });
+  });
+}
+
+// ../textures/src/lib/gl-extensions.ts
+var GL_EXTENSIONS_CONSTANTS = {
+  COMPRESSED_RGB_S3TC_DXT1_EXT: 33776,
+  COMPRESSED_RGBA_S3TC_DXT1_EXT: 33777,
+  COMPRESSED_RGBA_S3TC_DXT3_EXT: 33778,
+  COMPRESSED_RGBA_S3TC_DXT5_EXT: 33779,
+  COMPRESSED_R11_EAC: 37488,
+  COMPRESSED_SIGNED_R11_EAC: 37489,
+  COMPRESSED_RG11_EAC: 37490,
+  COMPRESSED_SIGNED_RG11_EAC: 37491,
+  COMPRESSED_RGB8_ETC2: 37492,
+  COMPRESSED_RGBA8_ETC2_EAC: 37493,
+  COMPRESSED_SRGB8_ETC2: 37494,
+  COMPRESSED_SRGB8_ALPHA8_ETC2_EAC: 37495,
+  COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2: 37496,
+  COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2: 37497,
+  COMPRESSED_RGB_PVRTC_4BPPV1_IMG: 35840,
+  COMPRESSED_RGBA_PVRTC_4BPPV1_IMG: 35842,
+  COMPRESSED_RGB_PVRTC_2BPPV1_IMG: 35841,
+  COMPRESSED_RGBA_PVRTC_2BPPV1_IMG: 35843,
+  COMPRESSED_RGB_ETC1_WEBGL: 36196,
+  COMPRESSED_RGB_ATC_WEBGL: 35986,
+  COMPRESSED_RGBA_ATC_EXPLICIT_ALPHA_WEBGL: 35987,
+  COMPRESSED_RGBA_ATC_INTERPOLATED_ALPHA_WEBGL: 34798,
+  COMPRESSED_RGBA_ASTC_4X4_KHR: 37808,
+  COMPRESSED_RGBA_ASTC_5X4_KHR: 37809,
+  COMPRESSED_RGBA_ASTC_5X5_KHR: 37810,
+  COMPRESSED_RGBA_ASTC_6X5_KHR: 37811,
+  COMPRESSED_RGBA_ASTC_6X6_KHR: 37812,
+  COMPRESSED_RGBA_ASTC_8X5_KHR: 37813,
+  COMPRESSED_RGBA_ASTC_8X6_KHR: 37814,
+  COMPRESSED_RGBA_ASTC_8X8_KHR: 37815,
+  COMPRESSED_RGBA_ASTC_10X5_KHR: 37816,
+  COMPRESSED_RGBA_ASTC_10X6_KHR: 37817,
+  COMPRESSED_RGBA_ASTC_10X8_KHR: 37818,
+  COMPRESSED_RGBA_ASTC_10X10_KHR: 37819,
+  COMPRESSED_RGBA_ASTC_12X10_KHR: 37820,
+  COMPRESSED_RGBA_ASTC_12X12_KHR: 37821,
+  COMPRESSED_SRGB8_ALPHA8_ASTC_4X4_KHR: 37840,
+  COMPRESSED_SRGB8_ALPHA8_ASTC_5X4_KHR: 37841,
+  COMPRESSED_SRGB8_ALPHA8_ASTC_5X5_KHR: 37842,
+  COMPRESSED_SRGB8_ALPHA8_ASTC_6X5_KHR: 37843,
+  COMPRESSED_SRGB8_ALPHA8_ASTC_6X6_KHR: 37844,
+  COMPRESSED_SRGB8_ALPHA8_ASTC_8X5_KHR: 37845,
+  COMPRESSED_SRGB8_ALPHA8_ASTC_8X6_KHR: 37846,
+  COMPRESSED_SRGB8_ALPHA8_ASTC_8X8_KHR: 37847,
+  COMPRESSED_SRGB8_ALPHA8_ASTC_10X5_KHR: 37848,
+  COMPRESSED_SRGB8_ALPHA8_ASTC_10X6_KHR: 37849,
+  COMPRESSED_SRGB8_ALPHA8_ASTC_10X8_KHR: 37850,
+  COMPRESSED_SRGB8_ALPHA8_ASTC_10X10_KHR: 37851,
+  COMPRESSED_SRGB8_ALPHA8_ASTC_12X10_KHR: 37852,
+  COMPRESSED_SRGB8_ALPHA8_ASTC_12X12_KHR: 37853,
+  COMPRESSED_RED_RGTC1_EXT: 36283,
+  COMPRESSED_SIGNED_RED_RGTC1_EXT: 36284,
+  COMPRESSED_RED_GREEN_RGTC2_EXT: 36285,
+  COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT: 36286,
+  COMPRESSED_SRGB_S3TC_DXT1_EXT: 35916,
+  COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT: 35917,
+  COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT: 35918,
+  COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT: 35919
+};
+
+// ../textures/src/lib/utils/texture-formats.ts
+var BROWSER_PREFIXES = ["", "WEBKIT_", "MOZ_"];
+var WEBGL_EXTENSIONS = {
+  WEBGL_compressed_texture_s3tc: "dxt",
+  WEBGL_compressed_texture_s3tc_srgb: "dxt-srgb",
+  WEBGL_compressed_texture_etc1: "etc1",
+  WEBGL_compressed_texture_etc: "etc2",
+  WEBGL_compressed_texture_pvrtc: "pvrtc",
+  WEBGL_compressed_texture_atc: "atc",
+  WEBGL_compressed_texture_astc: "astc",
+  EXT_texture_compression_rgtc: "rgtc"
+};
+var formats = null;
+function getSupportedGPUTextureFormats(gl) {
+  if (!formats) {
+    gl = gl || getWebGLContext() || void 0;
+    formats = new Set();
+    for (const prefix of BROWSER_PREFIXES) {
+      for (const extension in WEBGL_EXTENSIONS) {
+        if (gl && gl.getExtension(`${prefix}${extension}`)) {
+          const gpuTextureFormat = WEBGL_EXTENSIONS[extension];
+          formats.add(gpuTextureFormat);
+        }
+      }
+    }
+  }
+  return formats;
+}
+function getWebGLContext() {
+  try {
+    const canvas = document.createElement("canvas");
+    return canvas.getContext("webgl");
+  } catch (error) {
+    return null;
+  }
+}
+
+// ../textures/src/lib/parsers/parse-ktx.ts
+var import_ktx_parse = __toModule(require_ktx_parse());
+
+// ../textures/src/lib/utils/extract-mipmap-images.ts
+function extractMipmapImages(data, options) {
+  const images = new Array(options.mipMapLevels);
+  let levelWidth = options.width;
+  let levelHeight = options.height;
+  let offset = 0;
+  for (let i = 0; i < options.mipMapLevels; ++i) {
+    const levelSize = getLevelSize(options, levelWidth, levelHeight, data, i);
+    const levelData = getLevelData(data, i, offset, levelSize);
+    images[i] = {
+      compressed: true,
+      format: options.internalFormat,
+      data: levelData,
+      width: levelWidth,
+      height: levelHeight,
+      levelSize
+    };
+    levelWidth = Math.max(1, levelWidth >> 1);
+    levelHeight = Math.max(1, levelHeight >> 1);
+    offset += levelSize;
+  }
+  return images;
+}
+function getLevelData(data, index, offset, levelSize) {
+  if (!Array.isArray(data)) {
+    return new Uint8Array(data.buffer, data.byteOffset + offset, levelSize);
+  }
+  return data[index].levelData;
+}
+function getLevelSize(options, levelWidth, levelHeight, data, index) {
+  if (!Array.isArray(data)) {
+    return options.sizeFunction(levelWidth, levelHeight);
+  }
+  return options.sizeFunction(data[index]);
+}
+
+// ../textures/src/lib/utils/ktx-format-helper.ts
+var VULKAN_TO_WEBGL_FORMAT_MAP = {
+  131: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGB_S3TC_DXT1_EXT,
+  132: GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB_S3TC_DXT1_EXT,
+  133: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_S3TC_DXT1_EXT,
+  134: GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT,
+  135: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_S3TC_DXT3_EXT,
+  136: GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT,
+  137: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_S3TC_DXT5_EXT,
+  138: GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT,
+  139: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RED_RGTC1_EXT,
+  140: GL_EXTENSIONS_CONSTANTS.COMPRESSED_SIGNED_RED_RGTC1_EXT,
+  141: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RED_GREEN_RGTC2_EXT,
+  142: GL_EXTENSIONS_CONSTANTS.COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT,
+  147: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGB8_ETC2,
+  148: GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ETC2,
+  149: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2,
+  150: GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2,
+  151: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA8_ETC2_EAC,
+  152: GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ETC2_EAC,
+  153: GL_EXTENSIONS_CONSTANTS.COMPRESSED_R11_EAC,
+  154: GL_EXTENSIONS_CONSTANTS.COMPRESSED_SIGNED_R11_EAC,
+  155: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RG11_EAC,
+  156: GL_EXTENSIONS_CONSTANTS.COMPRESSED_SIGNED_RG11_EAC,
+  157: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_4x4_KHR,
+  158: GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR,
+  159: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_5x4_KHR,
+  160: GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_5X4_KHR,
+  161: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_5x5_KHR,
+  162: GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR,
+  163: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_6x5_KHR,
+  164: GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR,
+  165: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_6x6_KHR,
+  166: GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR,
+  167: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_8x5_KHR,
+  168: GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR,
+  169: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_8x6_KHR,
+  170: GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR,
+  171: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_8x8_KHR,
+  172: GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR,
+  173: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_10x5_KHR,
+  174: GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR,
+  175: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_10x6_KHR,
+  176: GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR,
+  177: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_10x8_KHR,
+  178: GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR,
+  179: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_10x10_KHR,
+  180: GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR,
+  181: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_12x10_KHR,
+  182: GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR,
+  183: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_12x12_KHR,
+  184: GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR,
+  1000054e3: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_PVRTC_2BPPV1_IMG,
+  1000054001: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_PVRTC_4BPPV1_IMG,
+  1000066e3: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_4x4_KHR,
+  1000066001: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_5x4_KHR,
+  1000066002: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_5x5_KHR,
+  1000066003: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_6x5_KHR,
+  1000066004: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_6x6_KHR,
+  1000066005: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_8x5_KHR,
+  1000066006: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_8x6_KHR,
+  1000066007: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_8x8_KHR,
+  1000066008: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_10x5_KHR,
+  1000066009: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_10x6_KHR,
+  1000066010: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_10x8_KHR,
+  1000066011: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_10x10_KHR,
+  1000066012: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_12x10_KHR,
+  1000066013: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_12x12_KHR
+};
+function mapVkFormatToWebGL(vkFormat) {
+  return VULKAN_TO_WEBGL_FORMAT_MAP[vkFormat];
+}
+
+// ../textures/src/lib/parsers/parse-ktx.ts
+var KTX2_ID = [
+  171,
+  75,
+  84,
+  88,
+  32,
+  50,
+  48,
+  187,
+  13,
+  10,
+  26,
+  10
+];
+function isKTX(data) {
+  const id = new Uint8Array(data);
+  const notKTX = id.byteLength < KTX2_ID.length || id[0] !== KTX2_ID[0] || id[1] !== KTX2_ID[1] || id[2] !== KTX2_ID[2] || id[3] !== KTX2_ID[3] || id[4] !== KTX2_ID[4] || id[5] !== KTX2_ID[5] || id[6] !== KTX2_ID[6] || id[7] !== KTX2_ID[7] || id[8] !== KTX2_ID[8] || id[9] !== KTX2_ID[9] || id[10] !== KTX2_ID[10] || id[11] !== KTX2_ID[11];
+  return !notKTX;
+}
+function parseKTX(arrayBuffer) {
+  const uint8Array = new Uint8Array(arrayBuffer);
+  const ktx = (0, import_ktx_parse.read)(uint8Array);
+  const mipMapLevels = Math.max(1, ktx.levels.length);
+  const width = ktx.pixelWidth;
+  const height = ktx.pixelHeight;
+  const internalFormat = mapVkFormatToWebGL(ktx.vkFormat);
+  return extractMipmapImages(ktx.levels, {
+    mipMapLevels,
+    width,
+    height,
+    sizeFunction: (level) => level.uncompressedByteLength,
+    internalFormat
+  });
+}
+
+// ../textures/src/lib/parsers/parse-basis.ts
 var OutputFormat = {
   etc1: {
     basisFormat: 0,
@@ -53716,9 +54421,9 @@ function selectSupportedBasisFormat() {
 // ../textures/src/basis-loader.ts
 var BasisWorkerLoader = {
   name: "Basis",
-  id: isBrowser2 ? "basis" : "basis-nodejs",
+  id: "basis",
   module: "textures",
-  version: VERSION9,
+  version: VERSION10,
   worker: true,
   extensions: ["basis", "ktx2"],
   mimeTypes: ["application/octet-stream", "image/ktx2"],
@@ -53955,624 +54660,125 @@ function pvrtc2bppSize(width, height) {
   height = Math.max(height, 8);
   return width * height / 4;
 }
-function pvrtc4bppSize(width, height) {
-  width = Math.max(width, 8);
-  height = Math.max(height, 8);
-  return width * height / 2;
-}
-function dxtEtcSmallSize(width, height) {
-  return Math.floor((width + 3) / 4) * Math.floor((height + 3) / 4) * 8;
-}
-function dxtEtcAstcBigSize(width, height) {
-  return Math.floor((width + 3) / 4) * Math.floor((height + 3) / 4) * 16;
-}
-function atc5x4Size(width, height) {
-  return Math.floor((width + 4) / 5) * Math.floor((height + 3) / 4) * 16;
-}
-function atc5x5Size(width, height) {
-  return Math.floor((width + 4) / 5) * Math.floor((height + 4) / 5) * 16;
-}
-function atc6x5Size(width, height) {
-  return Math.floor((width + 5) / 6) * Math.floor((height + 4) / 5) * 16;
-}
-function atc6x6Size(width, height) {
-  return Math.floor((width + 5) / 6) * Math.floor((height + 5) / 6) * 16;
-}
-function atc8x5Size(width, height) {
-  return Math.floor((width + 7) / 8) * Math.floor((height + 4) / 5) * 16;
-}
-function atc8x6Size(width, height) {
-  return Math.floor((width + 7) / 8) * Math.floor((height + 5) / 6) * 16;
-}
-function atc8x8Size(width, height) {
-  return Math.floor((width + 7) / 8) * Math.floor((height + 7) / 8) * 16;
-}
-function atc10x5Size(width, height) {
-  return Math.floor((width + 9) / 10) * Math.floor((height + 4) / 5) * 16;
-}
-function atc10x6Size(width, height) {
-  return Math.floor((width + 9) / 10) * Math.floor((height + 5) / 6) * 16;
-}
-function atc10x8Size(width, height) {
-  return Math.floor((width + 9) / 10) * Math.floor((height + 7) / 8) * 16;
-}
-function atc10x10Size(width, height) {
-  return Math.floor((width + 9) / 10) * Math.floor((height + 9) / 10) * 16;
-}
-function atc12x10Size(width, height) {
-  return Math.floor((width + 11) / 12) * Math.floor((height + 9) / 10) * 16;
-}
-function atc12x12Size(width, height) {
-  return Math.floor((width + 11) / 12) * Math.floor((height + 11) / 12) * 16;
-}
-
-// ../textures/src/lib/parsers/parse-compressed-texture.ts
-function parseCompressedTexture(data) {
-  if (isKTX(data)) {
-    return parseKTX(data);
-  }
-  if (isDDS(data)) {
-    return parseDDS(data);
-  }
-  if (isPVR(data)) {
-    return parsePVR(data);
-  }
-  throw new Error("Texture container format not recognized");
-}
-
-// ../textures/src/compressed-texture-loader.ts
-var DEFAULT_TEXTURE_LOADER_OPTIONS = {
-  "compressed-texture": {
-    libraryPath: "libs/",
-    useBasis: false
-  }
-};
-var CompressedTextureWorkerLoader = {
-  name: "Texture Containers",
-  id: "compressed-texture",
-  module: "textures",
-  version: VERSION9,
-  worker: true,
-  extensions: [
-    "ktx",
-    "ktx2",
-    "dds",
-    "pvr"
-  ],
-  mimeTypes: [
-    "image/ktx2",
-    "image/ktx",
-    "image/vnd-ms.dds",
-    "image/x-dds",
-    "application/octet-stream"
-  ],
-  binary: true,
-  options: DEFAULT_TEXTURE_LOADER_OPTIONS
-};
-var CompressedTextureLoader = {
-  ...CompressedTextureWorkerLoader,
-  parse: async (arrayBuffer, options) => {
-    if (options["compressed-texture"].useBasis) {
-      options.basis = {
-        format: {
-          alpha: "BC3",
-          noAlpha: "BC1"
-        },
-        ...options.basis,
-        containerFormat: "ktx2",
-        module: "encoder"
-      };
-      return (await parseBasis(arrayBuffer, options))[0];
-    }
-    return parseCompressedTexture(arrayBuffer);
-  }
-};
-
-// ../images/src/lib/utils/version.ts
-var VERSION11 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
-
-// ../images/src/lib/category-api/image-type.ts
-var { _parseImageNode } = globalThis;
-var IMAGE_SUPPORTED = typeof Image !== "undefined";
-var IMAGE_BITMAP_SUPPORTED = typeof ImageBitmap !== "undefined";
-var NODE_IMAGE_SUPPORTED = Boolean(_parseImageNode);
-var DATA_SUPPORTED = isBrowser ? true : NODE_IMAGE_SUPPORTED;
-function isImageTypeSupported(type) {
-  switch (type) {
-    case "auto":
-      return IMAGE_BITMAP_SUPPORTED || IMAGE_SUPPORTED || DATA_SUPPORTED;
-    case "imagebitmap":
-      return IMAGE_BITMAP_SUPPORTED;
-    case "image":
-      return IMAGE_SUPPORTED;
-    case "data":
-      return DATA_SUPPORTED;
-    default:
-      throw new Error(`@loaders.gl/images: image ${type} not supported in this environment`);
-  }
-}
-function getDefaultImageType() {
-  if (IMAGE_BITMAP_SUPPORTED) {
-    return "imagebitmap";
-  }
-  if (IMAGE_SUPPORTED) {
-    return "image";
-  }
-  if (DATA_SUPPORTED) {
-    return "data";
-  }
-  throw new Error("Install '@loaders.gl/polyfills' to parse images under Node.js");
-}
-
-// ../images/src/lib/category-api/parsed-image-api.ts
-function getImageType(image) {
-  const format = getImageTypeOrNull(image);
-  if (!format) {
-    throw new Error("Not an image");
-  }
-  return format;
-}
-function getImageSize(image) {
-  return getImageData(image);
-}
-function getImageData(image) {
-  switch (getImageType(image)) {
-    case "data":
-      return image;
-    case "image":
-    case "imagebitmap":
-      const canvas = document.createElement("canvas");
-      const context = canvas.getContext("2d");
-      if (!context) {
-        throw new Error("getImageData");
-      }
-      canvas.width = image.width;
-      canvas.height = image.height;
-      context.drawImage(image, 0, 0);
-      return context.getImageData(0, 0, image.width, image.height);
-    default:
-      throw new Error("getImageData");
-  }
-}
-function getImageTypeOrNull(image) {
-  if (typeof ImageBitmap !== "undefined" && image instanceof ImageBitmap) {
-    return "imagebitmap";
-  }
-  if (typeof Image !== "undefined" && image instanceof Image) {
-    return "image";
-  }
-  if (image && typeof image === "object" && image.data && image.width && image.height) {
-    return "data";
-  }
-  return null;
-}
-
-// ../images/src/lib/parsers/svg-utils.ts
-var SVG_DATA_URL_PATTERN = /^data:image\/svg\+xml/;
-var SVG_URL_PATTERN = /\.svg((\?|#).*)?$/;
-function isSVG(url) {
-  return url && (SVG_DATA_URL_PATTERN.test(url) || SVG_URL_PATTERN.test(url));
-}
-function getBlobOrSVGDataUrl(arrayBuffer, url) {
-  if (isSVG(url)) {
-    const textDecoder = new TextDecoder();
-    let xmlText = textDecoder.decode(arrayBuffer);
-    try {
-      if (typeof unescape === "function" && typeof encodeURIComponent === "function") {
-        xmlText = unescape(encodeURIComponent(xmlText));
-      }
-    } catch (error) {
-      throw new Error(error.message);
-    }
-    const src = `data:image/svg+xml;base64,${btoa(xmlText)}`;
-    return src;
-  }
-  return getBlob(arrayBuffer, url);
-}
-function getBlob(arrayBuffer, url) {
-  if (isSVG(url)) {
-    throw new Error("SVG cannot be parsed directly to imagebitmap");
-  }
-  return new Blob([new Uint8Array(arrayBuffer)]);
-}
-
-// ../images/src/lib/parsers/parse-to-image.ts
-async function parseToImage(arrayBuffer, options, url) {
-  const blobOrDataUrl = getBlobOrSVGDataUrl(arrayBuffer, url);
-  const URL2 = self.URL || self.webkitURL;
-  const objectUrl = typeof blobOrDataUrl !== "string" && URL2.createObjectURL(blobOrDataUrl);
-  try {
-    return await loadToImage(objectUrl || blobOrDataUrl, options);
-  } finally {
-    if (objectUrl) {
-      URL2.revokeObjectURL(objectUrl);
-    }
-  }
-}
-async function loadToImage(url, options) {
-  const image = new Image();
-  image.src = url;
-  if (options.image && options.image.decode && image.decode) {
-    await image.decode();
-    return image;
-  }
-  return await new Promise((resolve2, reject) => {
-    try {
-      image.onload = () => resolve2(image);
-      image.onerror = (err) => reject(new Error(`Could not load image ${url}: ${err}`));
-    } catch (error) {
-      reject(error);
-    }
-  });
-}
-
-// ../images/src/lib/parsers/parse-to-image-bitmap.ts
-var EMPTY_OBJECT = {};
-var imagebitmapOptionsSupported = true;
-async function parseToImageBitmap(arrayBuffer, options, url) {
-  let blob;
-  if (isSVG(url)) {
-    const image = await parseToImage(arrayBuffer, options, url);
-    blob = image;
-  } else {
-    blob = getBlob(arrayBuffer, url);
-  }
-  const imagebitmapOptions = options && options.imagebitmap;
-  return await safeCreateImageBitmap(blob, imagebitmapOptions);
-}
-async function safeCreateImageBitmap(blob, imagebitmapOptions = null) {
-  if (isEmptyObject(imagebitmapOptions) || !imagebitmapOptionsSupported) {
-    imagebitmapOptions = null;
-  }
-  if (imagebitmapOptions) {
-    try {
-      return await createImageBitmap(blob, imagebitmapOptions);
-    } catch (error) {
-      console.warn(error);
-      imagebitmapOptionsSupported = false;
-    }
-  }
-  return await createImageBitmap(blob);
-}
-function isEmptyObject(object) {
-  for (const key in object || EMPTY_OBJECT) {
-    return false;
-  }
-  return true;
+function pvrtc4bppSize(width, height) {
+  width = Math.max(width, 8);
+  height = Math.max(height, 8);
+  return width * height / 2;
 }
-
-// ../images/src/lib/category-api/parse-isobmff-binary.ts
-function getISOBMFFMediaType(buffer) {
-  if (!checkString(buffer, "ftyp", 4)) {
-    return null;
-  }
-  if ((buffer[8] & 96) === 0) {
-    return null;
-  }
-  return decodeMajorBrand(buffer);
+function dxtEtcSmallSize(width, height) {
+  return Math.floor((width + 3) / 4) * Math.floor((height + 3) / 4) * 8;
 }
-function decodeMajorBrand(buffer) {
-  const brandMajor = getUTF8String(buffer, 8, 12).replace("\0", " ").trim();
-  switch (brandMajor) {
-    case "avif":
-    case "avis":
-      return { extension: "avif", mimeType: "image/avif" };
-    default:
-      return null;
-  }
+function dxtEtcAstcBigSize(width, height) {
+  return Math.floor((width + 3) / 4) * Math.floor((height + 3) / 4) * 16;
 }
-function getUTF8String(array, start, end) {
-  return String.fromCharCode(...array.slice(start, end));
+function atc5x4Size(width, height) {
+  return Math.floor((width + 4) / 5) * Math.floor((height + 3) / 4) * 16;
 }
-function stringToBytes(string) {
-  return [...string].map((character) => character.charCodeAt(0));
+function atc5x5Size(width, height) {
+  return Math.floor((width + 4) / 5) * Math.floor((height + 4) / 5) * 16;
 }
-function checkString(buffer, header, offset = 0) {
-  const headerBytes = stringToBytes(header);
-  for (let i = 0; i < headerBytes.length; ++i) {
-    if (headerBytes[i] !== buffer[i + offset]) {
-      return false;
-    }
-  }
-  return true;
+function atc6x5Size(width, height) {
+  return Math.floor((width + 5) / 6) * Math.floor((height + 4) / 5) * 16;
 }
-
-// ../images/src/lib/category-api/binary-image-api.ts
-var BIG_ENDIAN = false;
-var LITTLE_ENDIAN = true;
-function getBinaryImageMetadata(binaryData) {
-  const dataView = toDataView(binaryData);
-  return getPngMetadata(dataView) || getJpegMetadata(dataView) || getGifMetadata(dataView) || getBmpMetadata(dataView) || getISOBMFFMetadata(dataView);
+function atc6x6Size(width, height) {
+  return Math.floor((width + 5) / 6) * Math.floor((height + 5) / 6) * 16;
 }
-function getISOBMFFMetadata(binaryData) {
-  const buffer = new Uint8Array(binaryData instanceof DataView ? binaryData.buffer : binaryData);
-  const mediaType = getISOBMFFMediaType(buffer);
-  if (!mediaType) {
-    return null;
-  }
-  return {
-    mimeType: mediaType.mimeType,
-    width: 0,
-    height: 0
-  };
+function atc8x5Size(width, height) {
+  return Math.floor((width + 7) / 8) * Math.floor((height + 4) / 5) * 16;
 }
-function getPngMetadata(binaryData) {
-  const dataView = toDataView(binaryData);
-  const isPng = dataView.byteLength >= 24 && dataView.getUint32(0, BIG_ENDIAN) === 2303741511;
-  if (!isPng) {
-    return null;
-  }
-  return {
-    mimeType: "image/png",
-    width: dataView.getUint32(16, BIG_ENDIAN),
-    height: dataView.getUint32(20, BIG_ENDIAN)
-  };
+function atc8x6Size(width, height) {
+  return Math.floor((width + 7) / 8) * Math.floor((height + 5) / 6) * 16;
 }
-function getGifMetadata(binaryData) {
-  const dataView = toDataView(binaryData);
-  const isGif = dataView.byteLength >= 10 && dataView.getUint32(0, BIG_ENDIAN) === 1195984440;
-  if (!isGif) {
-    return null;
-  }
-  return {
-    mimeType: "image/gif",
-    width: dataView.getUint16(6, LITTLE_ENDIAN),
-    height: dataView.getUint16(8, LITTLE_ENDIAN)
-  };
+function atc8x8Size(width, height) {
+  return Math.floor((width + 7) / 8) * Math.floor((height + 7) / 8) * 16;
 }
-function getBmpMetadata(binaryData) {
-  const dataView = toDataView(binaryData);
-  const isBmp = dataView.byteLength >= 14 && dataView.getUint16(0, BIG_ENDIAN) === 16973 && dataView.getUint32(2, LITTLE_ENDIAN) === dataView.byteLength;
-  if (!isBmp) {
-    return null;
-  }
-  return {
-    mimeType: "image/bmp",
-    width: dataView.getUint32(18, LITTLE_ENDIAN),
-    height: dataView.getUint32(22, LITTLE_ENDIAN)
-  };
+function atc10x5Size(width, height) {
+  return Math.floor((width + 9) / 10) * Math.floor((height + 4) / 5) * 16;
 }
-function getJpegMetadata(binaryData) {
-  const dataView = toDataView(binaryData);
-  const isJpeg = dataView.byteLength >= 3 && dataView.getUint16(0, BIG_ENDIAN) === 65496 && dataView.getUint8(2) === 255;
-  if (!isJpeg) {
-    return null;
-  }
-  const { tableMarkers, sofMarkers } = getJpegMarkers();
-  let i = 2;
-  while (i + 9 < dataView.byteLength) {
-    const marker2 = dataView.getUint16(i, BIG_ENDIAN);
-    if (sofMarkers.has(marker2)) {
-      return {
-        mimeType: "image/jpeg",
-        height: dataView.getUint16(i + 5, BIG_ENDIAN),
-        width: dataView.getUint16(i + 7, BIG_ENDIAN)
-      };
-    }
-    if (!tableMarkers.has(marker2)) {
-      return null;
-    }
-    i += 2;
-    i += dataView.getUint16(i, BIG_ENDIAN);
-  }
-  return null;
+function atc10x6Size(width, height) {
+  return Math.floor((width + 9) / 10) * Math.floor((height + 5) / 6) * 16;
 }
-function getJpegMarkers() {
-  const tableMarkers = new Set([65499, 65476, 65484, 65501, 65534]);
-  for (let i = 65504; i < 65520; ++i) {
-    tableMarkers.add(i);
-  }
-  const sofMarkers = new Set([
-    65472,
-    65473,
-    65474,
-    65475,
-    65477,
-    65478,
-    65479,
-    65481,
-    65482,
-    65483,
-    65485,
-    65486,
-    65487,
-    65502
-  ]);
-  return { tableMarkers, sofMarkers };
+function atc10x8Size(width, height) {
+  return Math.floor((width + 9) / 10) * Math.floor((height + 7) / 8) * 16;
 }
-function toDataView(data) {
-  if (data instanceof DataView) {
-    return data;
-  }
-  if (ArrayBuffer.isView(data)) {
-    return new DataView(data.buffer);
-  }
-  if (data instanceof ArrayBuffer) {
-    return new DataView(data);
-  }
-  throw new Error("toDataView");
+function atc10x10Size(width, height) {
+  return Math.floor((width + 9) / 10) * Math.floor((height + 9) / 10) * 16;
 }
-
-// ../images/src/lib/parsers/parse-to-node-image.ts
-async function parseToNodeImage(arrayBuffer, options) {
-  const { mimeType } = getBinaryImageMetadata(arrayBuffer) || {};
-  const _parseImageNode2 = globalThis._parseImageNode;
-  assert2(_parseImageNode2);
-  return await _parseImageNode2(arrayBuffer, mimeType);
+function atc12x10Size(width, height) {
+  return Math.floor((width + 11) / 12) * Math.floor((height + 9) / 10) * 16;
+}
+function atc12x12Size(width, height) {
+  return Math.floor((width + 11) / 12) * Math.floor((height + 11) / 12) * 16;
 }
 
-// ../images/src/lib/parsers/parse-image.ts
-async function parseImage(arrayBuffer, options, context) {
-  options = options || {};
-  const imageOptions = options.image || {};
-  const imageType = imageOptions.type || "auto";
-  const { url } = context || {};
-  const loadType = getLoadableImageType(imageType);
-  let image;
-  switch (loadType) {
-    case "imagebitmap":
-      image = await parseToImageBitmap(arrayBuffer, options, url);
-      break;
-    case "image":
-      image = await parseToImage(arrayBuffer, options, url);
-      break;
-    case "data":
-      image = await parseToNodeImage(arrayBuffer, options);
-      break;
-    default:
-      assert2(false);
+// ../textures/src/lib/parsers/parse-compressed-texture.ts
+function parseCompressedTexture(data) {
+  if (isKTX(data)) {
+    return parseKTX(data);
   }
-  if (imageType === "data") {
-    image = getImageData(image);
+  if (isDDS(data)) {
+    return parseDDS(data);
   }
-  return image;
-}
-function getLoadableImageType(type) {
-  switch (type) {
-    case "auto":
-    case "data":
-      return getDefaultImageType();
-    default:
-      isImageTypeSupported(type);
-      return type;
+  if (isPVR(data)) {
+    return parsePVR(data);
   }
+  throw new Error("Texture container format not recognized");
 }
 
-// ../images/src/image-loader.ts
-var EXTENSIONS = ["png", "jpg", "jpeg", "gif", "webp", "bmp", "ico", "svg", "avif"];
-var MIME_TYPES = [
-  "image/png",
-  "image/jpeg",
-  "image/gif",
-  "image/webp",
-  "image/avif",
-  "image/bmp",
-  "image/vnd.microsoft.icon",
-  "image/svg+xml"
-];
-var DEFAULT_IMAGE_LOADER_OPTIONS = {
-  image: {
-    type: "auto",
-    decode: true
+// ../textures/src/compressed-texture-loader.ts
+var DEFAULT_TEXTURE_LOADER_OPTIONS = {
+  "compressed-texture": {
+    libraryPath: "libs/",
+    useBasis: false
   }
 };
-var ImageLoader = {
-  id: "image",
-  module: "images",
-  name: "Images",
-  version: VERSION11,
-  mimeTypes: MIME_TYPES,
-  extensions: EXTENSIONS,
-  parse: parseImage,
-  tests: [(arrayBuffer) => Boolean(getBinaryImageMetadata(new DataView(arrayBuffer)))],
-  options: DEFAULT_IMAGE_LOADER_OPTIONS
+var CompressedTextureWorkerLoader = {
+  name: "Texture Containers",
+  id: "compressed-texture",
+  module: "textures",
+  version: VERSION10,
+  worker: true,
+  extensions: [
+    "ktx",
+    "ktx2",
+    "dds",
+    "pvr"
+  ],
+  mimeTypes: [
+    "image/ktx2",
+    "image/ktx",
+    "image/vnd-ms.dds",
+    "image/x-dds",
+    "application/octet-stream"
+  ],
+  binary: true,
+  options: DEFAULT_TEXTURE_LOADER_OPTIONS
 };
-
-// ../images/src/lib/encoders/encode-image.ts
-var { _encodeImageNode } = globalThis;
-async function encodeImage(image, options) {
-  options = options || {};
-  options.image = options.image || {};
-  return _encodeImageNode ? _encodeImageNode(image, { type: options.image.mimeType }) : encodeImageInBrowser(image, options);
-}
-var qualityParamSupported = true;
-async function encodeImageInBrowser(image, options) {
-  const { mimeType, jpegQuality } = options.image;
-  const { width, height } = getImageSize(image);
-  const canvas = document.createElement("canvas");
-  canvas.width = width;
-  canvas.height = height;
-  drawImageToCanvas(image, canvas);
-  const blob = await new Promise((resolve2) => {
-    if (jpegQuality && qualityParamSupported) {
-      try {
-        canvas.toBlob(resolve2, mimeType, jpegQuality);
-        return;
-      } catch (error) {
-        qualityParamSupported = false;
-      }
-    }
-    canvas.toBlob(resolve2, mimeType);
-  });
-  if (!blob) {
-    throw new Error("image encoding failed");
-  }
-  return await blob.arrayBuffer();
-}
-function drawImageToCanvas(image, canvas, x = 0, y = 0) {
-  if (x === 0 && y === 0 && typeof ImageBitmap !== "undefined" && image instanceof ImageBitmap) {
-    const context2 = canvas.getContext("bitmaprenderer");
-    if (context2) {
-      context2.transferFromImageBitmap(image);
-      return canvas;
+var CompressedTextureLoader = {
+  ...CompressedTextureWorkerLoader,
+  parse: async (arrayBuffer, options) => {
+    if (options["compressed-texture"].useBasis) {
+      options.basis = {
+        format: {
+          alpha: "BC3",
+          noAlpha: "BC1"
+        },
+        ...options.basis,
+        containerFormat: "ktx2",
+        module: "encoder"
+      };
+      return (await parseBasis(arrayBuffer, options))[0];
     }
+    return parseCompressedTexture(arrayBuffer);
   }
-  const context = canvas.getContext("2d");
-  if (image.data) {
-    const clampedArray = new Uint8ClampedArray(image.data);
-    const imageData = new ImageData(clampedArray, image.width, image.height);
-    context.putImageData(imageData, 0, 0);
-    return canvas;
-  }
-  context.drawImage(image, 0, 0);
-  return canvas;
-}
-
-// ../images/src/image-writer.ts
-var ImageWriter = {
-  name: "Images",
-  id: "image",
-  module: "images",
-  version: VERSION11,
-  extensions: ["jpeg"],
-  options: {
-    image: {
-      mimeType: "image/png",
-      jpegQuality: null
-    }
-  },
-  encode: encodeImage
 };
 
-// ../images/src/lib/category-api/image-format.ts
-var mimeTypeSupportedSync = {};
-function isImageFormatSupported(mimeType) {
-  if (mimeTypeSupportedSync[mimeType] === void 0) {
-    const supported = isBrowser ? checkBrowserImageFormatSupport(mimeType) : checkNodeImageFormatSupport(mimeType);
-    mimeTypeSupportedSync[mimeType] = supported;
-  }
-  return mimeTypeSupportedSync[mimeType];
-}
-function checkNodeImageFormatSupport(mimeType) {
-  const NODE_FORMAT_SUPPORT = ["image/png", "image/jpeg", "image/gif"];
-  const { _parseImageNode: _parseImageNode2, _imageFormatsNode = NODE_FORMAT_SUPPORT } = globalThis;
-  return Boolean(_parseImageNode2) && _imageFormatsNode.includes(mimeType);
-}
-function checkBrowserImageFormatSupport(mimeType) {
-  switch (mimeType) {
-    case "image/avif":
-    case "image/webp":
-      return testBrowserImageFormatSupport(mimeType);
-    default:
-      return true;
-  }
-}
-function testBrowserImageFormatSupport(mimeType) {
-  try {
-    const element = document.createElement("canvas");
-    const dataURL = element.toDataURL(mimeType);
-    return dataURL.indexOf(`data:${mimeType}`) === 0;
-  } catch {
-    return false;
-  }
-}
-
 // ../textures/src/index.ts
 var KTX2BasisWriterWorker = {
   name: "Basis Universal Supercompressed GPU Texture",
-  id: isBrowser ? "ktx2-basis-writer" : "ktx2-basis-writer-nodejs",
+  id: "ktx2-basis-writer",
   module: "textures",
-  version: VERSION9,
+  version: VERSION10,
   extensions: ["ktx2"],
   worker: true,
   options: {
@@ -54590,6 +54796,113 @@ function assert6(condition, message) {
   }
 }
 
+// ../gltf/src/lib/parsers/parse-glb.ts
+var LITTLE_ENDIAN2 = true;
+var MAGIC_glTF = 1735152710;
+var GLB_FILE_HEADER_SIZE = 12;
+var GLB_CHUNK_HEADER_SIZE = 8;
+var GLB_CHUNK_TYPE_JSON = 1313821514;
+var GLB_CHUNK_TYPE_BIN = 5130562;
+var GLB_V1_CONTENT_FORMAT_JSON = 0;
+var GLB_CHUNK_TYPE_JSON_XVIZ_DEPRECATED = 0;
+var GLB_CHUNK_TYPE_BIX_XVIZ_DEPRECATED = 1;
+function getMagicString4(dataView, byteOffset = 0) {
+  return `${String.fromCharCode(dataView.getUint8(byteOffset + 0))}${String.fromCharCode(dataView.getUint8(byteOffset + 1))}${String.fromCharCode(dataView.getUint8(byteOffset + 2))}${String.fromCharCode(dataView.getUint8(byteOffset + 3))}`;
+}
+function isGLB(arrayBuffer, byteOffset = 0, options = {}) {
+  const dataView = new DataView(arrayBuffer);
+  const { magic = MAGIC_glTF } = options;
+  const magic1 = dataView.getUint32(byteOffset, false);
+  return magic1 === magic || magic1 === MAGIC_glTF;
+}
+function parseGLBSync(glb, arrayBuffer, byteOffset = 0, options = {}) {
+  const dataView = new DataView(arrayBuffer);
+  const type = getMagicString4(dataView, byteOffset + 0);
+  const version2 = dataView.getUint32(byteOffset + 4, LITTLE_ENDIAN2);
+  const byteLength = dataView.getUint32(byteOffset + 8, LITTLE_ENDIAN2);
+  Object.assign(glb, {
+    header: {
+      byteOffset,
+      byteLength,
+      hasBinChunk: false
+    },
+    type,
+    version: version2,
+    json: {},
+    binChunks: []
+  });
+  byteOffset += GLB_FILE_HEADER_SIZE;
+  switch (glb.version) {
+    case 1:
+      return parseGLBV1(glb, dataView, byteOffset);
+    case 2:
+      return parseGLBV2(glb, dataView, byteOffset, options = {});
+    default:
+      throw new Error(`Invalid GLB version ${glb.version}. Only supports version 1 and 2.`);
+  }
+}
+function parseGLBV1(glb, dataView, byteOffset) {
+  assert2(glb.header.byteLength > GLB_FILE_HEADER_SIZE + GLB_CHUNK_HEADER_SIZE);
+  const contentLength = dataView.getUint32(byteOffset + 0, LITTLE_ENDIAN2);
+  const contentFormat = dataView.getUint32(byteOffset + 4, LITTLE_ENDIAN2);
+  byteOffset += GLB_CHUNK_HEADER_SIZE;
+  assert2(contentFormat === GLB_V1_CONTENT_FORMAT_JSON);
+  parseJSONChunk(glb, dataView, byteOffset, contentLength);
+  byteOffset += contentLength;
+  byteOffset += parseBINChunk(glb, dataView, byteOffset, glb.header.byteLength);
+  return byteOffset;
+}
+function parseGLBV2(glb, dataView, byteOffset, options) {
+  assert2(glb.header.byteLength > GLB_FILE_HEADER_SIZE + GLB_CHUNK_HEADER_SIZE);
+  parseGLBChunksSync(glb, dataView, byteOffset, options);
+  return byteOffset + glb.header.byteLength;
+}
+function parseGLBChunksSync(glb, dataView, byteOffset, options) {
+  while (byteOffset + 8 <= glb.header.byteLength) {
+    const chunkLength = dataView.getUint32(byteOffset + 0, LITTLE_ENDIAN2);
+    const chunkFormat = dataView.getUint32(byteOffset + 4, LITTLE_ENDIAN2);
+    byteOffset += GLB_CHUNK_HEADER_SIZE;
+    switch (chunkFormat) {
+      case GLB_CHUNK_TYPE_JSON:
+        parseJSONChunk(glb, dataView, byteOffset, chunkLength);
+        break;
+      case GLB_CHUNK_TYPE_BIN:
+        parseBINChunk(glb, dataView, byteOffset, chunkLength);
+        break;
+      case GLB_CHUNK_TYPE_JSON_XVIZ_DEPRECATED:
+        if (!options.strict) {
+          parseJSONChunk(glb, dataView, byteOffset, chunkLength);
+        }
+        break;
+      case GLB_CHUNK_TYPE_BIX_XVIZ_DEPRECATED:
+        if (!options.strict) {
+          parseBINChunk(glb, dataView, byteOffset, chunkLength);
+        }
+        break;
+      default:
+        break;
+    }
+    byteOffset += padToNBytes(chunkLength, 4);
+  }
+  return byteOffset;
+}
+function parseJSONChunk(glb, dataView, byteOffset, chunkLength) {
+  const jsonChunk = new Uint8Array(dataView.buffer, byteOffset, chunkLength);
+  const textDecoder = new TextDecoder("utf8");
+  const jsonText = textDecoder.decode(jsonChunk);
+  glb.json = JSON.parse(jsonText);
+  return padToNBytes(chunkLength, 4);
+}
+function parseBINChunk(glb, dataView, byteOffset, chunkLength) {
+  glb.header.hasBinChunk = true;
+  glb.binChunks.push({
+    byteOffset,
+    byteLength: chunkLength,
+    arrayBuffer: dataView.buffer
+  });
+  return padToNBytes(chunkLength, 4);
+}
+
 // ../gltf/src/lib/gltf-utils/resolve-url.ts
 function resolveUrl(url, options) {
   const absolute = url.startsWith("data:") || url.startsWith("http:") || url.startsWith("https:");
@@ -54622,6 +54935,7 @@ __export(EXT_meshopt_compression_exports, {
 });
 
 // ../gltf/src/lib/gltf-utils/gltf-utils.ts
+var MIPMAP_FACTOR = 1.33;
 var TYPES = ["SCALAR", "VEC2", "VEC3", "VEC4"];
 var ARRAY_CONSTRUCTOR_TO_WEBGL_CONSTANT = [
   [Int8Array, 5120],
@@ -54678,20 +54992,38 @@ function getAccessorArrayTypeAndLength(accessor, bufferView) {
   assert6(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 * MIPMAP_FACTOR);
+}
 
 // ../gltf/src/lib/api/gltf-scenegraph.ts
-var DEFAULT_GLTF_JSON = {
-  asset: {
-    version: "2.0",
-    generator: "loaders.gl"
-  },
-  buffers: []
-};
+function makeDefaultGLTFJson() {
+  return {
+    asset: {
+      version: "2.0",
+      generator: "loaders.gl"
+    },
+    buffers: [],
+    extensions: {},
+    extensionsRequired: [],
+    extensionsUsed: []
+  };
+}
 var GLTFScenegraph = class {
   constructor(gltf) {
-    this.gltf = gltf || {
-      json: { ...DEFAULT_GLTF_JSON },
-      buffers: []
+    this.gltf = {
+      json: gltf?.json || makeDefaultGLTFJson(),
+      buffers: gltf?.buffers || []
     };
     this.sourceBuffers = [];
     this.byteLength = 0;
@@ -54711,10 +55043,15 @@ var GLTFScenegraph = class {
     const extras = this.json.extras || {};
     return extras[key];
   }
+  hasExtension(extensionName) {
+    const isUsedExtension = this.getUsedExtensions().find((name10) => name10 === extensionName);
+    const isRequiredExtension = this.getRequiredExtensions().find((name10) => name10 === extensionName);
+    return typeof isUsedExtension === "string" || typeof isRequiredExtension === "string";
+  }
   getExtension(extensionName) {
     const isExtension = this.getUsedExtensions().find((name10) => name10 === extensionName);
     const extensions = this.json.extensions || {};
-    return isExtension ? extensions[extensionName] || true : null;
+    return isExtension ? extensions[extensionName] : null;
   }
   getRequiredExtension(extensionName) {
     const isRequired = this.getRequiredExtensions().find((name10) => name10 === extensionName);
@@ -54821,10 +55158,15 @@ var GLTFScenegraph = class {
     extensions[extensionName] = data;
   }
   removeObjectExtension(object, extensionName) {
-    const extensions = object.extensions || {};
-    const extension = extensions[extensionName];
+    const extensions = object?.extensions || {};
+    if (extensions[extensionName]) {
+      this.json.extensionsRemoved = this.json.extensionsRemoved || [];
+      const extensionsRemoved = this.json.extensionsRemoved;
+      if (!extensionsRemoved.includes(extensionName)) {
+        extensionsRemoved.push(extensionName);
+      }
+    }
     delete extensions[extensionName];
-    return extension;
   }
   addExtension(extensionName, extensionData = {}) {
     assert6(extensionData);
@@ -54853,8 +55195,15 @@ var GLTFScenegraph = class {
     }
   }
   removeExtension(extensionName) {
-    if (!this.getExtension(extensionName)) {
-      return;
+    if (this.json.extensions?.[extensionName]) {
+      this.json.extensionsRemoved = this.json.extensionsRemoved || [];
+      const extensionsRemoved = this.json.extensionsRemoved;
+      if (!extensionsRemoved.includes(extensionName)) {
+        extensionsRemoved.push(extensionName);
+      }
+    }
+    if (this.json.extensions) {
+      delete this.json.extensions[extensionName];
     }
     if (this.json.extensionsRequired) {
       this._removeStringFromArray(this.json.extensionsRequired, extensionName);
@@ -54862,16 +55211,6 @@ var GLTFScenegraph = class {
     if (this.json.extensionsUsed) {
       this._removeStringFromArray(this.json.extensionsUsed, extensionName);
     }
-    if (this.json.extensions) {
-      delete this.json.extensions[extensionName];
-    }
-    if (!Array.isArray(this.json.extensionsRemoved)) {
-      this.json.extensionsRemoved = [];
-    }
-    const extensionsRemoved = this.json.extensionsRemoved;
-    if (!extensionsRemoved.includes(extensionName)) {
-      extensionsRemoved.push(extensionName);
-    }
   }
   setDefaultScene(sceneIndex) {
     this.json.scene = sceneIndex;
@@ -55297,9 +55636,8 @@ async function decodeMeshoptBufferView(scenegraph, bufferView) {
     const source = new Uint8Array(buffer.arrayBuffer, buffer.byteOffset + byteOffset, byteLength);
     const result = new Uint8Array(scenegraph.gltf.buffers[bufferView.buffer].arrayBuffer, bufferView.byteOffset, bufferView.byteLength);
     await meshoptDecodeGltfBuffer(result, count, byteStride, source, mode, filter);
-    return result;
+    scenegraph.removeObjectExtension(bufferView, EXT_MESHOPT_COMPRESSION);
   }
-  return null;
 }
 
 // ../gltf/src/lib/extensions/EXT_texture_webp.ts
@@ -55344,8 +55682,8 @@ function preprocess2(gltfData, options) {
     const extension = scene.getObjectExtension(texture, KHR_TEXTURE_BASISU);
     if (extension) {
       texture.source = extension.source;
+      scene.removeObjectExtension(texture, KHR_TEXTURE_BASISU);
     }
-    scene.removeObjectExtension(texture, KHR_TEXTURE_BASISU);
   }
   scene.removeExtension(KHR_TEXTURE_BASISU);
 }
@@ -55469,6 +55807,7 @@ async function decompressPrimitive(scenegraph, primitive, options, context) {
   if (decodedData.indices) {
     primitive.indices = getGLTFAccessor(decodedData.indices);
   }
+  scenegraph.removeObjectExtension(primitive, KHR_DRACO_MESH_COMPRESSION);
   checkPrimitive(primitive);
 }
 function compressMesh(attributes, indices, mode = 4, options, context) {
@@ -55543,8 +55882,8 @@ var scratchRotationMatrix = new import_core15.Matrix3();
 var scratchScaleMatrix = new import_core15.Matrix3();
 async function decode4(gltfData, options) {
   const gltfScenegraph = new GLTFScenegraph(gltfData);
-  const extension = gltfScenegraph.getExtension(EXT_MESHOPT_TRANSFORM);
-  if (!extension) {
+  const hasExtension = gltfScenegraph.hasExtension(EXT_MESHOPT_TRANSFORM);
+  if (!hasExtension) {
     return;
   }
   const materials = gltfData.json.materials || [];
@@ -55678,10 +56017,10 @@ function createAttribute(newTexCoord, originalAccessor, primitive, gltfData, new
 }
 function makeTransformationMatrix(extensionData) {
   const { offset = [0, 0], rotation = 0, scale = [1, 1] } = extensionData;
-  const translationMatirx = new import_core15.Matrix3().set(1, 0, 0, 0, 1, 0, offset[0], offset[1], 1);
-  const rotationMatirx = scratchRotationMatrix.set(Math.cos(rotation), Math.sin(rotation), 0, -Math.sin(rotation), Math.cos(rotation), 0, 0, 0, 1);
+  const translationMatrix = new import_core15.Matrix3().set(1, 0, 0, 0, 1, 0, offset[0], offset[1], 1);
+  const rotationMatrix = scratchRotationMatrix.set(Math.cos(rotation), Math.sin(rotation), 0, -Math.sin(rotation), Math.cos(rotation), 0, 0, 0, 1);
   const scaleMatrix = scratchScaleMatrix.set(scale[0], 0, 0, 0, scale[1], 0, 0, 0, 1);
-  return translationMatirx.multiplyRight(rotationMatirx).multiplyRight(scaleMatrix);
+  return translationMatrix.multiplyRight(rotationMatrix).multiplyRight(scaleMatrix);
 }
 
 // ../gltf/src/lib/extensions/deprecated/KHR_lights_punctual.ts
@@ -56145,428 +56484,6 @@ function normalizeGLTFV1(gltf, options = {}) {
   return new GLTFV1Normalizer().normalize(gltf, options);
 }
 
-// ../gltf/src/lib/api/post-process-gltf.ts
-var COMPONENTS2 = {
-  SCALAR: 1,
-  VEC2: 2,
-  VEC3: 3,
-  VEC4: 4,
-  MAT2: 4,
-  MAT3: 9,
-  MAT4: 16
-};
-var BYTES2 = {
-  5120: 1,
-  5121: 1,
-  5122: 2,
-  5123: 2,
-  5125: 4,
-  5126: 4
-};
-var GL_SAMPLER = {
-  TEXTURE_MAG_FILTER: 10240,
-  TEXTURE_MIN_FILTER: 10241,
-  TEXTURE_WRAP_S: 10242,
-  TEXTURE_WRAP_T: 10243,
-  REPEAT: 10497,
-  LINEAR: 9729,
-  NEAREST_MIPMAP_LINEAR: 9986
-};
-var SAMPLER_PARAMETER_GLTF_TO_GL = {
-  magFilter: GL_SAMPLER.TEXTURE_MAG_FILTER,
-  minFilter: GL_SAMPLER.TEXTURE_MIN_FILTER,
-  wrapS: GL_SAMPLER.TEXTURE_WRAP_S,
-  wrapT: GL_SAMPLER.TEXTURE_WRAP_T
-};
-var DEFAULT_SAMPLER = {
-  [GL_SAMPLER.TEXTURE_MAG_FILTER]: GL_SAMPLER.LINEAR,
-  [GL_SAMPLER.TEXTURE_MIN_FILTER]: GL_SAMPLER.NEAREST_MIPMAP_LINEAR,
-  [GL_SAMPLER.TEXTURE_WRAP_S]: GL_SAMPLER.REPEAT,
-  [GL_SAMPLER.TEXTURE_WRAP_T]: GL_SAMPLER.REPEAT
-};
-function getBytesFromComponentType(componentType) {
-  return BYTES2[componentType];
-}
-function getSizeFromAccessorType(type) {
-  return COMPONENTS2[type];
-}
-var GLTFPostProcessor = class {
-  constructor() {
-    this.baseUri = "";
-    this.json = {};
-    this.buffers = [];
-    this.images = [];
-  }
-  postProcess(gltf, options = {}) {
-    const { json, buffers = [], images = [], baseUri = "" } = gltf;
-    assert6(json);
-    this.baseUri = baseUri;
-    this.json = json;
-    this.buffers = buffers;
-    this.images = images;
-    this._resolveTree(this.json, options);
-    return this.json;
-  }
-  _resolveTree(json, options = {}) {
-    if (json.bufferViews) {
-      json.bufferViews = json.bufferViews.map((bufView, i) => this._resolveBufferView(bufView, i));
-    }
-    if (json.images) {
-      json.images = json.images.map((image, i) => this._resolveImage(image, i));
-    }
-    if (json.samplers) {
-      json.samplers = json.samplers.map((sampler, i) => this._resolveSampler(sampler, i));
-    }
-    if (json.textures) {
-      json.textures = json.textures.map((texture, i) => this._resolveTexture(texture, i));
-    }
-    if (json.accessors) {
-      json.accessors = json.accessors.map((accessor, i) => this._resolveAccessor(accessor, i));
-    }
-    if (json.materials) {
-      json.materials = json.materials.map((material, i) => this._resolveMaterial(material, i));
-    }
-    if (json.meshes) {
-      json.meshes = json.meshes.map((mesh, i) => this._resolveMesh(mesh, i));
-    }
-    if (json.nodes) {
-      json.nodes = json.nodes.map((node2, i) => this._resolveNode(node2, i));
-    }
-    if (json.skins) {
-      json.skins = json.skins.map((skin, i) => this._resolveSkin(skin, i));
-    }
-    if (json.scenes) {
-      json.scenes = json.scenes.map((scene, i) => this._resolveScene(scene, i));
-    }
-    if (json.scene !== void 0) {
-      json.scene = json.scenes[this.json.scene];
-    }
-  }
-  getScene(index) {
-    return this._get("scenes", index);
-  }
-  getNode(index) {
-    return this._get("nodes", index);
-  }
-  getSkin(index) {
-    return this._get("skins", index);
-  }
-  getMesh(index) {
-    return this._get("meshes", index);
-  }
-  getMaterial(index) {
-    return this._get("materials", index);
-  }
-  getAccessor(index) {
-    return this._get("accessors", index);
-  }
-  getCamera(index) {
-    return null;
-  }
-  getTexture(index) {
-    return this._get("textures", index);
-  }
-  getSampler(index) {
-    return this._get("samplers", index);
-  }
-  getImage(index) {
-    return this._get("images", index);
-  }
-  getBufferView(index) {
-    return this._get("bufferViews", index);
-  }
-  getBuffer(index) {
-    return this._get("buffers", index);
-  }
-  _get(array, index) {
-    if (typeof index === "object") {
-      return index;
-    }
-    const object = this.json[array] && this.json[array][index];
-    if (!object) {
-      console.warn(`glTF file error: Could not find ${array}[${index}]`);
-    }
-    return object;
-  }
-  _resolveScene(scene, index) {
-    scene.id = scene.id || `scene-${index}`;
-    scene.nodes = (scene.nodes || []).map((node2) => this.getNode(node2));
-    return scene;
-  }
-  _resolveNode(node2, index) {
-    node2.id = node2.id || `node-${index}`;
-    if (node2.children) {
-      node2.children = node2.children.map((child) => this.getNode(child));
-    }
-    if (node2.mesh !== void 0) {
-      node2.mesh = this.getMesh(node2.mesh);
-    } else if (node2.meshes !== void 0 && node2.meshes.length) {
-      node2.mesh = node2.meshes.reduce((accum, meshIndex) => {
-        const mesh = this.getMesh(meshIndex);
-        accum.id = mesh.id;
-        accum.primitives = accum.primitives.concat(mesh.primitives);
-        return accum;
-      }, { primitives: [] });
-    }
-    if (node2.camera !== void 0) {
-      node2.camera = this.getCamera(node2.camera);
-    }
-    if (node2.skin !== void 0) {
-      node2.skin = this.getSkin(node2.skin);
-    }
-    return node2;
-  }
-  _resolveSkin(skin, index) {
-    skin.id = skin.id || `skin-${index}`;
-    skin.inverseBindMatrices = this.getAccessor(skin.inverseBindMatrices);
-    return skin;
-  }
-  _resolveMesh(mesh, index) {
-    mesh.id = mesh.id || `mesh-${index}`;
-    if (mesh.primitives) {
-      mesh.primitives = mesh.primitives.map((primitive) => {
-        primitive = { ...primitive };
-        const attributes = primitive.attributes;
-        primitive.attributes = {};
-        for (const attribute in attributes) {
-          primitive.attributes[attribute] = this.getAccessor(attributes[attribute]);
-        }
-        if (primitive.indices !== void 0) {
-          primitive.indices = this.getAccessor(primitive.indices);
-        }
-        if (primitive.material !== void 0) {
-          primitive.material = this.getMaterial(primitive.material);
-        }
-        return primitive;
-      });
-    }
-    return mesh;
-  }
-  _resolveMaterial(material, index) {
-    material.id = material.id || `material-${index}`;
-    if (material.normalTexture) {
-      material.normalTexture = { ...material.normalTexture };
-      material.normalTexture.texture = this.getTexture(material.normalTexture.index);
-    }
-    if (material.occlusionTexture) {
-      material.occlustionTexture = { ...material.occlustionTexture };
-      material.occlusionTexture.texture = this.getTexture(material.occlusionTexture.index);
-    }
-    if (material.emissiveTexture) {
-      material.emmisiveTexture = { ...material.emmisiveTexture };
-      material.emissiveTexture.texture = this.getTexture(material.emissiveTexture.index);
-    }
-    if (!material.emissiveFactor) {
-      material.emissiveFactor = material.emmisiveTexture ? [1, 1, 1] : [0, 0, 0];
-    }
-    if (material.pbrMetallicRoughness) {
-      material.pbrMetallicRoughness = { ...material.pbrMetallicRoughness };
-      const mr = material.pbrMetallicRoughness;
-      if (mr.baseColorTexture) {
-        mr.baseColorTexture = { ...mr.baseColorTexture };
-        mr.baseColorTexture.texture = this.getTexture(mr.baseColorTexture.index);
-      }
-      if (mr.metallicRoughnessTexture) {
-        mr.metallicRoughnessTexture = { ...mr.metallicRoughnessTexture };
-        mr.metallicRoughnessTexture.texture = this.getTexture(mr.metallicRoughnessTexture.index);
-      }
-    }
-    return material;
-  }
-  _resolveAccessor(accessor, index) {
-    accessor.id = accessor.id || `accessor-${index}`;
-    if (accessor.bufferView !== void 0) {
-      accessor.bufferView = this.getBufferView(accessor.bufferView);
-    }
-    accessor.bytesPerComponent = getBytesFromComponentType(accessor.componentType);
-    accessor.components = getSizeFromAccessorType(accessor.type);
-    accessor.bytesPerElement = accessor.bytesPerComponent * accessor.components;
-    if (accessor.bufferView) {
-      const buffer = accessor.bufferView.buffer;
-      const { ArrayType, byteLength } = getAccessorArrayTypeAndLength(accessor, accessor.bufferView);
-      const byteOffset = (accessor.bufferView.byteOffset || 0) + (accessor.byteOffset || 0) + buffer.byteOffset;
-      let cutBuffer = buffer.arrayBuffer.slice(byteOffset, byteOffset + byteLength);
-      if (accessor.bufferView.byteStride) {
-        cutBuffer = this._getValueFromInterleavedBuffer(buffer, byteOffset, accessor.bufferView.byteStride, accessor.bytesPerElement, accessor.count);
-      }
-      accessor.value = new ArrayType(cutBuffer);
-    }
-    return accessor;
-  }
-  _getValueFromInterleavedBuffer(buffer, byteOffset, byteStride, bytesPerElement, count) {
-    const result = new Uint8Array(count * bytesPerElement);
-    for (let i = 0; i < count; i++) {
-      const elementOffset = byteOffset + i * byteStride;
-      result.set(new Uint8Array(buffer.arrayBuffer.slice(elementOffset, elementOffset + bytesPerElement)), i * bytesPerElement);
-    }
-    return result.buffer;
-  }
-  _resolveTexture(texture, index) {
-    texture.id = texture.id || `texture-${index}`;
-    texture.sampler = "sampler" in texture ? this.getSampler(texture.sampler) : DEFAULT_SAMPLER;
-    texture.source = this.getImage(texture.source);
-    return texture;
-  }
-  _resolveSampler(sampler, index) {
-    sampler.id = sampler.id || `sampler-${index}`;
-    sampler.parameters = {};
-    for (const key in sampler) {
-      const glEnum = this._enumSamplerParameter(key);
-      if (glEnum !== void 0) {
-        sampler.parameters[glEnum] = sampler[key];
-      }
-    }
-    return sampler;
-  }
-  _enumSamplerParameter(key) {
-    return SAMPLER_PARAMETER_GLTF_TO_GL[key];
-  }
-  _resolveImage(image, index) {
-    image.id = image.id || `image-${index}`;
-    if (image.bufferView !== void 0) {
-      image.bufferView = this.getBufferView(image.bufferView);
-    }
-    const preloadedImage = this.images[index];
-    if (preloadedImage) {
-      image.image = preloadedImage;
-    }
-    return image;
-  }
-  _resolveBufferView(bufferView, index) {
-    const bufferIndex = bufferView.buffer;
-    const result = {
-      id: `bufferView-${index}`,
-      ...bufferView,
-      buffer: this.buffers[bufferIndex]
-    };
-    const arrayBuffer = this.buffers[bufferIndex].arrayBuffer;
-    let byteOffset = this.buffers[bufferIndex].byteOffset || 0;
-    if ("byteOffset" in bufferView) {
-      byteOffset += bufferView.byteOffset;
-    }
-    result.data = new Uint8Array(arrayBuffer, byteOffset, bufferView.byteLength);
-    return result;
-  }
-  _resolveCamera(camera, index) {
-    camera.id = camera.id || `camera-${index}`;
-    if (camera.perspective) {
-    }
-    if (camera.orthographic) {
-    }
-    return camera;
-  }
-};
-function postProcessGLTF(gltf, options) {
-  return new GLTFPostProcessor().postProcess(gltf, options);
-}
-
-// ../gltf/src/lib/parsers/parse-glb.ts
-var MAGIC_glTF = 1735152710;
-var GLB_FILE_HEADER_SIZE = 12;
-var GLB_CHUNK_HEADER_SIZE = 8;
-var GLB_CHUNK_TYPE_JSON = 1313821514;
-var GLB_CHUNK_TYPE_BIN = 5130562;
-var GLB_CHUNK_TYPE_JSON_XVIZ_DEPRECATED = 0;
-var GLB_CHUNK_TYPE_BIX_XVIZ_DEPRECATED = 1;
-var GLB_V1_CONTENT_FORMAT_JSON = 0;
-var LE = true;
-function getMagicString4(dataView, byteOffset = 0) {
-  return `${String.fromCharCode(dataView.getUint8(byteOffset + 0))}${String.fromCharCode(dataView.getUint8(byteOffset + 1))}${String.fromCharCode(dataView.getUint8(byteOffset + 2))}${String.fromCharCode(dataView.getUint8(byteOffset + 3))}`;
-}
-function isGLB(arrayBuffer, byteOffset = 0, options = {}) {
-  const dataView = new DataView(arrayBuffer);
-  const { magic = MAGIC_glTF } = options;
-  const magic1 = dataView.getUint32(byteOffset, false);
-  return magic1 === magic || magic1 === MAGIC_glTF;
-}
-function parseGLBSync(glb, arrayBuffer, byteOffset = 0, options = {}) {
-  const dataView = new DataView(arrayBuffer);
-  const type = getMagicString4(dataView, byteOffset + 0);
-  const version2 = dataView.getUint32(byteOffset + 4, LE);
-  const byteLength = dataView.getUint32(byteOffset + 8, LE);
-  Object.assign(glb, {
-    header: {
-      byteOffset,
-      byteLength,
-      hasBinChunk: false
-    },
-    type,
-    version: version2,
-    json: {},
-    binChunks: []
-  });
-  byteOffset += GLB_FILE_HEADER_SIZE;
-  switch (glb.version) {
-    case 1:
-      return parseGLBV1(glb, dataView, byteOffset);
-    case 2:
-      return parseGLBV2(glb, dataView, byteOffset, options = {});
-    default:
-      throw new Error(`Invalid GLB version ${glb.version}. Only supports v1 and v2.`);
-  }
-}
-function parseGLBV1(glb, dataView, byteOffset) {
-  assert2(glb.header.byteLength > GLB_FILE_HEADER_SIZE + GLB_CHUNK_HEADER_SIZE);
-  const contentLength = dataView.getUint32(byteOffset + 0, LE);
-  const contentFormat = dataView.getUint32(byteOffset + 4, LE);
-  byteOffset += GLB_CHUNK_HEADER_SIZE;
-  assert2(contentFormat === GLB_V1_CONTENT_FORMAT_JSON);
-  parseJSONChunk(glb, dataView, byteOffset, contentLength);
-  byteOffset += contentLength;
-  byteOffset += parseBINChunk(glb, dataView, byteOffset, glb.header.byteLength);
-  return byteOffset;
-}
-function parseGLBV2(glb, dataView, byteOffset, options) {
-  assert2(glb.header.byteLength > GLB_FILE_HEADER_SIZE + GLB_CHUNK_HEADER_SIZE);
-  parseGLBChunksSync(glb, dataView, byteOffset, options);
-  return byteOffset + glb.header.byteLength;
-}
-function parseGLBChunksSync(glb, dataView, byteOffset, options) {
-  while (byteOffset + 8 <= glb.header.byteLength) {
-    const chunkLength = dataView.getUint32(byteOffset + 0, LE);
-    const chunkFormat = dataView.getUint32(byteOffset + 4, LE);
-    byteOffset += GLB_CHUNK_HEADER_SIZE;
-    switch (chunkFormat) {
-      case GLB_CHUNK_TYPE_JSON:
-        parseJSONChunk(glb, dataView, byteOffset, chunkLength);
-        break;
-      case GLB_CHUNK_TYPE_BIN:
-        parseBINChunk(glb, dataView, byteOffset, chunkLength);
-        break;
-      case GLB_CHUNK_TYPE_JSON_XVIZ_DEPRECATED:
-        if (!options.strict) {
-          parseJSONChunk(glb, dataView, byteOffset, chunkLength);
-        }
-        break;
-      case GLB_CHUNK_TYPE_BIX_XVIZ_DEPRECATED:
-        if (!options.strict) {
-          parseBINChunk(glb, dataView, byteOffset, chunkLength);
-        }
-        break;
-      default:
-        break;
-    }
-    byteOffset += padToNBytes(chunkLength, 4);
-  }
-  return byteOffset;
-}
-function parseJSONChunk(glb, dataView, byteOffset, chunkLength) {
-  const jsonChunk = new Uint8Array(dataView.buffer, byteOffset, chunkLength);
-  const textDecoder = new TextDecoder("utf8");
-  const jsonText = textDecoder.decode(jsonChunk);
-  glb.json = JSON.parse(jsonText);
-  return padToNBytes(chunkLength, 4);
-}
-function parseBINChunk(glb, dataView, byteOffset, chunkLength) {
-  glb.header.hasBinChunk = true;
-  glb.binChunks.push({
-    byteOffset,
-    byteLength: chunkLength,
-    arrayBuffer: dataView.buffer
-  });
-  return padToNBytes(chunkLength, 4);
-}
-
 // ../gltf/src/lib/parsers/parse-gltf.ts
 async function parseGLTF(gltf, arrayBufferOrString, byteOffset = 0, options, context) {
   parseGLTFContainerSync(gltf, arrayBufferOrString, byteOffset, options);
@@ -56583,7 +56500,7 @@ async function parseGLTF(gltf, arrayBufferOrString, byteOffset = 0, options, con
   const promise = decodeExtensions(gltf, options, context);
   promises.push(promise);
   await Promise.all(promises);
-  return options?.gltf?.postProcess ? postProcessGLTF(gltf, options) : gltf;
+  return gltf;
 }
 function parseGLTFContainerSync(gltf, data, byteOffset, options) {
   if (options.uri) {
@@ -56708,8 +56625,7 @@ var GLTFLoader = {
       normalize: true,
       loadBuffers: true,
       loadImages: true,
-      decompressMeshes: true,
-      postProcess: true
+      decompressMeshes: true
     },
     log: console
   },
@@ -56719,7 +56635,8 @@ var GLTFLoader = {
     decompress: "gltf.decompressMeshes",
     postProcess: "gltf.postProcess",
     gltf: {
-      decompress: "gltf.decompressMeshes"
+      decompress: "gltf.decompressMeshes",
+      postProcess: "removed in v4"
     }
   }
 };
@@ -56731,6 +56648,373 @@ async function parse3(arrayBuffer, options = {}, context) {
   return await parseGLTF(gltf, arrayBuffer, byteOffset, options, context);
 }
 
+// ../gltf/src/lib/api/post-process-gltf.ts
+var COMPONENTS2 = {
+  SCALAR: 1,
+  VEC2: 2,
+  VEC3: 3,
+  VEC4: 4,
+  MAT2: 4,
+  MAT3: 9,
+  MAT4: 16
+};
+var BYTES2 = {
+  5120: 1,
+  5121: 1,
+  5122: 2,
+  5123: 2,
+  5125: 4,
+  5126: 4
+};
+var GL_SAMPLER = {
+  TEXTURE_MAG_FILTER: 10240,
+  TEXTURE_MIN_FILTER: 10241,
+  TEXTURE_WRAP_S: 10242,
+  TEXTURE_WRAP_T: 10243,
+  REPEAT: 10497,
+  LINEAR: 9729,
+  NEAREST_MIPMAP_LINEAR: 9986
+};
+var SAMPLER_PARAMETER_GLTF_TO_GL = {
+  magFilter: GL_SAMPLER.TEXTURE_MAG_FILTER,
+  minFilter: GL_SAMPLER.TEXTURE_MIN_FILTER,
+  wrapS: GL_SAMPLER.TEXTURE_WRAP_S,
+  wrapT: GL_SAMPLER.TEXTURE_WRAP_T
+};
+var DEFAULT_SAMPLER_PARAMETERS = {
+  [GL_SAMPLER.TEXTURE_MAG_FILTER]: GL_SAMPLER.LINEAR,
+  [GL_SAMPLER.TEXTURE_MIN_FILTER]: GL_SAMPLER.NEAREST_MIPMAP_LINEAR,
+  [GL_SAMPLER.TEXTURE_WRAP_S]: GL_SAMPLER.REPEAT,
+  [GL_SAMPLER.TEXTURE_WRAP_T]: GL_SAMPLER.REPEAT
+};
+function makeDefaultSampler() {
+  return {
+    id: "default-sampler",
+    parameters: DEFAULT_SAMPLER_PARAMETERS
+  };
+}
+function getBytesFromComponentType(componentType) {
+  return BYTES2[componentType];
+}
+function getSizeFromAccessorType(type) {
+  return COMPONENTS2[type];
+}
+var GLTFPostProcessor = class {
+  constructor() {
+    this.baseUri = "";
+    this.buffers = [];
+    this.images = [];
+  }
+  postProcess(gltf, options = {}) {
+    const { json, buffers = [], images = [] } = gltf;
+    const { baseUri = "" } = gltf;
+    assert6(json);
+    this.baseUri = baseUri;
+    this.buffers = buffers;
+    this.images = images;
+    this.jsonUnprocessed = json;
+    this.json = this._resolveTree(gltf.json, options);
+    return this.json;
+  }
+  _resolveTree(gltf, options = {}) {
+    const json = { ...gltf };
+    this.json = json;
+    if (gltf.bufferViews) {
+      json.bufferViews = gltf.bufferViews.map((bufView, i) => this._resolveBufferView(bufView, i));
+    }
+    if (gltf.images) {
+      json.images = gltf.images.map((image, i) => this._resolveImage(image, i));
+    }
+    if (gltf.samplers) {
+      json.samplers = gltf.samplers.map((sampler, i) => this._resolveSampler(sampler, i));
+    }
+    if (gltf.textures) {
+      json.textures = gltf.textures.map((texture, i) => this._resolveTexture(texture, i));
+    }
+    if (gltf.accessors) {
+      json.accessors = gltf.accessors.map((accessor, i) => this._resolveAccessor(accessor, i));
+    }
+    if (gltf.materials) {
+      json.materials = gltf.materials.map((material, i) => this._resolveMaterial(material, i));
+    }
+    if (gltf.meshes) {
+      json.meshes = gltf.meshes.map((mesh, i) => this._resolveMesh(mesh, i));
+    }
+    if (gltf.nodes) {
+      json.nodes = gltf.nodes.map((node2, i) => this._resolveNode(node2, i));
+      json.nodes = json.nodes.map((node2, i) => this._resolveNodeChildren(node2));
+    }
+    if (gltf.skins) {
+      json.skins = gltf.skins.map((skin, i) => this._resolveSkin(skin, i));
+    }
+    if (gltf.scenes) {
+      json.scenes = gltf.scenes.map((scene, i) => this._resolveScene(scene, i));
+    }
+    if (typeof this.json.scene === "number" && json.scenes) {
+      json.scene = json.scenes[this.json.scene];
+    }
+    return json;
+  }
+  getScene(index) {
+    return this._get(this.json.scenes, index);
+  }
+  getNode(index) {
+    return this._get(this.json.nodes, index);
+  }
+  getSkin(index) {
+    return this._get(this.json.skins, index);
+  }
+  getMesh(index) {
+    return this._get(this.json.meshes, index);
+  }
+  getMaterial(index) {
+    return this._get(this.json.materials, index);
+  }
+  getAccessor(index) {
+    return this._get(this.json.accessors, index);
+  }
+  getCamera(index) {
+    return this._get(this.json.cameras, index);
+  }
+  getTexture(index) {
+    return this._get(this.json.textures, index);
+  }
+  getSampler(index) {
+    return this._get(this.json.samplers, index);
+  }
+  getImage(index) {
+    return this._get(this.json.images, index);
+  }
+  getBufferView(index) {
+    return this._get(this.json.bufferViews, index);
+  }
+  getBuffer(index) {
+    return this._get(this.json.buffers, index);
+  }
+  _get(array, index) {
+    if (typeof index === "object") {
+      return index;
+    }
+    const object = array && array[index];
+    if (!object) {
+      console.warn(`glTF file error: Could not find ${array}[${index}]`);
+    }
+    return object;
+  }
+  _resolveScene(scene, index) {
+    return {
+      ...scene,
+      id: scene.id || `scene-${index}`,
+      nodes: (scene.nodes || []).map((node2) => this.getNode(node2))
+    };
+  }
+  _resolveNode(gltfNode, index) {
+    const node2 = {
+      ...gltfNode,
+      id: gltfNode?.id || `node-${index}`
+    };
+    if (gltfNode.mesh !== void 0) {
+      node2.mesh = this.getMesh(gltfNode.mesh);
+    }
+    if (gltfNode.camera !== void 0) {
+      node2.camera = this.getCamera(gltfNode.camera);
+    }
+    if (gltfNode.skin !== void 0) {
+      node2.skin = this.getSkin(gltfNode.skin);
+    }
+    if (gltfNode.meshes !== void 0 && gltfNode.meshes.length) {
+      node2.mesh = gltfNode.meshes.reduce((accum, meshIndex) => {
+        const mesh = this.getMesh(meshIndex);
+        accum.id = mesh.id;
+        accum.primitives = accum.primitives.concat(mesh.primitives);
+        return accum;
+      }, { primitives: [] });
+    }
+    return node2;
+  }
+  _resolveNodeChildren(node2) {
+    if (node2.children) {
+      node2.children = node2.children.map((child) => this.getNode(child));
+    }
+    return node2;
+  }
+  _resolveSkin(gltfSkin, index) {
+    const inverseBindMatrices = typeof gltfSkin.inverseBindMatrices === "number" ? this.getAccessor(gltfSkin.inverseBindMatrices) : void 0;
+    return {
+      ...gltfSkin,
+      id: gltfSkin.id || `skin-${index}`,
+      inverseBindMatrices
+    };
+  }
+  _resolveMesh(gltfMesh, index) {
+    const mesh = {
+      ...gltfMesh,
+      id: gltfMesh.id || `mesh-${index}`,
+      primitives: []
+    };
+    if (gltfMesh.primitives) {
+      mesh.primitives = gltfMesh.primitives.map((gltfPrimitive) => {
+        const primitive = {
+          ...gltfPrimitive,
+          attributes: {},
+          indices: void 0,
+          material: void 0
+        };
+        const attributes = gltfPrimitive.attributes;
+        for (const attribute in attributes) {
+          primitive.attributes[attribute] = this.getAccessor(attributes[attribute]);
+        }
+        if (gltfPrimitive.indices !== void 0) {
+          primitive.indices = this.getAccessor(gltfPrimitive.indices);
+        }
+        if (gltfPrimitive.material !== void 0) {
+          primitive.material = this.getMaterial(gltfPrimitive.material);
+        }
+        return primitive;
+      });
+    }
+    return mesh;
+  }
+  _resolveMaterial(gltfMaterial, index) {
+    const material = {
+      ...gltfMaterial,
+      id: gltfMaterial.id || `material-${index}`
+    };
+    if (material.normalTexture) {
+      material.normalTexture = { ...material.normalTexture };
+      material.normalTexture.texture = this.getTexture(material.normalTexture.index);
+    }
+    if (material.occlusionTexture) {
+      material.occlusionTexture = { ...material.occlusionTexture };
+      material.occlusionTexture.texture = this.getTexture(material.occlusionTexture.index);
+    }
+    if (material.emissiveTexture) {
+      material.emissiveTexture = { ...material.emissiveTexture };
+      material.emissiveTexture.texture = this.getTexture(material.emissiveTexture.index);
+    }
+    if (!material.emissiveFactor) {
+      material.emissiveFactor = material.emissiveTexture ? [1, 1, 1] : [0, 0, 0];
+    }
+    if (material.pbrMetallicRoughness) {
+      material.pbrMetallicRoughness = { ...material.pbrMetallicRoughness };
+      const mr = material.pbrMetallicRoughness;
+      if (mr.baseColorTexture) {
+        mr.baseColorTexture = { ...mr.baseColorTexture };
+        mr.baseColorTexture.texture = this.getTexture(mr.baseColorTexture.index);
+      }
+      if (mr.metallicRoughnessTexture) {
+        mr.metallicRoughnessTexture = { ...mr.metallicRoughnessTexture };
+        mr.metallicRoughnessTexture.texture = this.getTexture(mr.metallicRoughnessTexture.index);
+      }
+    }
+    return material;
+  }
+  _resolveAccessor(gltfAccessor, index) {
+    const bytesPerComponent = getBytesFromComponentType(gltfAccessor.componentType);
+    const components = getSizeFromAccessorType(gltfAccessor.type);
+    const bytesPerElement = bytesPerComponent * components;
+    const accessor = {
+      ...gltfAccessor,
+      id: gltfAccessor.id || `accessor-${index}`,
+      bytesPerComponent,
+      components,
+      bytesPerElement,
+      value: void 0,
+      bufferView: void 0,
+      sparse: void 0
+    };
+    if (gltfAccessor.bufferView !== void 0) {
+      accessor.bufferView = this.getBufferView(gltfAccessor.bufferView);
+    }
+    if (accessor.bufferView) {
+      const buffer = accessor.bufferView.buffer;
+      const { ArrayType, byteLength } = getAccessorArrayTypeAndLength(accessor, accessor.bufferView);
+      const byteOffset = (accessor.bufferView.byteOffset || 0) + (accessor.byteOffset || 0) + buffer.byteOffset;
+      let cutBuffer = buffer.arrayBuffer.slice(byteOffset, byteOffset + byteLength);
+      if (accessor.bufferView.byteStride) {
+        cutBuffer = this._getValueFromInterleavedBuffer(buffer, byteOffset, accessor.bufferView.byteStride, accessor.bytesPerElement, accessor.count);
+      }
+      accessor.value = new ArrayType(cutBuffer);
+    }
+    return accessor;
+  }
+  _getValueFromInterleavedBuffer(buffer, byteOffset, byteStride, bytesPerElement, count) {
+    const result = new Uint8Array(count * bytesPerElement);
+    for (let i = 0; i < count; i++) {
+      const elementOffset = byteOffset + i * byteStride;
+      result.set(new Uint8Array(buffer.arrayBuffer.slice(elementOffset, elementOffset + bytesPerElement)), i * bytesPerElement);
+    }
+    return result.buffer;
+  }
+  _resolveTexture(gltfTexture, index) {
+    return {
+      ...gltfTexture,
+      id: gltfTexture.id || `texture-${index}`,
+      sampler: typeof gltfTexture.sampler === "number" ? this.getSampler(gltfTexture.sampler) : makeDefaultSampler(),
+      source: typeof gltfTexture.source === "number" ? this.getImage(gltfTexture.source) : void 0
+    };
+  }
+  _resolveSampler(gltfSampler, index) {
+    const sampler = {
+      id: gltfSampler.id || `sampler-${index}`,
+      ...gltfSampler,
+      parameters: {}
+    };
+    for (const key in sampler) {
+      const glEnum = this._enumSamplerParameter(key);
+      if (glEnum !== void 0) {
+        sampler.parameters[glEnum] = sampler[key];
+      }
+    }
+    return sampler;
+  }
+  _enumSamplerParameter(key) {
+    return SAMPLER_PARAMETER_GLTF_TO_GL[key];
+  }
+  _resolveImage(gltfImage, index) {
+    const image = {
+      ...gltfImage,
+      id: gltfImage.id || `image-${index}`,
+      image: null,
+      bufferView: gltfImage.bufferView !== void 0 ? this.getBufferView(gltfImage.bufferView) : void 0
+    };
+    const preloadedImage = this.images[index];
+    if (preloadedImage) {
+      image.image = preloadedImage;
+    }
+    return image;
+  }
+  _resolveBufferView(gltfBufferView, index) {
+    const bufferIndex = gltfBufferView.buffer;
+    const arrayBuffer = this.buffers[bufferIndex].arrayBuffer;
+    let byteOffset = this.buffers[bufferIndex].byteOffset || 0;
+    if (gltfBufferView.byteOffset) {
+      byteOffset += gltfBufferView.byteOffset;
+    }
+    const bufferView = {
+      id: `bufferView-${index}`,
+      ...gltfBufferView,
+      buffer: this.buffers[bufferIndex],
+      data: new Uint8Array(arrayBuffer, byteOffset, gltfBufferView.byteLength)
+    };
+    return bufferView;
+  }
+  _resolveCamera(gltfCamera, index) {
+    const camera = {
+      ...gltfCamera,
+      id: gltfCamera.id || `camera-${index}`
+    };
+    if (camera.perspective) {
+    }
+    if (camera.orthographic) {
+    }
+    return camera;
+  }
+};
+function postProcessGLTF(gltf, options) {
+  return new GLTFPostProcessor().postProcess(gltf, options);
+}
+
 // ../3d-tiles/src/lib/parsers/helpers/parse-3d-tile-gltf-view.ts
 var GLTF_FORMAT = {
   URI: 0,
@@ -56762,7 +57046,9 @@ async function extractGLTF(tile, gltfFormat, options, context) {
       tile.gltfByteOffset = 0;
     }
     if (tile.gltfArrayBuffer) {
-      tile.gltf = await parse7(tile.gltfArrayBuffer, GLTFLoader, options, context);
+      const gltfWithBuffers = await parse7(tile.gltfArrayBuffer, GLTFLoader, options, context);
+      tile.gltf = postProcessGLTF(gltfWithBuffers);
+      tile.gpuMemoryUsageInBytes = getMemoryUsageGLTF(tile.gltf);
       delete tile.gltfArrayBuffer;
       delete tile.gltfByteOffset;
       delete tile.gltfByteLength;
@@ -56969,7 +57255,9 @@ async function parseGltf3DTile(tile, arrayBuffer, options, context) {
   tile.rotateYtoZ = true;
   tile.gltfUpAxis = options["3d-tiles"] && options["3d-tiles"].assetGltfUpAxis ? options["3d-tiles"].assetGltfUpAxis : "Y";
   const { parse: parse7 } = context;
-  tile.gltf = await parse7(arrayBuffer, GLTFLoader, options, context);
+  const gltfWithBuffers = await parse7(arrayBuffer, GLTFLoader, options, context);
+  tile.gltf = postProcessGLTF(gltfWithBuffers);
+  tile.gpuMemoryUsageInBytes = getMemoryUsageGLTF(tile.gltf);
 }
 
 // ../3d-tiles/src/lib/parsers/parse-3d-tile.ts
@@ -58451,7 +58739,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":
@@ -58611,8 +58899,27 @@ var Tiles3DLoader = {
     }
   }
 };
-function getBaseUri(tileset) {
-  return path_exports.dirname(tileset.url);
+async function parse4(data, options = {}, context) {
+  const loaderOptions = options["3d-tiles"] || {};
+  let isTileset;
+  if (loaderOptions.isTileset === "auto") {
+    isTileset = context?.url && context.url.indexOf(".json") !== -1;
+  } else {
+    isTileset = loaderOptions.isTileset;
+  }
+  return await isTileset ? parseTileset(data, options, context) : parseTile(data, options, context);
+}
+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;
+  tilesetJson.lodMetricType = LOD_METRIC_TYPE.GEOMETRIC_ERROR;
+  tilesetJson.lodMetricValue = tilesetJson.root?.lodMetricValue || 0;
+  return tilesetJson;
 }
 async function parseTile(arrayBuffer, options, context) {
   const tile = {
@@ -58624,31 +58931,8 @@ async function parseTile(arrayBuffer, options, context) {
   await parse3DTile(arrayBuffer, byteOffset, options, context, tile.content);
   return tile.content;
 }
-async function parseTileset(data, options, context) {
-  const tilesetJson = JSON.parse(new TextDecoder().decode(data));
-  tilesetJson.loader = options.loader || Tiles3DLoader;
-  tilesetJson.url = context.url;
-  tilesetJson.basePath = getBaseUri(tilesetJson);
-  tilesetJson.root = await normalizeTileHeaders(tilesetJson, options);
-  tilesetJson.type = TILESET_TYPE.TILES3D;
-  tilesetJson.lodMetricType = LOD_METRIC_TYPE.GEOMETRIC_ERROR;
-  tilesetJson.lodMetricValue = tilesetJson.root?.lodMetricValue || 0;
-  return tilesetJson;
-}
-async function parse4(data, options, context) {
-  const loaderOptions = options["3d-tiles"] || {};
-  let isTileset;
-  if (loaderOptions.isTileset === "auto") {
-    isTileset = context.url && context.url.indexOf(".json") !== -1;
-  } else {
-    isTileset = loaderOptions.isTileset;
-  }
-  if (isTileset) {
-    data = await parseTileset(data, options, context);
-  } else {
-    data = await parseTile(data, options, context);
-  }
-  return data;
+function getBaseUri(tileset) {
+  return path_exports.dirname(tileset.url);
 }
 
 // ../3d-tiles/src/lib/ion/ion.ts
@@ -59422,10 +59706,7 @@ function prepareDataForAttributesConversion(tileContent) {
   let nodes = tileContent.gltf?.scene?.nodes || tileContent.gltf?.scenes?.[0]?.nodes || tileContent.gltf?.nodes || [];
   const images = tileContent.gltf?.images?.map((imageObject) => {
     if (imageObject?.image?.compressed) {
-      return {
-        data: null,
-        compressed: true
-      };
+      return null;
     } else {
       const data = imageObject?.image?.data;
       const dataCopy = new Uint8Array(data.length);
@@ -59557,7 +59838,7 @@ function generateBatchIdsFromTexture(featureIdTexture, textureCoordinates, image
   const image = images[textureIndex];
   const batchIds = [];
   const channels = CHANNELS_MAP[featureChannel];
-  if (!image.compressed) {
+  if (image && image?.width && image?.height && image?.components) {
     for (let index = 0; index < textureCoordinates.length; index += 2) {
       const u = textureCoordinates[index];
       const v = textureCoordinates[index + 1];
@@ -59568,7 +59849,7 @@ function generateBatchIdsFromTexture(featureIdTexture, textureCoordinates, image
       batchIds.push(batchId);
     }
   } else {
-    console.warn(`Can't get batch Ids from ${image.mimeType} compressed texture`);
+    console.warn(`Can't get batch Ids from ${image?.mimeType || ""} compressed texture`);
   }
   return batchIds;
 }
@@ -59715,6 +59996,15 @@ function setupDoubleAttribute(storageAttribute) {
   };
 }
 
+// src/lib/utils/geometry-utils.ts
+var generateSyntheticIndices = (vertexCount) => {
+  const result = new Uint32Array(vertexCount);
+  for (let index = 0; index < vertexCount; index++) {
+    result[index] = index;
+  }
+  return result;
+};
+
 // src/i3s-converter/helpers/geometry-converter.ts
 var DEFAULT_ROUGHNESS_FACTOR = 1;
 var DEFAULT_METALLIC_FACTOR = 1;
@@ -59903,17 +60193,18 @@ function convertMesh(mesh, images, cartographicOrigin, cartesianModelMatrix, att
     let outputAttributes = null;
     let materialUvRegion;
     if (primitive.material) {
-      outputAttributes = attributesMap.get(primitive.material.uniqueId);
-      materialUvRegion = outputAttributes?.mergedMaterials.find(({ originalMaterialId }) => originalMaterialId === primitive.material?.uniqueId)?.uvRegion;
+      outputAttributes = attributesMap.get(primitive.material.id);
+      materialUvRegion = outputAttributes?.mergedMaterials.find(({ originalMaterialId }) => originalMaterialId === primitive.material?.id)?.uvRegion;
     } else if (attributesMap.has("default")) {
       outputAttributes = attributesMap.get("default");
     }
     assert2(outputAttributes !== null, "Primitive - material mapping failed");
+    assert2(primitive.mode === GL2.TRIANGLES || primitive.mode === GL2.TRIANGLE_STRIP, `Primitive - unsupported mode ${primitive.mode}`);
     const attributes = primitive.attributes;
     if (!outputAttributes) {
       continue;
     }
-    const indices = getIndices(primitive);
+    const indices = normalizeIndices(primitive);
     outputAttributes.positions = concatenateTypedArrays(outputAttributes.positions, transformVertexArray({
       vertices: attributes.POSITION.value,
       cartographicOrigin,
@@ -59941,8 +60232,12 @@ function convertMesh(mesh, images, cartographicOrigin, cartesianModelMatrix, att
     outputAttributes.featureIndicesGroups.push(flattenBatchIds(getBatchIds(attributes, primitive, images), indices));
   }
 }
-function getIndices(primitive) {
+function normalizeIndices(primitive) {
   let indices = primitive.indices?.value;
+  if (!indices) {
+    const positions = primitive.attributes.POSITION.value;
+    return generateSyntheticIndices(positions.length / VALUES_PER_VERTEX2);
+  }
   if (indices && primitive.mode === GL2.TRIANGLE_STRIP) {
     const TypedArrayConstructor = indices.constructor;
     const newIndices = new TypedArrayConstructor((indices.length - 2) * 3);
@@ -60157,9 +60452,8 @@ function convertMaterial(sourceMaterial) {
       textureSetDefinitionId: 0
     };
   }
-  const uniqueId = v4();
-  sourceMaterial.uniqueId = uniqueId;
-  let mergedMaterials = [{ originalMaterialId: uniqueId }];
+  sourceMaterial.id = Number.isFinite(sourceMaterial.id) ? sourceMaterial.id : v4();
+  let mergedMaterials = [{ originalMaterialId: sourceMaterial.id }];
   if (!texture) {
     const baseColorFactor = sourceMaterial?.pbrMetallicRoughness?.baseColorFactor;
     material.pbrMetallicRoughness.baseColorFactor = baseColorFactor && baseColorFactor.map((c) => Math.round(c * 255)) || void 0;
@@ -60247,13 +60541,16 @@ function extractSharedResourcesTextureInfo(texture, nodeId) {
       {
         id: generateImageId(texture, nodeId),
         size: texture.source?.image.width,
-        length: [texture.source?.image.data.length]
+        length: texture.source?.image.data.length ? [texture.source?.image.data.length] : void 0
       }
     ]
   };
 }
 function generateImageId(texture, nodeId) {
-  const { width, height } = texture.source?.image;
+  const { width, height } = texture.source?.image || {};
+  if (!width || !height) {
+    return "";
+  }
   const levelCountOfTexture = 1;
   const indexOfLevel = 0;
   const indexOfTextureInStore = nodeId + 1;
@@ -61605,12 +61902,7 @@ var I3SConverter = class {
         loadOptions: {
           _nodeWorkers: true,
           reuseWorkers: true,
-          basis: { format: "rgba32" },
-          "basis-nodejs": {
-            format: "rgba32",
-            workerUrl: "./modules/textures/dist/basis-nodejs-worker.js"
-          },
-          "draco-nodejs": { workerUrl: "./modules/draco/dist/draco-nodejs-worker.js" }
+          basis: { format: "rgba32" }
         }
       };
       if (preloadOptions.headers) {
@@ -62777,7 +63069,7 @@ function getFeatureIdsFromFeatureIndexMetadata(featureIndex) {
 var VERSION15 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "beta";
 var I3SContentLoader = {
   name: "I3S Content (Indexed Scene Layers)",
-  id: isBrowser2 ? "i3s-content" : "i3s-content-nodejs",
+  id: "i3s-content",
   module: "i3s",
   worker: true,
   version: VERSION15,
@@ -63243,9 +63535,6 @@ var Tiles3DConverter = class {
       loadOptions: {
         _nodeWorkers: true,
         reuseWorkers: true,
-        "i3s-content-nodejs": {
-          workerUrl: "./modules/i3s/dist/i3s-content-nodejs-worker.js"
-        },
         i3s: { coordinateSystem: COORDINATE_SYSTEM.LNGLAT_OFFSETS, decodeTextures: false }
       }
     });