@loaders.gl/3d-tiles 4.0.0-alpha.6 → 4.0.0-alpha.8

package/dist/dist.min.js

@@ -417,7 +417,7 @@
           }
         }
         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--;
@@ -515,7 +515,7 @@
   // ../worker-utils/src/lib/worker-api/get-worker-url.ts
   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;
@@ -538,6 +538,7 @@
   var init_get_worker_url = __esm({
     "../worker-utils/src/lib/worker-api/get-worker-url.ts"() {
       init_assert2();
+      init_globals2();
       NPM_TAG = "beta";
     }
   });
@@ -5341,39 +5342,60 @@
     }
   });
 
+  // ../core/src/lib/utils/url-utils.ts
+  function extractQueryString(url) {
+    const matches3 = url.match(QUERY_STRING_PATTERN);
+    return matches3 && matches3[0];
+  }
+  function stripQueryString(url) {
+    return url.replace(QUERY_STRING_PATTERN, "");
+  }
+  var QUERY_STRING_PATTERN;
+  var init_url_utils = __esm({
+    "../core/src/lib/utils/url-utils.ts"() {
+      QUERY_STRING_PATTERN = /\?.*/;
+    }
+  });
+
   // ../core/src/lib/utils/resource-utils.ts
-  function getResourceUrlAndType(resource) {
+  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;
@@ -5386,15 +5408,11 @@
     }
     return -1;
   }
-  function stripQueryString(url) {
-    return url.replace(QUERY_STRING_PATTERN, "");
-  }
-  var QUERY_STRING_PATTERN;
   var init_resource_utils = __esm({
     "../core/src/lib/utils/resource-utils.ts"() {
       init_is_type();
       init_mime_type_utils();
-      QUERY_STRING_PATTERN = /\?.*/;
+      init_url_utils();
     }
   });
 
@@ -5408,7 +5426,8 @@
     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;
     }
@@ -5497,7 +5516,7 @@
     }
   });
 
-  // ../../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;
@@ -5513,25 +5532,25 @@
     return false;
   }
   var init_is_electron = __esm({
-    "../../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"() {
     }
   });
 
-  // ../../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();
   }
   var init_is_browser = __esm({
-    "../../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"() {
       init_is_electron();
     }
   });
 
-  // ../../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, window_3, document_3, process_, console_, navigator_;
   var init_globals3 = __esm({
-    "../../node_modules/@probe.gl/env/dist/lib/globals.js"() {
+    "../../node_modules/@probe.gl/log/node_modules/@probe.gl/env/dist/lib/globals.js"() {
       self_3 = globalThis.self || globalThis.window || globalThis.global;
       window_3 = globalThis.window || globalThis.self || globalThis.global;
       document_3 = globalThis.document || {};
@@ -5541,19 +5560,19 @@
     }
   });
 
-  // ../../node_modules/@probe.gl/env/dist/utils/globals.js
+  // ../../node_modules/@probe.gl/log/node_modules/@probe.gl/env/dist/utils/globals.js
   var VERSION3, isBrowser4;
   var init_globals4 = __esm({
-    "../../node_modules/@probe.gl/env/dist/utils/globals.js"() {
+    "../../node_modules/@probe.gl/log/node_modules/@probe.gl/env/dist/utils/globals.js"() {
       init_is_browser();
       VERSION3 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "untranspiled source";
       isBrowser4 = isBrowser3();
     }
   });
 
-  // ../../node_modules/@probe.gl/env/dist/index.js
+  // ../../node_modules/@probe.gl/log/node_modules/@probe.gl/env/dist/index.js
   var init_dist = __esm({
-    "../../node_modules/@probe.gl/env/dist/index.js"() {
+    "../../node_modules/@probe.gl/log/node_modules/@probe.gl/env/dist/index.js"() {
       init_globals4();
       init_globals3();
       init_is_browser();
@@ -6394,8 +6413,9 @@
     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) {
@@ -6424,7 +6444,8 @@
     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"}, `;
@@ -6543,6 +6564,7 @@
       init_resource_utils();
       init_register_loaders();
       init_is_type();
+      init_url_utils();
       EXT_PATTERN = /\.([^.]+)$/;
     }
   });
@@ -6755,18 +6777,25 @@
   });
 
   // ../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)) {
@@ -6785,6 +6814,8 @@
   var init_loader_context = __esm({
     "../core/src/lib/loader-utils/loader-context.ts"() {
       init_get_fetch_function();
+      init_url_utils();
+      init_src2();
     }
   });
 
@@ -6798,7 +6829,7 @@
     }
     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);
@@ -6806,7 +6837,7 @@
       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) {
@@ -6891,24 +6922,24 @@
   var TILE_REFINEMENT, TILE_TYPE, TILESET_TYPE, LOD_METRIC_TYPE;
   var init_constants3 = __esm({
     "../tiles/src/constants.ts"() {
-      TILE_REFINEMENT = {
-        ADD: 1,
-        REPLACE: 2
-      };
-      TILE_TYPE = {
-        EMPTY: "empty",
-        SCENEGRAPH: "scenegraph",
-        POINTCLOUD: "pointcloud",
-        MESH: "mesh"
-      };
-      TILESET_TYPE = {
-        I3S: "I3S",
-        TILES3D: "TILES3D"
-      };
-      LOD_METRIC_TYPE = {
-        GEOMETRIC_ERROR: "geometricError",
-        MAX_SCREEN_THRESHOLD: "maxScreenThreshold"
-      };
+      (function(TILE_REFINEMENT2) {
+        TILE_REFINEMENT2[TILE_REFINEMENT2["ADD"] = 1] = "ADD";
+        TILE_REFINEMENT2[TILE_REFINEMENT2["REPLACE"] = 2] = "REPLACE";
+      })(TILE_REFINEMENT || (TILE_REFINEMENT = {}));
+      (function(TILE_TYPE2) {
+        TILE_TYPE2["EMPTY"] = "empty";
+        TILE_TYPE2["SCENEGRAPH"] = "scenegraph";
+        TILE_TYPE2["POINTCLOUD"] = "pointcloud";
+        TILE_TYPE2["MESH"] = "mesh";
+      })(TILE_TYPE || (TILE_TYPE = {}));
+      (function(TILESET_TYPE2) {
+        TILESET_TYPE2["I3S"] = "I3S";
+        TILESET_TYPE2["TILES3D"] = "TILES3D";
+      })(TILESET_TYPE || (TILESET_TYPE = {}));
+      (function(LOD_METRIC_TYPE2) {
+        LOD_METRIC_TYPE2["GEOMETRIC_ERROR"] = "geometricError";
+        LOD_METRIC_TYPE2["MAX_SCREEN_THRESHOLD"] = "maxScreenThreshold";
+      })(LOD_METRIC_TYPE || (LOD_METRIC_TYPE = {}));
     }
   });
 
@@ -6980,7 +7011,6 @@
   var DEFAULT_DRACO_OPTIONS, DracoLoader;
   var init_draco_loader = __esm({
     "../draco/src/draco-loader.ts"() {
-      init_src();
       init_version3();
       DEFAULT_DRACO_OPTIONS = {
         draco: {
@@ -6992,7 +7022,7 @@
       };
       DracoLoader = {
         name: "Draco",
-        id: isBrowser2 ? "draco" : "draco-nodejs",
+        id: "draco",
         module: "draco",
         version: VERSION5,
         worker: true,
@@ -8423,26 +8453,26 @@
     return byteOffset;
   }
   function parse3DTileFeatureTable(tile, arrayBuffer, byteOffset, options) {
-    const { featureTableJsonByteLength, featureTableBinaryByteLength, batchLength } = tile.header;
+    const { featureTableJsonByteLength, featureTableBinaryByteLength, batchLength } = tile.header || {};
     tile.featureTableJson = {
       BATCH_LENGTH: batchLength || 0
     };
-    if (featureTableJsonByteLength > 0) {
+    if (featureTableJsonByteLength && featureTableJsonByteLength > 0) {
       const featureTableString = getStringFromArrayBuffer(arrayBuffer, byteOffset, featureTableJsonByteLength);
       tile.featureTableJson = JSON.parse(featureTableString);
     }
-    byteOffset += featureTableJsonByteLength;
+    byteOffset += featureTableJsonByteLength || 0;
     tile.featureTableBinary = new Uint8Array(arrayBuffer, byteOffset, featureTableBinaryByteLength);
-    byteOffset += featureTableBinaryByteLength;
+    byteOffset += featureTableBinaryByteLength || 0;
     return byteOffset;
   }
   function parse3DTileBatchTable(tile, arrayBuffer, byteOffset, options) {
-    const { batchTableJsonByteLength, batchTableBinaryByteLength } = tile.header;
-    if (batchTableJsonByteLength > 0) {
+    const { batchTableJsonByteLength, batchTableBinaryByteLength } = tile.header || {};
+    if (batchTableJsonByteLength && batchTableJsonByteLength > 0) {
       const batchTableString = getStringFromArrayBuffer(arrayBuffer, byteOffset, batchTableJsonByteLength);
       tile.batchTableJson = JSON.parse(batchTableString);
       byteOffset += batchTableJsonByteLength;
-      if (batchTableBinaryByteLength > 0) {
+      if (batchTableBinaryByteLength && batchTableBinaryByteLength > 0) {
         tile.batchTableBinary = new Uint8Array(arrayBuffer, byteOffset, batchTableBinaryByteLength);
         tile.batchTableBinary = new Uint8Array(tile.batchTableBinary);
         byteOffset += batchTableBinaryByteLength;
@@ -8464,7 +8494,7 @@
     if (!colors && (!tile || !tile.batchIds || !batchTable)) {
       return null;
     }
-    const { batchIds, isRGB565, pointCount } = tile;
+    const { batchIds, isRGB565, pointCount = 0 } = tile;
     if (batchIds && batchTable) {
       const colorArray = new Uint8ClampedArray(pointCount * 3);
       for (let i2 = 0; i2 < pointCount; i2++) {
@@ -8482,7 +8512,7 @@
         normalized: true
       };
     }
-    if (isRGB565) {
+    if (colors && isRGB565) {
       const colorArray = new Uint8ClampedArray(pointCount * 3);
       for (let i2 = 0; i2 < pointCount; i2++) {
         const color = decodeRGB565(colors[i2]);
@@ -8507,7 +8537,7 @@
     }
     return {
       type: GL2.UNSIGNED_BYTE,
-      value: colors,
+      value: colors || new Uint8ClampedArray(),
       size: 4,
       normalized: true
     };
@@ -8524,8 +8554,8 @@
       return null;
     }
     if (tile.isOctEncoded16P) {
-      const decodedArray = new Float32Array(tile.pointsLength * 3);
-      for (let i2 = 0; i2 < tile.pointsLength; i2++) {
+      const decodedArray = new Float32Array((tile.pointsLength || 0) * 3);
+      for (let i2 = 0; i2 < (tile.pointsLength || 0); i2++) {
         octDecode(normals[i2 * 2], normals[i2 * 2 + 1], scratchNormal4);
         scratchNormal4.toArray(decodedArray, i2 * 3);
       }
@@ -8621,6 +8651,12 @@
     return { featureTable, batchTable };
   }
   function parsePositions(tile, featureTable, options) {
+    tile.attributes = tile.attributes || {
+      positions: null,
+      colors: null,
+      normals: null,
+      batchIds: null
+    };
     if (!tile.attributes.positions) {
       if (featureTable.hasProperty("POSITION")) {
         tile.attributes.positions = featureTable.getPropertyArray("POSITION", GL2.FLOAT, 3);
@@ -8644,6 +8680,12 @@
     }
   }
   function parseColors(tile, featureTable, batchTable) {
+    tile.attributes = tile.attributes || {
+      positions: null,
+      colors: null,
+      normals: null,
+      batchIds: null
+    };
     if (!tile.attributes.colors) {
       let colors = null;
       if (featureTable.hasProperty("RGBA")) {
@@ -8662,6 +8704,12 @@
     }
   }
   function parseNormals(tile, featureTable) {
+    tile.attributes = tile.attributes || {
+      positions: null,
+      colors: null,
+      normals: null,
+      batchIds: null
+    };
     if (!tile.attributes.normals) {
       let normals = null;
       if (featureTable.hasProperty("NORMAL")) {
@@ -8704,7 +8752,7 @@
       if (!dracoFeatureTableProperties || !Number.isFinite(dracoByteOffset) || !dracoByteLength) {
         throw new Error("Draco properties, byteOffset, and byteLength must be defined");
       }
-      dracoBuffer = tile.featureTableBinary.slice(dracoByteOffset, dracoByteOffset + dracoByteLength);
+      dracoBuffer = (tile.featureTableBinary || []).slice(dracoByteOffset, dracoByteOffset + dracoByteLength);
       tile.hasPositions = Number.isFinite(dracoFeatureTableProperties.POSITION);
       tile.hasColors = Number.isFinite(dracoFeatureTableProperties.RGB) || Number.isFinite(dracoFeatureTableProperties.RGBA);
       tile.hasNormals = Number.isFinite(dracoFeatureTableProperties.NORMAL);
@@ -8724,11 +8772,14 @@
     return await loadDraco(tile, dracoData, options, context);
   }
   async function loadDraco(tile, dracoData, options, context) {
+    if (!context) {
+      return;
+    }
     const { parse: parse5 } = context;
     const dracoOptions = {
       ...options,
       draco: {
-        ...options.draco,
+        ...options?.draco,
         extraAttributes: dracoData.batchTableProperties || {}
       }
     };
@@ -8791,977 +8842,977 @@
     }
   });
 
-  // ../textures/src/lib/utils/version.ts
+  // ../images/src/lib/utils/version.ts
   var VERSION7;
   var init_version5 = __esm({
-    "../textures/src/lib/utils/version.ts"() {
-      VERSION7 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "beta";
+    "../images/src/lib/utils/version.ts"() {
+      VERSION7 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
     }
   });
 
-  // ../textures/src/lib/parsers/basis-module-loader.ts
-  async function loadBasisTrascoderModule(options) {
-    const modules = options.modules || {};
-    if (modules.basis) {
-      return modules.basis;
+  // ../images/src/lib/category-api/image-type.ts
+  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 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");
   }
-  function initializeBasisTrascoderModule(BasisModule, wasmBinary) {
-    const options = {};
-    if (wasmBinary) {
-      options.wasmBinary = wasmBinary;
+  var _parseImageNode, IMAGE_SUPPORTED, IMAGE_BITMAP_SUPPORTED, NODE_IMAGE_SUPPORTED, DATA_SUPPORTED;
+  var init_image_type = __esm({
+    "../images/src/lib/category-api/image-type.ts"() {
+      init_src2();
+      ({ _parseImageNode } = globalThis);
+      IMAGE_SUPPORTED = typeof Image !== "undefined";
+      IMAGE_BITMAP_SUPPORTED = typeof ImageBitmap !== "undefined";
+      NODE_IMAGE_SUPPORTED = Boolean(_parseImageNode);
+      DATA_SUPPORTED = isBrowser ? true : NODE_IMAGE_SUPPORTED;
     }
-    return new Promise((resolve2) => {
-      BasisModule(options).then((module) => {
-        const { BasisFile, initializeBasis } = module;
-        initializeBasis();
-        resolve2({ BasisFile });
-      });
-    });
+  });
+
+  // ../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;
   }
-  async function loadBasisEncoderModule(options) {
-    const modules = options.modules || {};
-    if (modules.basisEncoder) {
-      return modules.basisEncoder;
+  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");
     }
-    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 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;
   }
-  function initializeBasisEncoderModule(BasisEncoderModule, wasmBinary) {
-    const options = {};
-    if (wasmBinary) {
-      options.wasmBinary = wasmBinary;
+  var init_parsed_image_api = __esm({
+    "../images/src/lib/category-api/parsed-image-api.ts"() {
     }
-    return new Promise((resolve2) => {
-      BasisEncoderModule(options).then((module) => {
-        const { BasisFile, KTX2File, initializeBasis, BasisEncoder } = module;
-        initializeBasis();
-        resolve2({ BasisFile, KTX2File, BasisEncoder });
-      });
+  });
+
+  // ../images/src/lib/parsers/svg-utils.ts
+  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)]);
+  }
+  var SVG_DATA_URL_PATTERN, SVG_URL_PATTERN;
+  var init_svg_utils = __esm({
+    "../images/src/lib/parsers/svg-utils.ts"() {
+      SVG_DATA_URL_PATTERN = /^data:image\/svg\+xml/;
+      SVG_URL_PATTERN = /\.svg((\?|#).*)?$/;
+    }
+  });
+
+  // ../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);
+      }
     });
   }
-  var VERSION8, BASIS_CDN_ENCODER_WASM, BASIS_CDN_ENCODER_JS, loadBasisTranscoderPromise, loadBasisEncoderPromise;
-  var init_basis_module_loader = __esm({
-    "../textures/src/lib/parsers/basis-module-loader.ts"() {
-      init_src();
-      VERSION8 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "beta";
-      BASIS_CDN_ENCODER_WASM = `https://unpkg.com/@loaders.gl/textures@${VERSION8}/dist/libs/basis_encoder.wasm`;
-      BASIS_CDN_ENCODER_JS = `https://unpkg.com/@loaders.gl/textures@${VERSION8}/dist/libs/basis_encoder.js`;
+  var init_parse_to_image = __esm({
+    "../images/src/lib/parsers/parse-to-image.ts"() {
+      init_svg_utils();
     }
   });
 
-  // ../textures/src/lib/gl-extensions.ts
-  var GL_EXTENSIONS_CONSTANTS;
-  var init_gl_extensions = __esm({
-    "../textures/src/lib/gl-extensions.ts"() {
-      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
-      };
+  // ../images/src/lib/parsers/parse-to-image-bitmap.ts
+  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);
     }
-  });
-
-  // ../textures/src/lib/utils/texture-formats.ts
-  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);
-          }
-        }
+    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 formats;
+    return await createImageBitmap(blob);
   }
-  function getWebGLContext() {
-    try {
-      const canvas = document.createElement("canvas");
-      return canvas.getContext("webgl");
-    } catch (error) {
-      return null;
+  function isEmptyObject(object) {
+    for (const key in object || EMPTY_OBJECT) {
+      return false;
     }
+    return true;
   }
-  var BROWSER_PREFIXES, WEBGL_EXTENSIONS, formats;
-  var init_texture_formats = __esm({
-    "../textures/src/lib/utils/texture-formats.ts"() {
-      BROWSER_PREFIXES = ["", "WEBKIT_", "MOZ_"];
-      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"
-      };
-      formats = null;
-    }
-  });
-
-  // ../../node_modules/ktx-parse/dist/ktx-parse.modern.js
-  var t, n, i, s, a, r, o, l, f;
-  var init_ktx_parse_modern = __esm({
-    "../../node_modules/ktx-parse/dist/ktx-parse.modern.js"() {
-      t = new Uint8Array([0]);
-      !function(t2) {
-        t2[t2.NONE = 0] = "NONE", t2[t2.BASISLZ = 1] = "BASISLZ", t2[t2.ZSTD = 2] = "ZSTD", t2[t2.ZLIB = 3] = "ZLIB";
-      }(n || (n = {})), function(t2) {
-        t2[t2.BASICFORMAT = 0] = "BASICFORMAT";
-      }(i || (i = {})), function(t2) {
-        t2[t2.UNSPECIFIED = 0] = "UNSPECIFIED", t2[t2.ETC1S = 163] = "ETC1S", t2[t2.UASTC = 166] = "UASTC";
-      }(s || (s = {})), function(t2) {
-        t2[t2.UNSPECIFIED = 0] = "UNSPECIFIED", t2[t2.SRGB = 1] = "SRGB";
-      }(a || (a = {})), function(t2) {
-        t2[t2.UNSPECIFIED = 0] = "UNSPECIFIED", t2[t2.LINEAR = 1] = "LINEAR", t2[t2.SRGB = 2] = "SRGB", t2[t2.ITU = 3] = "ITU", t2[t2.NTSC = 4] = "NTSC", t2[t2.SLOG = 5] = "SLOG", t2[t2.SLOG2 = 6] = "SLOG2";
-      }(r || (r = {})), function(t2) {
-        t2[t2.ALPHA_STRAIGHT = 0] = "ALPHA_STRAIGHT", t2[t2.ALPHA_PREMULTIPLIED = 1] = "ALPHA_PREMULTIPLIED";
-      }(o || (o = {})), function(t2) {
-        t2[t2.RGB = 0] = "RGB", t2[t2.RRR = 3] = "RRR", t2[t2.GGG = 4] = "GGG", t2[t2.AAA = 15] = "AAA";
-      }(l || (l = {})), function(t2) {
-        t2[t2.RGB = 0] = "RGB", t2[t2.RGBA = 3] = "RGBA", t2[t2.RRR = 4] = "RRR", t2[t2.RRRG = 5] = "RRRG";
-      }(f || (f = {}));
+  var EMPTY_OBJECT, imagebitmapOptionsSupported;
+  var init_parse_to_image_bitmap = __esm({
+    "../images/src/lib/parsers/parse-to-image-bitmap.ts"() {
+      init_svg_utils();
+      init_parse_to_image();
+      EMPTY_OBJECT = {};
+      imagebitmapOptionsSupported = true;
     }
   });
 
-  // ../textures/src/lib/parsers/parse-ktx.ts
-  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;
-  }
-  var KTX2_ID;
-  var init_parse_ktx = __esm({
-    "../textures/src/lib/parsers/parse-ktx.ts"() {
-      init_ktx_parse_modern();
-      KTX2_ID = [
-        171,
-        75,
-        84,
-        88,
-        32,
-        50,
-        48,
-        187,
-        13,
-        10,
-        26,
-        10
-      ];
+  // ../images/src/lib/category-api/parse-isobmff-binary.ts
+  function getISOBMFFMediaType(buffer) {
+    if (!checkString(buffer, "ftyp", 4)) {
+      return null;
     }
-  });
-
-  // ../textures/src/lib/parsers/parse-basis.ts
-  async function parseBasis(data, options) {
-    if (options.basis.containerFormat === "auto") {
-      if (isKTX(data)) {
-        const fileConstructors = await loadBasisEncoderModule(options);
-        return parseKTX2File(fileConstructors.KTX2File, data, options);
-      }
-      const { BasisFile } = await loadBasisTrascoderModule(options);
-      return parseBasisFile(BasisFile, data, options);
+    if ((buffer[8] & 96) === 0) {
+      return null;
     }
-    switch (options.basis.module) {
-      case "encoder":
-        const fileConstructors = await loadBasisEncoderModule(options);
-        switch (options.basis.containerFormat) {
-          case "ktx2":
-            return parseKTX2File(fileConstructors.KTX2File, data, options);
-          case "basis":
-          default:
-            return parseBasisFile(fileConstructors.BasisFile, data, options);
-        }
-      case "transcoder":
+    return decodeMajorBrand(buffer);
+  }
+  function decodeMajorBrand(buffer) {
+    const brandMajor = getUTF8String(buffer, 8, 12).replace("\0", " ").trim();
+    switch (brandMajor) {
+      case "avif":
+      case "avis":
+        return { extension: "avif", mimeType: "image/avif" };
       default:
-        const { BasisFile } = await loadBasisTrascoderModule(options);
-        return parseBasisFile(BasisFile, data, options);
+        return null;
     }
   }
-  function parseBasisFile(BasisFile, data, options) {
-    const basisFile = new BasisFile(new Uint8Array(data));
-    try {
-      if (!basisFile.startTranscoding()) {
-        throw new Error("Failed to start basis transcoding");
-      }
-      const imageCount = basisFile.getNumImages();
-      const images = [];
-      for (let imageIndex = 0; imageIndex < imageCount; imageIndex++) {
-        const levelsCount = basisFile.getNumLevels(imageIndex);
-        const levels = [];
-        for (let levelIndex = 0; levelIndex < levelsCount; levelIndex++) {
-          levels.push(transcodeImage(basisFile, imageIndex, levelIndex, options));
-        }
-        images.push(levels);
+  function getUTF8String(array, start, end) {
+    return String.fromCharCode(...array.slice(start, end));
+  }
+  function stringToBytes(string) {
+    return [...string].map((character) => character.charCodeAt(0));
+  }
+  function checkString(buffer, header, offset = 0) {
+    const headerBytes = stringToBytes(header);
+    for (let i2 = 0; i2 < headerBytes.length; ++i2) {
+      if (headerBytes[i2] !== buffer[i2 + offset]) {
+        return false;
       }
-      return images;
-    } finally {
-      basisFile.close();
-      basisFile.delete();
     }
+    return true;
   }
-  function transcodeImage(basisFile, imageIndex, levelIndex, options) {
-    const width = basisFile.getImageWidth(imageIndex, levelIndex);
-    const height = basisFile.getImageHeight(imageIndex, levelIndex);
-    const hasAlpha = basisFile.getHasAlpha();
-    const { compressed, format, basisFormat } = getBasisOptions(options, hasAlpha);
-    const decodedSize = basisFile.getImageTranscodedSizeInBytes(imageIndex, levelIndex, basisFormat);
-    const decodedData = new Uint8Array(decodedSize);
-    if (!basisFile.transcodeImage(decodedData, imageIndex, levelIndex, basisFormat, 0, 0)) {
-      throw new Error("failed to start Basis transcoding");
+  var init_parse_isobmff_binary = __esm({
+    "../images/src/lib/category-api/parse-isobmff-binary.ts"() {
+    }
+  });
+
+  // ../images/src/lib/category-api/binary-image-api.ts
+  function getBinaryImageMetadata(binaryData) {
+    const dataView = toDataView(binaryData);
+    return getPngMetadata(dataView) || getJpegMetadata(dataView) || getGifMetadata(dataView) || getBmpMetadata(dataView) || getISOBMFFMetadata(dataView);
+  }
+  function getISOBMFFMetadata(binaryData) {
+    const buffer = new Uint8Array(binaryData instanceof DataView ? binaryData.buffer : binaryData);
+    const mediaType = getISOBMFFMediaType(buffer);
+    if (!mediaType) {
+      return null;
     }
     return {
-      width,
-      height,
-      data: decodedData,
-      compressed,
-      format,
-      hasAlpha
+      mimeType: mediaType.mimeType,
+      width: 0,
+      height: 0
     };
   }
-  function parseKTX2File(KTX2File, data, options) {
-    const ktx2File = new KTX2File(new Uint8Array(data));
-    try {
-      if (!ktx2File.startTranscoding()) {
-        throw new Error("failed to start KTX2 transcoding");
-      }
-      const levelsCount = ktx2File.getLevels();
-      const levels = [];
-      for (let levelIndex = 0; levelIndex < levelsCount; levelIndex++) {
-        levels.push(transcodeKTX2Image(ktx2File, levelIndex, options));
-        break;
-      }
-      return [levels];
-    } finally {
-      ktx2File.close();
-      ktx2File.delete();
+  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 transcodeKTX2Image(ktx2File, levelIndex, options) {
-    const { alphaFlag, height, width } = ktx2File.getImageLevelInfo(levelIndex, 0, 0);
-    const { compressed, format, basisFormat } = getBasisOptions(options, alphaFlag);
-    const decodedSize = ktx2File.getImageTranscodedSizeInBytes(levelIndex, 0, 0, basisFormat);
-    const decodedData = new Uint8Array(decodedSize);
-    if (!ktx2File.transcodeImage(decodedData, levelIndex, 0, 0, basisFormat, 0, -1, -1)) {
-      throw new Error("Failed to transcode KTX2 image");
+  function getGifMetadata(binaryData) {
+    const dataView = toDataView(binaryData);
+    const isGif = dataView.byteLength >= 10 && dataView.getUint32(0, BIG_ENDIAN) === 1195984440;
+    if (!isGif) {
+      return null;
     }
     return {
-      width,
-      height,
-      data: decodedData,
-      compressed,
-      levelSize: decodedSize,
-      hasAlpha: alphaFlag,
-      format
+      mimeType: "image/gif",
+      width: dataView.getUint16(6, LITTLE_ENDIAN),
+      height: dataView.getUint16(8, LITTLE_ENDIAN)
     };
   }
-  function getBasisOptions(options, hasAlpha) {
-    let format = options && options.basis && options.basis.format;
-    if (format === "auto") {
-      format = selectSupportedBasisFormat();
+  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;
     }
-    if (typeof format === "object") {
-      format = hasAlpha ? format.alpha : format.noAlpha;
+    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;
     }
-    format = format.toLowerCase();
-    return OutputFormat[format];
+    const { tableMarkers, sofMarkers } = getJpegMarkers();
+    let i2 = 2;
+    while (i2 + 9 < dataView.byteLength) {
+      const marker2 = dataView.getUint16(i2, BIG_ENDIAN);
+      if (sofMarkers.has(marker2)) {
+        return {
+          mimeType: "image/jpeg",
+          height: dataView.getUint16(i2 + 5, BIG_ENDIAN),
+          width: dataView.getUint16(i2 + 7, BIG_ENDIAN)
+        };
+      }
+      if (!tableMarkers.has(marker2)) {
+        return null;
+      }
+      i2 += 2;
+      i2 += dataView.getUint16(i2, BIG_ENDIAN);
+    }
+    return null;
   }
-  function selectSupportedBasisFormat() {
-    const supportedFormats = getSupportedGPUTextureFormats();
-    if (supportedFormats.has("astc")) {
-      return "astc-4x4";
-    } else if (supportedFormats.has("dxt")) {
-      return {
-        alpha: "bc3",
-        noAlpha: "bc1"
-      };
-    } else if (supportedFormats.has("pvrtc")) {
-      return {
-        alpha: "pvrtc1-4-rgba",
-        noAlpha: "pvrtc1-4-rgb"
-      };
-    } else if (supportedFormats.has("etc1")) {
-      return "etc1";
-    } else if (supportedFormats.has("etc2")) {
-      return "etc2";
+  function getJpegMarkers() {
+    const tableMarkers = new Set([65499, 65476, 65484, 65501, 65534]);
+    for (let i2 = 65504; i2 < 65520; ++i2) {
+      tableMarkers.add(i2);
     }
-    return "rgb565";
+    const sofMarkers = new Set([
+      65472,
+      65473,
+      65474,
+      65475,
+      65477,
+      65478,
+      65479,
+      65481,
+      65482,
+      65483,
+      65485,
+      65486,
+      65487,
+      65502
+    ]);
+    return { tableMarkers, sofMarkers };
   }
-  var OutputFormat;
-  var init_parse_basis = __esm({
-    "../textures/src/lib/parsers/parse-basis.ts"() {
-      init_basis_module_loader();
-      init_gl_extensions();
-      init_texture_formats();
-      init_parse_ktx();
-      OutputFormat = {
-        etc1: {
-          basisFormat: 0,
-          compressed: true,
-          format: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGB_ETC1_WEBGL
-        },
-        etc2: { basisFormat: 1, compressed: true },
-        bc1: {
-          basisFormat: 2,
-          compressed: true,
-          format: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGB_S3TC_DXT1_EXT
-        },
-        bc3: {
-          basisFormat: 3,
-          compressed: true,
-          format: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_S3TC_DXT5_EXT
-        },
-        bc4: { basisFormat: 4, compressed: true },
-        bc5: { basisFormat: 5, compressed: true },
-        "bc7-m6-opaque-only": { basisFormat: 6, compressed: true },
-        "bc7-m5": { basisFormat: 7, compressed: true },
-        "pvrtc1-4-rgb": {
-          basisFormat: 8,
-          compressed: true,
-          format: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGB_PVRTC_4BPPV1_IMG
-        },
-        "pvrtc1-4-rgba": {
-          basisFormat: 9,
-          compressed: true,
-          format: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_PVRTC_4BPPV1_IMG
-        },
-        "astc-4x4": {
-          basisFormat: 10,
-          compressed: true,
-          format: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_4X4_KHR
-        },
-        "atc-rgb": { basisFormat: 11, compressed: true },
-        "atc-rgba-interpolated-alpha": { basisFormat: 12, compressed: true },
-        rgba32: { basisFormat: 13, compressed: false },
-        rgb565: { basisFormat: 14, compressed: false },
-        bgr565: { basisFormat: 15, compressed: false },
-        rgba4444: { basisFormat: 16, compressed: false }
-      };
+  function toDataView(data) {
+    if (data instanceof DataView) {
+      return data;
     }
-  });
-
-  // ../textures/src/basis-loader.ts
-  var BasisWorkerLoader, BasisLoader;
-  var init_basis_loader = __esm({
-    "../textures/src/basis-loader.ts"() {
-      init_src();
-      init_version5();
-      init_parse_basis();
-      BasisWorkerLoader = {
-        name: "Basis",
-        id: isBrowser2 ? "basis" : "basis-nodejs",
-        module: "textures",
-        version: VERSION7,
-        worker: true,
-        extensions: ["basis", "ktx2"],
-        mimeTypes: ["application/octet-stream", "image/ktx2"],
-        tests: ["sB"],
-        binary: true,
-        options: {
-          basis: {
-            format: "auto",
-            libraryPath: "libs/",
-            containerFormat: "auto",
-            module: "transcoder"
-          }
-        }
-      };
-      BasisLoader = {
-        ...BasisWorkerLoader,
-        parse: parseBasis
-      };
+    if (ArrayBuffer.isView(data)) {
+      return new DataView(data.buffer);
+    }
+    if (data instanceof ArrayBuffer) {
+      return new DataView(data);
+    }
+    throw new Error("toDataView");
+  }
+  var BIG_ENDIAN, LITTLE_ENDIAN;
+  var init_binary_image_api = __esm({
+    "../images/src/lib/category-api/binary-image-api.ts"() {
+      init_parse_isobmff_binary();
+      BIG_ENDIAN = false;
+      LITTLE_ENDIAN = true;
     }
   });
 
-  // ../images/src/lib/utils/version.ts
-  var VERSION9;
-  var init_version6 = __esm({
-    "../images/src/lib/utils/version.ts"() {
-      VERSION9 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+  // ../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);
+  }
+  var init_parse_to_node_image = __esm({
+    "../images/src/lib/parsers/parse-to-node-image.ts"() {
+      init_src2();
+      init_binary_image_api();
     }
   });
 
-  // ../images/src/lib/category-api/image-type.ts
-  function isImageTypeSupported(type) {
-    switch (type) {
-      case "auto":
-        return IMAGE_BITMAP_SUPPORTED || IMAGE_SUPPORTED || DATA_SUPPORTED;
+  // ../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":
-        return IMAGE_BITMAP_SUPPORTED;
+        image = await parseToImageBitmap(arrayBuffer, options, url);
+        break;
       case "image":
-        return IMAGE_SUPPORTED;
+        image = await parseToImage(arrayBuffer, options, url);
+        break;
       case "data":
-        return DATA_SUPPORTED;
+        image = await parseToNodeImage(arrayBuffer, options);
+        break;
       default:
-        throw new Error(`@loaders.gl/images: image ${type} not supported in this environment`);
-    }
-  }
-  function getDefaultImageType() {
-    if (IMAGE_BITMAP_SUPPORTED) {
-      return "imagebitmap";
+        assert2(false);
     }
-    if (IMAGE_SUPPORTED) {
-      return "image";
+    if (imageType === "data") {
+      image = getImageData(image);
     }
-    if (DATA_SUPPORTED) {
-      return "data";
+    return image;
+  }
+  function getLoadableImageType(type) {
+    switch (type) {
+      case "auto":
+      case "data":
+        return getDefaultImageType();
+      default:
+        isImageTypeSupported(type);
+        return type;
     }
-    throw new Error("Install '@loaders.gl/polyfills' to parse images under Node.js");
   }
-  var _parseImageNode, IMAGE_SUPPORTED, IMAGE_BITMAP_SUPPORTED, NODE_IMAGE_SUPPORTED, DATA_SUPPORTED;
-  var init_image_type = __esm({
-    "../images/src/lib/category-api/image-type.ts"() {
+  var init_parse_image = __esm({
+    "../images/src/lib/parsers/parse-image.ts"() {
       init_src2();
-      ({ _parseImageNode } = globalThis);
-      IMAGE_SUPPORTED = typeof Image !== "undefined";
-      IMAGE_BITMAP_SUPPORTED = typeof ImageBitmap !== "undefined";
-      NODE_IMAGE_SUPPORTED = Boolean(_parseImageNode);
-      DATA_SUPPORTED = isBrowser ? true : NODE_IMAGE_SUPPORTED;
+      init_image_type();
+      init_parsed_image_api();
+      init_parse_to_image();
+      init_parse_to_image_bitmap();
+      init_parse_to_node_image();
     }
   });
 
-  // ../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 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");
+  // ../images/src/image-loader.ts
+  var EXTENSIONS, MIME_TYPES, DEFAULT_IMAGE_LOADER_OPTIONS, ImageLoader;
+  var init_image_loader = __esm({
+    "../images/src/image-loader.ts"() {
+      init_version5();
+      init_parse_image();
+      init_binary_image_api();
+      EXTENSIONS = ["png", "jpg", "jpeg", "gif", "webp", "bmp", "ico", "svg", "avif"];
+      MIME_TYPES = [
+        "image/png",
+        "image/jpeg",
+        "image/gif",
+        "image/webp",
+        "image/avif",
+        "image/bmp",
+        "image/vnd.microsoft.icon",
+        "image/svg+xml"
+      ];
+      DEFAULT_IMAGE_LOADER_OPTIONS = {
+        image: {
+          type: "auto",
+          decode: true
         }
-        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;
-  }
-  var init_parsed_image_api = __esm({
-    "../images/src/lib/category-api/parsed-image-api.ts"() {
+      };
+      ImageLoader = {
+        id: "image",
+        module: "images",
+        name: "Images",
+        version: VERSION7,
+        mimeTypes: MIME_TYPES,
+        extensions: EXTENSIONS,
+        parse: parseImage,
+        tests: [(arrayBuffer) => Boolean(getBinaryImageMetadata(new DataView(arrayBuffer)))],
+        options: DEFAULT_IMAGE_LOADER_OPTIONS
+      };
     }
   });
 
-  // ../images/src/lib/parsers/svg-utils.ts
-  function isSVG(url) {
-    return url && (SVG_DATA_URL_PATTERN.test(url) || SVG_URL_PATTERN.test(url));
+  // ../images/src/lib/category-api/image-format.ts
+  function isImageFormatSupported(mimeType) {
+    if (mimeTypeSupportedSync[mimeType] === void 0) {
+      const supported = isBrowser ? checkBrowserImageFormatSupport(mimeType) : checkNodeImageFormatSupport(mimeType);
+      mimeTypeSupportedSync[mimeType] = supported;
+    }
+    return mimeTypeSupportedSync[mimeType];
   }
-  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;
+  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;
     }
-    return getBlob(arrayBuffer, url);
   }
-  function getBlob(arrayBuffer, url) {
-    if (isSVG(url)) {
-      throw new Error("SVG cannot be parsed directly to imagebitmap");
+  function testBrowserImageFormatSupport(mimeType) {
+    try {
+      const element = document.createElement("canvas");
+      const dataURL = element.toDataURL(mimeType);
+      return dataURL.indexOf(`data:${mimeType}`) === 0;
+    } catch {
+      return false;
     }
-    return new Blob([new Uint8Array(arrayBuffer)]);
   }
-  var SVG_DATA_URL_PATTERN, SVG_URL_PATTERN;
-  var init_svg_utils = __esm({
-    "../images/src/lib/parsers/svg-utils.ts"() {
-      SVG_DATA_URL_PATTERN = /^data:image\/svg\+xml/;
-      SVG_URL_PATTERN = /\.svg((\?|#).*)?$/;
+  var mimeTypeSupportedSync;
+  var init_image_format = __esm({
+    "../images/src/lib/category-api/image-format.ts"() {
+      init_src2();
+      mimeTypeSupportedSync = {};
     }
   });
 
-  // ../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;
+  // ../images/src/index.ts
+  var init_src8 = __esm({
+    "../images/src/index.ts"() {
+      init_image_loader();
+      init_binary_image_api();
+      init_parsed_image_api();
+      init_image_format();
     }
-    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);
-      }
-    });
-  }
-  var init_parse_to_image = __esm({
-    "../images/src/lib/parsers/parse-to-image.ts"() {
-      init_svg_utils();
+  });
+
+  // ../textures/src/lib/utils/version.ts
+  var VERSION8;
+  var init_version6 = __esm({
+    "../textures/src/lib/utils/version.ts"() {
+      VERSION8 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "beta";
     }
   });
 
-  // ../images/src/lib/parsers/parse-to-image-bitmap.ts
-  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;
-      }
+  // ../textures/src/lib/parsers/basis-module-loader.ts
+  async function loadBasisTrascoderModule(options) {
+    const modules = options.modules || {};
+    if (modules.basis) {
+      return modules.basis;
     }
-    return await createImageBitmap(blob);
+    loadBasisTranscoderPromise = loadBasisTranscoderPromise || loadBasisTrascoder(options);
+    return await loadBasisTranscoderPromise;
   }
-  function isEmptyObject(object) {
-    for (const key in object || EMPTY_OBJECT) {
-      return false;
-    }
-    return true;
+  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);
   }
-  var EMPTY_OBJECT, imagebitmapOptionsSupported;
-  var init_parse_to_image_bitmap = __esm({
-    "../images/src/lib/parsers/parse-to-image-bitmap.ts"() {
-      init_svg_utils();
-      init_parse_to_image();
-      EMPTY_OBJECT = {};
-      imagebitmapOptionsSupported = true;
-    }
-  });
-
-  // ../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;
+  function initializeBasisTrascoderModule(BasisModule, wasmBinary) {
+    const options = {};
+    if (wasmBinary) {
+      options.wasmBinary = wasmBinary;
     }
-    return decodeMajorBrand(buffer);
+    return new Promise((resolve2) => {
+      BasisModule(options).then((module) => {
+        const { BasisFile, initializeBasis } = module;
+        initializeBasis();
+        resolve2({ BasisFile });
+      });
+    });
   }
-  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;
+  async function loadBasisEncoderModule(options) {
+    const modules = options.modules || {};
+    if (modules.basisEncoder) {
+      return modules.basisEncoder;
     }
+    loadBasisEncoderPromise = loadBasisEncoderPromise || loadBasisEncoder(options);
+    return await loadBasisEncoderPromise;
   }
-  function getUTF8String(array, start, end) {
-    return String.fromCharCode(...array.slice(start, end));
-  }
-  function stringToBytes(string) {
-    return [...string].map((character) => character.charCodeAt(0));
+  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 checkString(buffer, header, offset = 0) {
-    const headerBytes = stringToBytes(header);
-    for (let i2 = 0; i2 < headerBytes.length; ++i2) {
-      if (headerBytes[i2] !== buffer[i2 + offset]) {
-        return false;
-      }
+  function initializeBasisEncoderModule(BasisEncoderModule, wasmBinary) {
+    const options = {};
+    if (wasmBinary) {
+      options.wasmBinary = wasmBinary;
     }
-    return true;
+    return new Promise((resolve2) => {
+      BasisEncoderModule(options).then((module) => {
+        const { BasisFile, KTX2File, initializeBasis, BasisEncoder } = module;
+        initializeBasis();
+        resolve2({ BasisFile, KTX2File, BasisEncoder });
+      });
+    });
   }
-  var init_parse_isobmff_binary = __esm({
-    "../images/src/lib/category-api/parse-isobmff-binary.ts"() {
+  var VERSION9, BASIS_CDN_ENCODER_WASM, BASIS_CDN_ENCODER_JS, loadBasisTranscoderPromise, loadBasisEncoderPromise;
+  var init_basis_module_loader = __esm({
+    "../textures/src/lib/parsers/basis-module-loader.ts"() {
+      init_src();
+      VERSION9 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "beta";
+      BASIS_CDN_ENCODER_WASM = `https://unpkg.com/@loaders.gl/textures@${VERSION9}/dist/libs/basis_encoder.wasm`;
+      BASIS_CDN_ENCODER_JS = `https://unpkg.com/@loaders.gl/textures@${VERSION9}/dist/libs/basis_encoder.js`;
     }
   });
 
-  // ../images/src/lib/category-api/binary-image-api.ts
-  function getBinaryImageMetadata(binaryData) {
-    const dataView = toDataView(binaryData);
-    return getPngMetadata(dataView) || getJpegMetadata(dataView) || getGifMetadata(dataView) || getBmpMetadata(dataView) || 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;
+  // ../textures/src/lib/gl-extensions.ts
+  var GL_EXTENSIONS_CONSTANTS;
+  var init_gl_extensions = __esm({
+    "../textures/src/lib/gl-extensions.ts"() {
+      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
+      };
     }
-    const { tableMarkers, sofMarkers } = getJpegMarkers();
-    let i2 = 2;
-    while (i2 + 9 < dataView.byteLength) {
-      const marker2 = dataView.getUint16(i2, BIG_ENDIAN);
-      if (sofMarkers.has(marker2)) {
-        return {
-          mimeType: "image/jpeg",
-          height: dataView.getUint16(i2 + 5, BIG_ENDIAN),
-          width: dataView.getUint16(i2 + 7, BIG_ENDIAN)
-        };
-      }
-      if (!tableMarkers.has(marker2)) {
-        return null;
+  });
+
+  // ../textures/src/lib/utils/texture-formats.ts
+  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);
+          }
+        }
       }
-      i2 += 2;
-      i2 += dataView.getUint16(i2, BIG_ENDIAN);
     }
-    return null;
+    return formats;
   }
-  function getJpegMarkers() {
-    const tableMarkers = new Set([65499, 65476, 65484, 65501, 65534]);
-    for (let i2 = 65504; i2 < 65520; ++i2) {
-      tableMarkers.add(i2);
+  function getWebGLContext() {
+    try {
+      const canvas = document.createElement("canvas");
+      return canvas.getContext("webgl");
+    } catch (error) {
+      return null;
     }
-    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);
+  var BROWSER_PREFIXES, WEBGL_EXTENSIONS, formats;
+  var init_texture_formats = __esm({
+    "../textures/src/lib/utils/texture-formats.ts"() {
+      BROWSER_PREFIXES = ["", "WEBKIT_", "MOZ_"];
+      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"
+      };
+      formats = null;
     }
-    if (data instanceof ArrayBuffer) {
-      return new DataView(data);
+  });
+
+  // ../../node_modules/ktx-parse/dist/ktx-parse.modern.js
+  var t, n, i, s, a, r, o, l, f;
+  var init_ktx_parse_modern = __esm({
+    "../../node_modules/ktx-parse/dist/ktx-parse.modern.js"() {
+      t = new Uint8Array([0]);
+      !function(t2) {
+        t2[t2.NONE = 0] = "NONE", t2[t2.BASISLZ = 1] = "BASISLZ", t2[t2.ZSTD = 2] = "ZSTD", t2[t2.ZLIB = 3] = "ZLIB";
+      }(n || (n = {})), function(t2) {
+        t2[t2.BASICFORMAT = 0] = "BASICFORMAT";
+      }(i || (i = {})), function(t2) {
+        t2[t2.UNSPECIFIED = 0] = "UNSPECIFIED", t2[t2.ETC1S = 163] = "ETC1S", t2[t2.UASTC = 166] = "UASTC";
+      }(s || (s = {})), function(t2) {
+        t2[t2.UNSPECIFIED = 0] = "UNSPECIFIED", t2[t2.SRGB = 1] = "SRGB";
+      }(a || (a = {})), function(t2) {
+        t2[t2.UNSPECIFIED = 0] = "UNSPECIFIED", t2[t2.LINEAR = 1] = "LINEAR", t2[t2.SRGB = 2] = "SRGB", t2[t2.ITU = 3] = "ITU", t2[t2.NTSC = 4] = "NTSC", t2[t2.SLOG = 5] = "SLOG", t2[t2.SLOG2 = 6] = "SLOG2";
+      }(r || (r = {})), function(t2) {
+        t2[t2.ALPHA_STRAIGHT = 0] = "ALPHA_STRAIGHT", t2[t2.ALPHA_PREMULTIPLIED = 1] = "ALPHA_PREMULTIPLIED";
+      }(o || (o = {})), function(t2) {
+        t2[t2.RGB = 0] = "RGB", t2[t2.RRR = 3] = "RRR", t2[t2.GGG = 4] = "GGG", t2[t2.AAA = 15] = "AAA";
+      }(l || (l = {})), function(t2) {
+        t2[t2.RGB = 0] = "RGB", t2[t2.RGBA = 3] = "RGBA", t2[t2.RRR = 4] = "RRR", t2[t2.RRRG = 5] = "RRRG";
+      }(f || (f = {}));
     }
-    throw new Error("toDataView");
+  });
+
+  // ../textures/src/lib/parsers/parse-ktx.ts
+  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;
   }
-  var BIG_ENDIAN, LITTLE_ENDIAN;
-  var init_binary_image_api = __esm({
-    "../images/src/lib/category-api/binary-image-api.ts"() {
-      init_parse_isobmff_binary();
-      BIG_ENDIAN = false;
-      LITTLE_ENDIAN = true;
+  var KTX2_ID;
+  var init_parse_ktx = __esm({
+    "../textures/src/lib/parsers/parse-ktx.ts"() {
+      init_ktx_parse_modern();
+      KTX2_ID = [
+        171,
+        75,
+        84,
+        88,
+        32,
+        50,
+        48,
+        187,
+        13,
+        10,
+        26,
+        10
+      ];
     }
   });
 
-  // ../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);
-  }
-  var init_parse_to_node_image = __esm({
-    "../images/src/lib/parsers/parse-to-node-image.ts"() {
-      init_src2();
-      init_binary_image_api();
+  // ../textures/src/lib/parsers/parse-basis.ts
+  async function parseBasis(data, options) {
+    if (options.basis.containerFormat === "auto") {
+      if (isKTX(data)) {
+        const fileConstructors = await loadBasisEncoderModule(options);
+        return parseKTX2File(fileConstructors.KTX2File, data, options);
+      }
+      const { BasisFile } = await loadBasisTrascoderModule(options);
+      return parseBasisFile(BasisFile, data, options);
     }
-  });
-
-  // ../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;
+    switch (options.basis.module) {
+      case "encoder":
+        const fileConstructors = await loadBasisEncoderModule(options);
+        switch (options.basis.containerFormat) {
+          case "ktx2":
+            return parseKTX2File(fileConstructors.KTX2File, data, options);
+          case "basis":
+          default:
+            return parseBasisFile(fileConstructors.BasisFile, data, options);
+        }
+      case "transcoder":
       default:
-        assert2(false);
-    }
-    if (imageType === "data") {
-      image = getImageData(image);
+        const { BasisFile } = await loadBasisTrascoderModule(options);
+        return parseBasisFile(BasisFile, data, options);
     }
-    return image;
   }
-  function getLoadableImageType(type) {
-    switch (type) {
-      case "auto":
-      case "data":
-        return getDefaultImageType();
-      default:
-        isImageTypeSupported(type);
-        return type;
+  function parseBasisFile(BasisFile, data, options) {
+    const basisFile = new BasisFile(new Uint8Array(data));
+    try {
+      if (!basisFile.startTranscoding()) {
+        throw new Error("Failed to start basis transcoding");
+      }
+      const imageCount = basisFile.getNumImages();
+      const images = [];
+      for (let imageIndex = 0; imageIndex < imageCount; imageIndex++) {
+        const levelsCount = basisFile.getNumLevels(imageIndex);
+        const levels = [];
+        for (let levelIndex = 0; levelIndex < levelsCount; levelIndex++) {
+          levels.push(transcodeImage(basisFile, imageIndex, levelIndex, options));
+        }
+        images.push(levels);
+      }
+      return images;
+    } finally {
+      basisFile.close();
+      basisFile.delete();
     }
   }
-  var init_parse_image = __esm({
-    "../images/src/lib/parsers/parse-image.ts"() {
-      init_src2();
-      init_image_type();
-      init_parsed_image_api();
-      init_parse_to_image();
-      init_parse_to_image_bitmap();
-      init_parse_to_node_image();
-    }
-  });
-
-  // ../images/src/image-loader.ts
-  var EXTENSIONS, MIME_TYPES, DEFAULT_IMAGE_LOADER_OPTIONS, ImageLoader;
-  var init_image_loader = __esm({
-    "../images/src/image-loader.ts"() {
-      init_version6();
-      init_parse_image();
-      init_binary_image_api();
-      EXTENSIONS = ["png", "jpg", "jpeg", "gif", "webp", "bmp", "ico", "svg", "avif"];
-      MIME_TYPES = [
-        "image/png",
-        "image/jpeg",
-        "image/gif",
-        "image/webp",
-        "image/avif",
-        "image/bmp",
-        "image/vnd.microsoft.icon",
-        "image/svg+xml"
-      ];
-      DEFAULT_IMAGE_LOADER_OPTIONS = {
-        image: {
-          type: "auto",
-          decode: true
-        }
-      };
-      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
-      };
+  function transcodeImage(basisFile, imageIndex, levelIndex, options) {
+    const width = basisFile.getImageWidth(imageIndex, levelIndex);
+    const height = basisFile.getImageHeight(imageIndex, levelIndex);
+    const hasAlpha = basisFile.getHasAlpha();
+    const { compressed, format, basisFormat } = getBasisOptions(options, hasAlpha);
+    const decodedSize = basisFile.getImageTranscodedSizeInBytes(imageIndex, levelIndex, basisFormat);
+    const decodedData = new Uint8Array(decodedSize);
+    if (!basisFile.transcodeImage(decodedData, imageIndex, levelIndex, basisFormat, 0, 0)) {
+      throw new Error("failed to start Basis transcoding");
     }
-  });
-
-  // ../images/src/lib/category-api/image-format.ts
-  function isImageFormatSupported(mimeType) {
-    if (mimeTypeSupportedSync[mimeType] === void 0) {
-      const supported = isBrowser ? checkBrowserImageFormatSupport(mimeType) : checkNodeImageFormatSupport(mimeType);
-      mimeTypeSupportedSync[mimeType] = supported;
+    return {
+      width,
+      height,
+      data: decodedData,
+      compressed,
+      format,
+      hasAlpha
+    };
+  }
+  function parseKTX2File(KTX2File, data, options) {
+    const ktx2File = new KTX2File(new Uint8Array(data));
+    try {
+      if (!ktx2File.startTranscoding()) {
+        throw new Error("failed to start KTX2 transcoding");
+      }
+      const levelsCount = ktx2File.getLevels();
+      const levels = [];
+      for (let levelIndex = 0; levelIndex < levelsCount; levelIndex++) {
+        levels.push(transcodeKTX2Image(ktx2File, levelIndex, options));
+        break;
+      }
+      return [levels];
+    } finally {
+      ktx2File.close();
+      ktx2File.delete();
     }
-    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 transcodeKTX2Image(ktx2File, levelIndex, options) {
+    const { alphaFlag, height, width } = ktx2File.getImageLevelInfo(levelIndex, 0, 0);
+    const { compressed, format, basisFormat } = getBasisOptions(options, alphaFlag);
+    const decodedSize = ktx2File.getImageTranscodedSizeInBytes(levelIndex, 0, 0, basisFormat);
+    const decodedData = new Uint8Array(decodedSize);
+    if (!ktx2File.transcodeImage(decodedData, levelIndex, 0, 0, basisFormat, 0, -1, -1)) {
+      throw new Error("Failed to transcode KTX2 image");
+    }
+    return {
+      width,
+      height,
+      data: decodedData,
+      compressed,
+      levelSize: decodedSize,
+      hasAlpha: alphaFlag,
+      format
+    };
   }
-  function checkBrowserImageFormatSupport(mimeType) {
-    switch (mimeType) {
-      case "image/avif":
-      case "image/webp":
-        return testBrowserImageFormatSupport(mimeType);
-      default:
-        return true;
+  function getBasisOptions(options, hasAlpha) {
+    let format = options && options.basis && options.basis.format;
+    if (format === "auto") {
+      format = selectSupportedBasisFormat();
+    }
+    if (typeof format === "object") {
+      format = hasAlpha ? format.alpha : format.noAlpha;
     }
+    format = format.toLowerCase();
+    return OutputFormat[format];
   }
-  function testBrowserImageFormatSupport(mimeType) {
-    try {
-      const element = document.createElement("canvas");
-      const dataURL = element.toDataURL(mimeType);
-      return dataURL.indexOf(`data:${mimeType}`) === 0;
-    } catch {
-      return false;
+  function selectSupportedBasisFormat() {
+    const supportedFormats = getSupportedGPUTextureFormats();
+    if (supportedFormats.has("astc")) {
+      return "astc-4x4";
+    } else if (supportedFormats.has("dxt")) {
+      return {
+        alpha: "bc3",
+        noAlpha: "bc1"
+      };
+    } else if (supportedFormats.has("pvrtc")) {
+      return {
+        alpha: "pvrtc1-4-rgba",
+        noAlpha: "pvrtc1-4-rgb"
+      };
+    } else if (supportedFormats.has("etc1")) {
+      return "etc1";
+    } else if (supportedFormats.has("etc2")) {
+      return "etc2";
     }
+    return "rgb565";
   }
-  var mimeTypeSupportedSync;
-  var init_image_format = __esm({
-    "../images/src/lib/category-api/image-format.ts"() {
-      init_src2();
-      mimeTypeSupportedSync = {};
+  var OutputFormat;
+  var init_parse_basis = __esm({
+    "../textures/src/lib/parsers/parse-basis.ts"() {
+      init_basis_module_loader();
+      init_gl_extensions();
+      init_texture_formats();
+      init_parse_ktx();
+      OutputFormat = {
+        etc1: {
+          basisFormat: 0,
+          compressed: true,
+          format: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGB_ETC1_WEBGL
+        },
+        etc2: { basisFormat: 1, compressed: true },
+        bc1: {
+          basisFormat: 2,
+          compressed: true,
+          format: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGB_S3TC_DXT1_EXT
+        },
+        bc3: {
+          basisFormat: 3,
+          compressed: true,
+          format: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_S3TC_DXT5_EXT
+        },
+        bc4: { basisFormat: 4, compressed: true },
+        bc5: { basisFormat: 5, compressed: true },
+        "bc7-m6-opaque-only": { basisFormat: 6, compressed: true },
+        "bc7-m5": { basisFormat: 7, compressed: true },
+        "pvrtc1-4-rgb": {
+          basisFormat: 8,
+          compressed: true,
+          format: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGB_PVRTC_4BPPV1_IMG
+        },
+        "pvrtc1-4-rgba": {
+          basisFormat: 9,
+          compressed: true,
+          format: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_PVRTC_4BPPV1_IMG
+        },
+        "astc-4x4": {
+          basisFormat: 10,
+          compressed: true,
+          format: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_4X4_KHR
+        },
+        "atc-rgb": { basisFormat: 11, compressed: true },
+        "atc-rgba-interpolated-alpha": { basisFormat: 12, compressed: true },
+        rgba32: { basisFormat: 13, compressed: false },
+        rgb565: { basisFormat: 14, compressed: false },
+        bgr565: { basisFormat: 15, compressed: false },
+        rgba4444: { basisFormat: 16, compressed: false }
+      };
     }
   });
 
-  // ../images/src/index.ts
-  var init_src8 = __esm({
-    "../images/src/index.ts"() {
-      init_image_loader();
-      init_binary_image_api();
-      init_image_format();
+  // ../textures/src/basis-loader.ts
+  var BasisWorkerLoader, BasisLoader;
+  var init_basis_loader = __esm({
+    "../textures/src/basis-loader.ts"() {
+      init_version6();
+      init_parse_basis();
+      BasisWorkerLoader = {
+        name: "Basis",
+        id: "basis",
+        module: "textures",
+        version: VERSION8,
+        worker: true,
+        extensions: ["basis", "ktx2"],
+        mimeTypes: ["application/octet-stream", "image/ktx2"],
+        tests: ["sB"],
+        binary: true,
+        options: {
+          basis: {
+            format: "auto",
+            libraryPath: "libs/",
+            containerFormat: "auto",
+            module: "transcoder"
+          }
+        }
+      };
+      BasisLoader = {
+        ...BasisWorkerLoader,
+        parse: parseBasis
+      };
     }
   });
 
@@ -9784,6 +9835,119 @@
     }
   });
 
+  // ../gltf/src/lib/parsers/parse-glb.ts
+  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 version = dataView.getUint32(byteOffset + 4, LITTLE_ENDIAN2);
+    const byteLength = dataView.getUint32(byteOffset + 8, LITTLE_ENDIAN2);
+    Object.assign(glb, {
+      header: {
+        byteOffset,
+        byteLength,
+        hasBinChunk: false
+      },
+      type,
+      version,
+      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);
+  }
+  var LITTLE_ENDIAN2, MAGIC_glTF, GLB_FILE_HEADER_SIZE, GLB_CHUNK_HEADER_SIZE, GLB_CHUNK_TYPE_JSON, GLB_CHUNK_TYPE_BIN, GLB_V1_CONTENT_FORMAT_JSON, GLB_CHUNK_TYPE_JSON_XVIZ_DEPRECATED, GLB_CHUNK_TYPE_BIX_XVIZ_DEPRECATED;
+  var init_parse_glb = __esm({
+    "../gltf/src/lib/parsers/parse-glb.ts"() {
+      init_src2();
+      LITTLE_ENDIAN2 = true;
+      MAGIC_glTF = 1735152710;
+      GLB_FILE_HEADER_SIZE = 12;
+      GLB_CHUNK_HEADER_SIZE = 8;
+      GLB_CHUNK_TYPE_JSON = 1313821514;
+      GLB_CHUNK_TYPE_BIN = 5130562;
+      GLB_V1_CONTENT_FORMAT_JSON = 0;
+      GLB_CHUNK_TYPE_JSON_XVIZ_DEPRECATED = 0;
+      GLB_CHUNK_TYPE_BIX_XVIZ_DEPRECATED = 1;
+    }
+  });
+
   // ../gltf/src/lib/gltf-utils/resolve-url.ts
   function resolveUrl(url, options) {
     const absolute = url.startsWith("data:") || url.startsWith("http:") || url.startsWith("https:");
@@ -9838,10 +10002,24 @@
     assert7(byteLength >= 0 && byteLength <= bufferView.byteLength);
     return { ArrayType, length: length4, byteLength };
   }
-  var TYPES, ARRAY_CONSTRUCTOR_TO_WEBGL_CONSTANT, ARRAY_TO_COMPONENT_TYPE, ATTRIBUTE_TYPE_TO_COMPONENTS, ATTRIBUTE_COMPONENT_TYPE_TO_BYTE_SIZE, ATTRIBUTE_COMPONENT_TYPE_TO_ARRAY;
+  function getMemoryUsageGLTF(gltf) {
+    let { images, bufferViews } = gltf;
+    images = images || [];
+    bufferViews = bufferViews || [];
+    const imageBufferViews = images.map((i2) => i2.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);
+  }
+  var MIPMAP_FACTOR, TYPES, ARRAY_CONSTRUCTOR_TO_WEBGL_CONSTANT, ARRAY_TO_COMPONENT_TYPE, ATTRIBUTE_TYPE_TO_COMPONENTS, ATTRIBUTE_COMPONENT_TYPE_TO_BYTE_SIZE, ATTRIBUTE_COMPONENT_TYPE_TO_ARRAY;
   var init_gltf_utils = __esm({
     "../gltf/src/lib/gltf-utils/gltf-utils.ts"() {
       init_assert6();
+      MIPMAP_FACTOR = 1.33;
       TYPES = ["SCALAR", "VEC2", "VEC3", "VEC4"];
       ARRAY_CONSTRUCTOR_TO_WEBGL_CONSTANT = [
         [Int8Array, 5120],
@@ -9882,25 +10060,31 @@
   });
 
   // ../gltf/src/lib/api/gltf-scenegraph.ts
-  var DEFAULT_GLTF_JSON, GLTFScenegraph;
+  function makeDefaultGLTFJson() {
+    return {
+      asset: {
+        version: "2.0",
+        generator: "loaders.gl"
+      },
+      buffers: [],
+      extensions: {},
+      extensionsRequired: [],
+      extensionsUsed: []
+    };
+  }
+  var GLTFScenegraph;
   var init_gltf_scenegraph = __esm({
     "../gltf/src/lib/api/gltf-scenegraph.ts"() {
       init_src8();
       init_src2();
       init_assert6();
       init_gltf_utils();
-      DEFAULT_GLTF_JSON = {
-        asset: {
-          version: "2.0",
-          generator: "loaders.gl"
-        },
-        buffers: []
-      };
       GLTFScenegraph = class {
         constructor(gltf) {
-          this.gltf = gltf || {
-            json: { ...DEFAULT_GLTF_JSON },
-            buffers: []
+          this.gltf = {
+            json: gltf?.json || makeDefaultGLTFJson(),
+            buffers: gltf?.buffers || [],
+            images: gltf?.images || []
           };
           this.sourceBuffers = [];
           this.byteLength = 0;
@@ -9920,10 +10104,15 @@
           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);
@@ -10030,10 +10219,15 @@
           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 = {}) {
           assert7(extensionData);
@@ -10062,8 +10256,15 @@
           }
         }
         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);
@@ -10071,16 +10272,6 @@
           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;
@@ -10149,14 +10340,14 @@
           this.json.images.push(glTFImage);
           return this.json.images.length - 1;
         }
-        addBufferView(buffer) {
+        addBufferView(buffer, bufferIndex = 0, byteOffset = this.byteLength) {
           const byteLength = buffer.byteLength;
           assert7(Number.isFinite(byteLength));
           this.sourceBuffers = this.sourceBuffers || [];
           this.sourceBuffers.push(buffer);
           const glTFBufferView = {
-            buffer: 0,
-            byteOffset: this.byteLength,
+            buffer: bufferIndex,
+            byteOffset,
             byteLength
           };
           this.byteLength += padToNBytes(byteLength, 4);
@@ -10515,9 +10706,8 @@
       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;
   }
   var EXT_MESHOPT_COMPRESSION, name;
   var init_EXT_meshopt_compression = __esm({
@@ -10576,8 +10766,8 @@
       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);
   }
@@ -10710,6 +10900,7 @@
     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) {
@@ -10792,8 +10983,8 @@
   });
   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 || [];
@@ -10927,10 +11118,10 @@
   }
   function makeTransformationMatrix(extensionData) {
     const { offset = [0, 0], rotation = 0, scale: scale5 = [1, 1] } = extensionData;
-    const translationMatirx = new 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 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(scale5[0], 0, 0, 0, scale5[1], 0, 0, 0, 1);
-    return translationMatirx.multiplyRight(rotationMatirx).multiplyRight(scaleMatrix);
+    return translationMatrix.multiplyRight(rotationMatrix).multiplyRight(scaleMatrix);
   }
   var EXT_MESHOPT_TRANSFORM, name5, scratchVector7, scratchRotationMatrix, scratchScaleMatrix;
   var init_KHR_texture_transform = __esm({
@@ -11112,18 +11303,16 @@
     decode: () => decode8,
     name: () => name9
   });
-  async function decode8(gltfData) {
+  async function decode8(gltfData, options) {
     const scenegraph = new GLTFScenegraph(gltfData);
-    decodeExtFeatureMetadata(scenegraph);
+    decodeExtFeatureMetadata(scenegraph, options);
   }
-  function decodeExtFeatureMetadata(scenegraph) {
+  function decodeExtFeatureMetadata(scenegraph, options) {
     const extension = scenegraph.getExtension(EXT_FEATURE_METADATA);
-    const schemaClasses = extension?.schema?.classes;
-    const featureTables = extension?.featureTables;
-    const featureTextures = extension?.featureTextures;
-    if (featureTextures) {
-      console.warn('featureTextures is not yet supported in the "EXT_feature_metadata" extension.');
-    }
+    if (!extension)
+      return;
+    const schemaClasses = extension.schema?.classes;
+    const { featureTables } = extension;
     if (schemaClasses && featureTables) {
       for (const schemaName in schemaClasses) {
         const schemaClass = schemaClasses[schemaName];
@@ -11133,6 +11322,16 @@
         }
       }
     }
+    const { featureTextures } = extension;
+    if (schemaClasses && featureTextures && options.gltf?.loadImages) {
+      for (const schemaName in schemaClasses) {
+        const schemaClass = schemaClasses[schemaName];
+        const featureTexture = findFeatureTextureByName(featureTextures, schemaName);
+        if (featureTexture) {
+          handleFeatureTextureProperties(scenegraph, featureTexture, schemaClass);
+        }
+      }
+    }
   }
   function handleFeatureTableProperties(scenegraph, featureTable, schemaClass) {
     for (const propertyName in schemaClass.properties) {
@@ -11145,19 +11344,128 @@
       }
     }
   }
+  function handleFeatureTextureProperties(scenegraph, featureTexture, schemaClass) {
+    const attributeName = featureTexture.class;
+    for (const propertyName in schemaClass.properties) {
+      const featureTextureProperty = featureTexture?.properties?.[propertyName];
+      if (featureTextureProperty) {
+        const data = getPropertyDataFromTexture(scenegraph, featureTextureProperty, attributeName);
+        featureTextureProperty.data = data;
+      }
+    }
+  }
   function getPropertyDataFromBinarySource(scenegraph, schemaProperty, numberOfFeatures, featureTableProperty) {
     const bufferView = featureTableProperty.bufferView;
-    let data = scenegraph.getTypedArrayForBufferView(bufferView);
+    const dataArray = scenegraph.getTypedArrayForBufferView(bufferView);
     switch (schemaProperty.type) {
       case "STRING": {
         const stringOffsetBufferView = featureTableProperty.stringOffsetBufferView;
         const offsetsData = scenegraph.getTypedArrayForBufferView(stringOffsetBufferView);
-        data = getStringAttributes(data, offsetsData, numberOfFeatures);
-        break;
+        return getStringAttributes(dataArray, offsetsData, numberOfFeatures);
       }
       default:
     }
-    return data;
+    return dataArray;
+  }
+  function getPropertyDataFromTexture(scenegraph, featureTextureProperty, attributeName) {
+    const json = scenegraph.gltf.json;
+    if (!json.meshes) {
+      return [];
+    }
+    const featureTextureTable = [];
+    for (const mesh of json.meshes) {
+      for (const primitive of mesh.primitives) {
+        processPrimitiveTextures(scenegraph, attributeName, featureTextureProperty, featureTextureTable, primitive);
+      }
+    }
+    return featureTextureTable;
+  }
+  function processPrimitiveTextures(scenegraph, attributeName, featureTextureProperty, featureTextureTable, primitive) {
+    const json = scenegraph.gltf.json;
+    const textureData = [];
+    const texCoordAccessorKey = `TEXCOORD_${featureTextureProperty.texture.texCoord}`;
+    const texCoordAccessorIndex = primitive.attributes[texCoordAccessorKey];
+    const texCoordBufferView = scenegraph.getBufferView(texCoordAccessorIndex);
+    const texCoordArray = scenegraph.getTypedArrayForBufferView(texCoordBufferView);
+    const textureCoordinates = new Float32Array(texCoordArray.buffer, texCoordArray.byteOffset, texCoordArray.length / 4);
+    const textureIndex = featureTextureProperty.texture.index;
+    const texture = json.textures?.[textureIndex];
+    const imageIndex = texture?.source;
+    if (typeof imageIndex !== "undefined") {
+      const image = json.images?.[imageIndex];
+      const mimeType = image?.mimeType;
+      const parsedImage = scenegraph.gltf.images?.[imageIndex];
+      if (parsedImage) {
+        for (let index = 0; index < textureCoordinates.length; index += 2) {
+          const value = getImageValueByCoordinates(parsedImage, mimeType, textureCoordinates, index, featureTextureProperty.channels);
+          textureData.push(value);
+        }
+      }
+    }
+    const featureIndices = [];
+    for (const texelData of textureData) {
+      let index = featureTextureTable.findIndex((item) => item === texelData);
+      if (index === -1) {
+        index = featureTextureTable.push(texelData) - 1;
+      }
+      featureIndices.push(index);
+    }
+    const typedArray = new Uint32Array(featureIndices);
+    const bufferIndex = scenegraph.gltf.buffers.push({
+      arrayBuffer: typedArray.buffer,
+      byteOffset: 0,
+      byteLength: typedArray.byteLength
+    }) - 1;
+    const bufferViewIndex = scenegraph.addBufferView(typedArray, bufferIndex, 0);
+    const accessorIndex = scenegraph.addAccessor(bufferViewIndex, {
+      size: 1,
+      componentType: getComponentTypeFromArray(typedArray),
+      count: typedArray.length
+    });
+    primitive.attributes[attributeName] = accessorIndex;
+  }
+  function getImageValueByCoordinates(parsedImage, mimeType, textureCoordinates, index, channels) {
+    const CHANNELS_MAP = {
+      r: { offset: 0, shift: 0 },
+      g: { offset: 1, shift: 8 },
+      b: { offset: 2, shift: 16 },
+      a: { offset: 3, shift: 24 }
+    };
+    const u = textureCoordinates[index];
+    const v = textureCoordinates[index + 1];
+    let components = 1;
+    if (mimeType && (mimeType.indexOf("image/jpeg") !== -1 || mimeType.indexOf("image/png") !== -1))
+      components = 4;
+    const offset = coordinatesToOffset(u, v, parsedImage, components);
+    let value = 0;
+    for (const c of channels) {
+      const map2 = CHANNELS_MAP[c];
+      const val = getVal(parsedImage, offset + map2.offset);
+      value |= val << map2.shift;
+    }
+    return value;
+  }
+  function getVal(parsedImage, offset) {
+    const imageData = getImageData(parsedImage);
+    if (imageData.data.length <= offset) {
+      throw new Error(`${imageData.data.length} <= ${offset}`);
+    }
+    return imageData.data[offset];
+  }
+  function coordinatesToOffset(u, v, parsedImage, componentsCount = 1) {
+    const w = parsedImage.width;
+    const iX = emod(u) * (w - 1);
+    const indX = Math.round(iX);
+    const h = parsedImage.height;
+    const iY = emod(v) * (h - 1);
+    const indY = Math.round(iY);
+    const components = parsedImage.components ? parsedImage.components : componentsCount;
+    const offset = (indY * w + indX) * components;
+    return offset;
+  }
+  function emod(n2) {
+    const a2 = (n2 % 1 + 1) % 1;
+    return a2;
   }
   function findFeatureTableByName(featureTables, schemaClassName) {
     for (const featureTableName in featureTables) {
@@ -11168,6 +11476,15 @@
     }
     return null;
   }
+  function findFeatureTextureByName(featureTextures, schemaClassName) {
+    for (const featureTexturesName in featureTextures) {
+      const featureTable = featureTextures[featureTexturesName];
+      if (featureTable.class === schemaClassName) {
+        return featureTable;
+      }
+    }
+    return null;
+  }
   function getStringAttributes(data, offsetsData, stringsCount) {
     const stringsArray = [];
     const textDecoder = new TextDecoder("utf8");
@@ -11186,6 +11503,8 @@
   var init_EXT_feature_metadata = __esm({
     "../gltf/src/lib/extensions/deprecated/EXT_feature_metadata.ts"() {
       init_gltf_scenegraph();
+      init_src8();
+      init_gltf_utils();
       EXT_FEATURE_METADATA = "EXT_feature_metadata";
       name9 = EXT_FEATURE_METADATA;
     }
@@ -11459,7 +11778,193 @@
     }
   });
 
+  // ../gltf/src/lib/parsers/parse-gltf.ts
+  async function parseGLTF(gltf, arrayBufferOrString, byteOffset = 0, options, context) {
+    parseGLTFContainerSync(gltf, arrayBufferOrString, byteOffset, options);
+    normalizeGLTFV1(gltf, { normalize: options?.gltf?.normalize });
+    preprocessExtensions(gltf, options, context);
+    if (options?.gltf?.loadBuffers && gltf.json.buffers) {
+      await loadBuffers(gltf, options, context);
+    }
+    if (options?.gltf?.loadImages) {
+      await loadImages(gltf, options, context);
+    }
+    await decodeExtensions(gltf, options, context);
+    return gltf;
+  }
+  function parseGLTFContainerSync(gltf, data, byteOffset, options) {
+    if (options.uri) {
+      gltf.baseUri = options.uri;
+    }
+    if (data instanceof ArrayBuffer && !isGLB(data, byteOffset, options)) {
+      const textDecoder = new TextDecoder();
+      data = textDecoder.decode(data);
+    }
+    if (typeof data === "string") {
+      gltf.json = parseJSON(data);
+    } else if (data instanceof ArrayBuffer) {
+      const glb = {};
+      byteOffset = parseGLBSync(glb, data, byteOffset, options.glb);
+      assert7(glb.type === "glTF", `Invalid GLB magic string ${glb.type}`);
+      gltf._glb = glb;
+      gltf.json = glb.json;
+    } else {
+      assert7(false, "GLTF: must be ArrayBuffer or string");
+    }
+    const buffers = gltf.json.buffers || [];
+    gltf.buffers = new Array(buffers.length).fill(null);
+    if (gltf._glb && gltf._glb.header.hasBinChunk) {
+      const { binChunks } = gltf._glb;
+      gltf.buffers[0] = {
+        arrayBuffer: binChunks[0].arrayBuffer,
+        byteOffset: binChunks[0].byteOffset,
+        byteLength: binChunks[0].byteLength
+      };
+    }
+    const images = gltf.json.images || [];
+    gltf.images = new Array(images.length).fill({});
+  }
+  async function loadBuffers(gltf, options, context) {
+    const buffers = gltf.json.buffers || [];
+    for (let i2 = 0; i2 < buffers.length; ++i2) {
+      const buffer = buffers[i2];
+      if (buffer.uri) {
+        const { fetch: fetch2 } = context;
+        assert7(fetch2);
+        const uri = resolveUrl(buffer.uri, options);
+        const response = await context?.fetch?.(uri);
+        const arrayBuffer = await response?.arrayBuffer?.();
+        gltf.buffers[i2] = {
+          arrayBuffer,
+          byteOffset: 0,
+          byteLength: arrayBuffer.byteLength
+        };
+        delete buffer.uri;
+      } else if (gltf.buffers[i2] === null) {
+        gltf.buffers[i2] = {
+          arrayBuffer: new ArrayBuffer(buffer.byteLength),
+          byteOffset: 0,
+          byteLength: buffer.byteLength
+        };
+      }
+    }
+  }
+  async function loadImages(gltf, options, context) {
+    const imageIndices = getReferencesImageIndices(gltf);
+    const images = gltf.json.images || [];
+    const promises = [];
+    for (const imageIndex of imageIndices) {
+      promises.push(loadImage(gltf, images[imageIndex], imageIndex, options, context));
+    }
+    return await Promise.all(promises);
+  }
+  function getReferencesImageIndices(gltf) {
+    const imageIndices = new Set();
+    const textures = gltf.json.textures || [];
+    for (const texture of textures) {
+      if (texture.source !== void 0) {
+        imageIndices.add(texture.source);
+      }
+    }
+    return Array.from(imageIndices).sort();
+  }
+  async function loadImage(gltf, image, index, options, context) {
+    const { fetch: fetch2, parse: parse5 } = context;
+    let arrayBuffer;
+    if (image.uri && !image.hasOwnProperty("bufferView")) {
+      const uri = resolveUrl(image.uri, options);
+      const response = await fetch2(uri);
+      arrayBuffer = await response.arrayBuffer();
+      image.bufferView = {
+        data: arrayBuffer
+      };
+    }
+    if (Number.isFinite(image.bufferView)) {
+      const array = getTypedArrayForBufferView(gltf.json, gltf.buffers, image.bufferView);
+      arrayBuffer = sliceArrayBuffer(array.buffer, array.byteOffset, array.byteLength);
+    }
+    assert7(arrayBuffer, "glTF image has no data");
+    let parsedImage = await parse5(arrayBuffer, [ImageLoader, BasisLoader], { mimeType: image.mimeType, basis: options.basis || { format: selectSupportedBasisFormat() } }, context);
+    if (parsedImage && parsedImage[0]) {
+      parsedImage = {
+        compressed: true,
+        mipmaps: false,
+        width: parsedImage[0].width,
+        height: parsedImage[0].height,
+        data: parsedImage[0]
+      };
+    }
+    gltf.images = gltf.images || [];
+    gltf.images[index] = parsedImage;
+  }
+  var init_parse_gltf = __esm({
+    "../gltf/src/lib/parsers/parse-gltf.ts"() {
+      init_src2();
+      init_src8();
+      init_src9();
+      init_assert6();
+      init_parse_glb();
+      init_resolve_url();
+      init_get_typed_array();
+      init_gltf_extensions();
+      init_normalize_gltf_v1();
+    }
+  });
+
+  // ../gltf/src/gltf-loader.ts
+  async function parse3(arrayBuffer, options = {}, context) {
+    options = { ...GLTFLoader.options, ...options };
+    options.gltf = { ...GLTFLoader.options.gltf, ...options.gltf };
+    const { byteOffset = 0 } = options;
+    const gltf = {};
+    return await parseGLTF(gltf, arrayBuffer, byteOffset, options, context);
+  }
+  var GLTFLoader;
+  var init_gltf_loader = __esm({
+    "../gltf/src/gltf-loader.ts"() {
+      init_version4();
+      init_parse_gltf();
+      GLTFLoader = {
+        name: "glTF",
+        id: "gltf",
+        module: "gltf",
+        version: VERSION6,
+        extensions: ["gltf", "glb"],
+        mimeTypes: ["model/gltf+json", "model/gltf-binary"],
+        text: true,
+        binary: true,
+        tests: ["glTF"],
+        parse: parse3,
+        options: {
+          gltf: {
+            normalize: true,
+            loadBuffers: true,
+            loadImages: true,
+            decompressMeshes: true
+          },
+          log: console
+        },
+        deprecatedOptions: {
+          fetchImages: "gltf.loadImages",
+          createImages: "gltf.loadImages",
+          decompress: "gltf.decompressMeshes",
+          postProcess: "gltf.postProcess",
+          gltf: {
+            decompress: "gltf.decompressMeshes",
+            postProcess: "removed in v4"
+          }
+        }
+      };
+    }
+  });
+
   // ../gltf/src/lib/api/post-process-gltf.ts
+  function makeDefaultSampler() {
+    return {
+      id: "default-sampler",
+      parameters: DEFAULT_SAMPLER_PARAMETERS
+    };
+  }
   function getBytesFromComponentType(componentType) {
     return BYTES2[componentType];
   }
@@ -11469,7 +11974,7 @@
   function postProcessGLTF(gltf, options) {
     return new GLTFPostProcessor().postProcess(gltf, options);
   }
-  var COMPONENTS2, BYTES2, GL_SAMPLER, SAMPLER_PARAMETER_GLTF_TO_GL, DEFAULT_SAMPLER, GLTFPostProcessor;
+  var COMPONENTS2, BYTES2, GL_SAMPLER, SAMPLER_PARAMETER_GLTF_TO_GL, DEFAULT_SAMPLER_PARAMETERS, GLTFPostProcessor;
   var init_post_process_gltf = __esm({
     "../gltf/src/lib/api/post-process-gltf.ts"() {
       init_assert6();
@@ -11506,7 +12011,7 @@
         wrapS: GL_SAMPLER.TEXTURE_WRAP_S,
         wrapT: GL_SAMPLER.TEXTURE_WRAP_T
       };
-      DEFAULT_SAMPLER = {
+      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,
@@ -11515,171 +12020,198 @@
       GLTFPostProcessor = class {
         constructor() {
           this.baseUri = "";
-          this.json = {};
           this.buffers = [];
           this.images = [];
         }
         postProcess(gltf, options = {}) {
-          const { json, buffers = [], images = [], baseUri = "" } = gltf;
+          const { json, buffers = [], images = [] } = gltf;
+          const { baseUri = "" } = gltf;
           assert7(json);
           this.baseUri = baseUri;
-          this.json = json;
           this.buffers = buffers;
           this.images = images;
-          this._resolveTree(this.json, options);
+          this.jsonUnprocessed = json;
+          this.json = this._resolveTree(gltf.json, options);
           return this.json;
         }
-        _resolveTree(json, options = {}) {
-          if (json.bufferViews) {
-            json.bufferViews = json.bufferViews.map((bufView, i2) => this._resolveBufferView(bufView, i2));
+        _resolveTree(gltf, options = {}) {
+          const json = { ...gltf };
+          this.json = json;
+          if (gltf.bufferViews) {
+            json.bufferViews = gltf.bufferViews.map((bufView, i2) => this._resolveBufferView(bufView, i2));
           }
-          if (json.images) {
-            json.images = json.images.map((image, i2) => this._resolveImage(image, i2));
+          if (gltf.images) {
+            json.images = gltf.images.map((image, i2) => this._resolveImage(image, i2));
           }
-          if (json.samplers) {
-            json.samplers = json.samplers.map((sampler, i2) => this._resolveSampler(sampler, i2));
+          if (gltf.samplers) {
+            json.samplers = gltf.samplers.map((sampler, i2) => this._resolveSampler(sampler, i2));
           }
-          if (json.textures) {
-            json.textures = json.textures.map((texture, i2) => this._resolveTexture(texture, i2));
+          if (gltf.textures) {
+            json.textures = gltf.textures.map((texture, i2) => this._resolveTexture(texture, i2));
           }
-          if (json.accessors) {
-            json.accessors = json.accessors.map((accessor, i2) => this._resolveAccessor(accessor, i2));
+          if (gltf.accessors) {
+            json.accessors = gltf.accessors.map((accessor, i2) => this._resolveAccessor(accessor, i2));
           }
-          if (json.materials) {
-            json.materials = json.materials.map((material, i2) => this._resolveMaterial(material, i2));
+          if (gltf.materials) {
+            json.materials = gltf.materials.map((material, i2) => this._resolveMaterial(material, i2));
           }
-          if (json.meshes) {
-            json.meshes = json.meshes.map((mesh, i2) => this._resolveMesh(mesh, i2));
+          if (gltf.meshes) {
+            json.meshes = gltf.meshes.map((mesh, i2) => this._resolveMesh(mesh, i2));
           }
-          if (json.nodes) {
-            json.nodes = json.nodes.map((node3, i2) => this._resolveNode(node3, i2));
+          if (gltf.nodes) {
+            json.nodes = gltf.nodes.map((node3, i2) => this._resolveNode(node3, i2));
+            json.nodes = json.nodes.map((node3, i2) => this._resolveNodeChildren(node3));
           }
-          if (json.skins) {
-            json.skins = json.skins.map((skin, i2) => this._resolveSkin(skin, i2));
+          if (gltf.skins) {
+            json.skins = gltf.skins.map((skin, i2) => this._resolveSkin(skin, i2));
           }
-          if (json.scenes) {
-            json.scenes = json.scenes.map((scene, i2) => this._resolveScene(scene, i2));
+          if (gltf.scenes) {
+            json.scenes = gltf.scenes.map((scene, i2) => this._resolveScene(scene, i2));
           }
-          if (json.scene !== void 0) {
+          if (typeof this.json.scene === "number" && json.scenes) {
             json.scene = json.scenes[this.json.scene];
           }
+          return json;
         }
         getScene(index) {
-          return this._get("scenes", index);
+          return this._get(this.json.scenes, index);
         }
         getNode(index) {
-          return this._get("nodes", index);
+          return this._get(this.json.nodes, index);
         }
         getSkin(index) {
-          return this._get("skins", index);
+          return this._get(this.json.skins, index);
         }
         getMesh(index) {
-          return this._get("meshes", index);
+          return this._get(this.json.meshes, index);
         }
         getMaterial(index) {
-          return this._get("materials", index);
+          return this._get(this.json.materials, index);
         }
         getAccessor(index) {
-          return this._get("accessors", index);
+          return this._get(this.json.accessors, index);
         }
         getCamera(index) {
-          return null;
+          return this._get(this.json.cameras, index);
         }
         getTexture(index) {
-          return this._get("textures", index);
+          return this._get(this.json.textures, index);
         }
         getSampler(index) {
-          return this._get("samplers", index);
+          return this._get(this.json.samplers, index);
         }
         getImage(index) {
-          return this._get("images", index);
+          return this._get(this.json.images, index);
         }
         getBufferView(index) {
-          return this._get("bufferViews", index);
+          return this._get(this.json.bufferViews, index);
         }
         getBuffer(index) {
-          return this._get("buffers", index);
+          return this._get(this.json.buffers, index);
         }
         _get(array, index) {
           if (typeof index === "object") {
             return index;
           }
-          const object = this.json[array] && this.json[array][index];
+          const object = array && 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((node3) => this.getNode(node3));
-          return scene;
+          return {
+            ...scene,
+            id: scene.id || `scene-${index}`,
+            nodes: (scene.nodes || []).map((node3) => this.getNode(node3))
+          };
         }
-        _resolveNode(node3, index) {
-          node3.id = node3.id || `node-${index}`;
-          if (node3.children) {
-            node3.children = node3.children.map((child) => this.getNode(child));
+        _resolveNode(gltfNode, index) {
+          const node3 = {
+            ...gltfNode,
+            id: gltfNode?.id || `node-${index}`
+          };
+          if (gltfNode.mesh !== void 0) {
+            node3.mesh = this.getMesh(gltfNode.mesh);
+          }
+          if (gltfNode.camera !== void 0) {
+            node3.camera = this.getCamera(gltfNode.camera);
           }
-          if (node3.mesh !== void 0) {
-            node3.mesh = this.getMesh(node3.mesh);
-          } else if (node3.meshes !== void 0 && node3.meshes.length) {
-            node3.mesh = node3.meshes.reduce((accum, meshIndex) => {
+          if (gltfNode.skin !== void 0) {
+            node3.skin = this.getSkin(gltfNode.skin);
+          }
+          if (gltfNode.meshes !== void 0 && gltfNode.meshes.length) {
+            node3.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: [] });
           }
-          if (node3.camera !== void 0) {
-            node3.camera = this.getCamera(node3.camera);
-          }
-          if (node3.skin !== void 0) {
-            node3.skin = this.getSkin(node3.skin);
+          return node3;
+        }
+        _resolveNodeChildren(node3) {
+          if (node3.children) {
+            node3.children = node3.children.map((child) => this.getNode(child));
           }
           return node3;
         }
-        _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 = {};
+        _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 (primitive.indices !== void 0) {
-                primitive.indices = this.getAccessor(primitive.indices);
+              if (gltfPrimitive.indices !== void 0) {
+                primitive.indices = this.getAccessor(gltfPrimitive.indices);
               }
-              if (primitive.material !== void 0) {
-                primitive.material = this.getMaterial(primitive.material);
+              if (gltfPrimitive.material !== void 0) {
+                primitive.material = this.getMaterial(gltfPrimitive.material);
               }
               return primitive;
             });
           }
           return mesh;
         }
-        _resolveMaterial(material, index) {
-          material.id = material.id || `material-${index}`;
+        _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.occlustionTexture = { ...material.occlustionTexture };
+            material.occlusionTexture = { ...material.occlusionTexture };
             material.occlusionTexture.texture = this.getTexture(material.occlusionTexture.index);
           }
           if (material.emissiveTexture) {
-            material.emmisiveTexture = { ...material.emmisiveTexture };
+            material.emissiveTexture = { ...material.emissiveTexture };
             material.emissiveTexture.texture = this.getTexture(material.emissiveTexture.index);
           }
           if (!material.emissiveFactor) {
-            material.emissiveFactor = material.emmisiveTexture ? [1, 1, 1] : [0, 0, 0];
+            material.emissiveFactor = material.emissiveTexture ? [1, 1, 1] : [0, 0, 0];
           }
           if (material.pbrMetallicRoughness) {
             material.pbrMetallicRoughness = { ...material.pbrMetallicRoughness };
@@ -11695,14 +12227,23 @@
           }
           return material;
         }
-        _resolveAccessor(accessor, index) {
-          accessor.id = accessor.id || `accessor-${index}`;
-          if (accessor.bufferView !== void 0) {
-            accessor.bufferView = this.getBufferView(accessor.bufferView);
+        _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);
           }
-          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);
@@ -11723,15 +12264,20 @@
           }
           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;
+        _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(sampler, index) {
-          sampler.id = sampler.id || `sampler-${index}`;
-          sampler.parameters = {};
+        _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) {
@@ -11743,337 +12289,44 @@
         _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);
-          }
+        _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(bufferView, index) {
-          const bufferIndex = bufferView.buffer;
-          const result = {
-            id: `bufferView-${index}`,
-            ...bufferView,
-            buffer: this.buffers[bufferIndex]
-          };
+        _resolveBufferView(gltfBufferView, index) {
+          const bufferIndex = gltfBufferView.buffer;
           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;
-        }
-      };
-    }
-  });
-
-  // ../gltf/src/lib/parsers/parse-glb.ts
-  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 version = dataView.getUint32(byteOffset + 4, LE);
-    const byteLength = dataView.getUint32(byteOffset + 8, LE);
-    Object.assign(glb, {
-      header: {
-        byteOffset,
-        byteLength,
-        hasBinChunk: false
-      },
-      type,
-      version,
-      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);
+          if (gltfBufferView.byteOffset) {
+            byteOffset += gltfBufferView.byteOffset;
           }
-          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);
-  }
-  var MAGIC_glTF, GLB_FILE_HEADER_SIZE, GLB_CHUNK_HEADER_SIZE, GLB_CHUNK_TYPE_JSON, GLB_CHUNK_TYPE_BIN, GLB_CHUNK_TYPE_JSON_XVIZ_DEPRECATED, GLB_CHUNK_TYPE_BIX_XVIZ_DEPRECATED, GLB_V1_CONTENT_FORMAT_JSON, LE;
-  var init_parse_glb = __esm({
-    "../gltf/src/lib/parsers/parse-glb.ts"() {
-      init_src2();
-      MAGIC_glTF = 1735152710;
-      GLB_FILE_HEADER_SIZE = 12;
-      GLB_CHUNK_HEADER_SIZE = 8;
-      GLB_CHUNK_TYPE_JSON = 1313821514;
-      GLB_CHUNK_TYPE_BIN = 5130562;
-      GLB_CHUNK_TYPE_JSON_XVIZ_DEPRECATED = 0;
-      GLB_CHUNK_TYPE_BIX_XVIZ_DEPRECATED = 1;
-      GLB_V1_CONTENT_FORMAT_JSON = 0;
-      LE = true;
-    }
-  });
-
-  // ../gltf/src/lib/parsers/parse-gltf.ts
-  async function parseGLTF(gltf, arrayBufferOrString, byteOffset = 0, options, context) {
-    parseGLTFContainerSync(gltf, arrayBufferOrString, byteOffset, options);
-    normalizeGLTFV1(gltf, { normalize: options?.gltf?.normalize });
-    preprocessExtensions(gltf, options, context);
-    const promises = [];
-    if (options?.gltf?.loadBuffers && gltf.json.buffers) {
-      await loadBuffers(gltf, options, context);
-    }
-    if (options?.gltf?.loadImages) {
-      const promise2 = loadImages(gltf, options, context);
-      promises.push(promise2);
-    }
-    const promise = decodeExtensions(gltf, options, context);
-    promises.push(promise);
-    await Promise.all(promises);
-    return options?.gltf?.postProcess ? postProcessGLTF(gltf, options) : gltf;
-  }
-  function parseGLTFContainerSync(gltf, data, byteOffset, options) {
-    if (options.uri) {
-      gltf.baseUri = options.uri;
-    }
-    if (data instanceof ArrayBuffer && !isGLB(data, byteOffset, options)) {
-      const textDecoder = new TextDecoder();
-      data = textDecoder.decode(data);
-    }
-    if (typeof data === "string") {
-      gltf.json = parseJSON(data);
-    } else if (data instanceof ArrayBuffer) {
-      const glb = {};
-      byteOffset = parseGLBSync(glb, data, byteOffset, options.glb);
-      assert7(glb.type === "glTF", `Invalid GLB magic string ${glb.type}`);
-      gltf._glb = glb;
-      gltf.json = glb.json;
-    } else {
-      assert7(false, "GLTF: must be ArrayBuffer or string");
-    }
-    const buffers = gltf.json.buffers || [];
-    gltf.buffers = new Array(buffers.length).fill(null);
-    if (gltf._glb && gltf._glb.header.hasBinChunk) {
-      const { binChunks } = gltf._glb;
-      gltf.buffers[0] = {
-        arrayBuffer: binChunks[0].arrayBuffer,
-        byteOffset: binChunks[0].byteOffset,
-        byteLength: binChunks[0].byteLength
-      };
-    }
-    const images = gltf.json.images || [];
-    gltf.images = new Array(images.length).fill({});
-  }
-  async function loadBuffers(gltf, options, context) {
-    const buffers = gltf.json.buffers || [];
-    for (let i2 = 0; i2 < buffers.length; ++i2) {
-      const buffer = buffers[i2];
-      if (buffer.uri) {
-        const { fetch: fetch2 } = context;
-        assert7(fetch2);
-        const uri = resolveUrl(buffer.uri, options);
-        const response = await context?.fetch?.(uri);
-        const arrayBuffer = await response?.arrayBuffer?.();
-        gltf.buffers[i2] = {
-          arrayBuffer,
-          byteOffset: 0,
-          byteLength: arrayBuffer.byteLength
-        };
-        delete buffer.uri;
-      } else if (gltf.buffers[i2] === null) {
-        gltf.buffers[i2] = {
-          arrayBuffer: new ArrayBuffer(buffer.byteLength),
-          byteOffset: 0,
-          byteLength: buffer.byteLength
-        };
-      }
-    }
-  }
-  async function loadImages(gltf, options, context) {
-    const imageIndices = getReferencesImageIndices(gltf);
-    const images = gltf.json.images || [];
-    const promises = [];
-    for (const imageIndex of imageIndices) {
-      promises.push(loadImage(gltf, images[imageIndex], imageIndex, options, context));
-    }
-    return await Promise.all(promises);
-  }
-  function getReferencesImageIndices(gltf) {
-    const imageIndices = new Set();
-    const textures = gltf.json.textures || [];
-    for (const texture of textures) {
-      if (texture.source !== void 0) {
-        imageIndices.add(texture.source);
-      }
-    }
-    return Array.from(imageIndices).sort();
-  }
-  async function loadImage(gltf, image, index, options, context) {
-    const { fetch: fetch2, parse: parse5 } = context;
-    let arrayBuffer;
-    if (image.uri && !image.hasOwnProperty("bufferView")) {
-      const uri = resolveUrl(image.uri, options);
-      const response = await fetch2(uri);
-      arrayBuffer = await response.arrayBuffer();
-      image.bufferView = {
-        data: arrayBuffer
-      };
-    }
-    if (Number.isFinite(image.bufferView)) {
-      const array = getTypedArrayForBufferView(gltf.json, gltf.buffers, image.bufferView);
-      arrayBuffer = sliceArrayBuffer(array.buffer, array.byteOffset, array.byteLength);
-    }
-    assert7(arrayBuffer, "glTF image has no data");
-    let parsedImage = await parse5(arrayBuffer, [ImageLoader, BasisLoader], { mimeType: image.mimeType, basis: options.basis || { format: selectSupportedBasisFormat() } }, context);
-    if (parsedImage && parsedImage[0]) {
-      parsedImage = {
-        compressed: true,
-        mipmaps: false,
-        width: parsedImage[0].width,
-        height: parsedImage[0].height,
-        data: parsedImage[0]
-      };
-    }
-    gltf.images = gltf.images || [];
-    gltf.images[index] = parsedImage;
-  }
-  var init_parse_gltf = __esm({
-    "../gltf/src/lib/parsers/parse-gltf.ts"() {
-      init_src9();
-      init_src8();
-      init_src2();
-      init_assert6();
-      init_resolve_url();
-      init_get_typed_array();
-      init_gltf_extensions();
-      init_normalize_gltf_v1();
-      init_post_process_gltf();
-      init_parse_glb();
-    }
-  });
-
-  // ../gltf/src/gltf-loader.ts
-  async function parse3(arrayBuffer, options = {}, context) {
-    options = { ...GLTFLoader.options, ...options };
-    options.gltf = { ...GLTFLoader.options.gltf, ...options.gltf };
-    const { byteOffset = 0 } = options;
-    const gltf = {};
-    return await parseGLTF(gltf, arrayBuffer, byteOffset, options, context);
-  }
-  var GLTFLoader;
-  var init_gltf_loader = __esm({
-    "../gltf/src/gltf-loader.ts"() {
-      init_version4();
-      init_parse_gltf();
-      GLTFLoader = {
-        name: "glTF",
-        id: "gltf",
-        module: "gltf",
-        version: VERSION6,
-        extensions: ["gltf", "glb"],
-        mimeTypes: ["model/gltf+json", "model/gltf-binary"],
-        text: true,
-        binary: true,
-        tests: ["glTF"],
-        parse: parse3,
-        options: {
-          gltf: {
-            normalize: true,
-            loadBuffers: true,
-            loadImages: true,
-            decompressMeshes: true,
-            postProcess: true
-          },
-          log: console
-        },
-        deprecatedOptions: {
-          fetchImages: "gltf.loadImages",
-          createImages: "gltf.loadImages",
-          decompress: "gltf.decompressMeshes",
-          postProcess: "gltf.postProcess",
-          gltf: {
-            decompress: "gltf.decompressMeshes"
+          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;
         }
       };
     }
@@ -12083,17 +12336,19 @@
   var init_src10 = __esm({
     "../gltf/src/index.ts"() {
       init_gltf_loader();
+      init_post_process_gltf();
+      init_gltf_utils();
     }
   });
 
   // src/lib/parsers/helpers/parse-3d-tile-gltf-view.ts
   function parse3DTileGLTFViewSync(tile, arrayBuffer, byteOffset, options) {
     tile.rotateYtoZ = true;
-    const gltfByteLength = tile.byteOffset + tile.byteLength - byteOffset;
+    const gltfByteLength = (tile.byteOffset || 0) + (tile.byteLength || 0) - byteOffset;
     if (gltfByteLength === 0) {
       throw new Error("glTF byte length must be greater than 0.");
     }
-    tile.gltfUpAxis = options["3d-tiles"] && options["3d-tiles"].assetGltfUpAxis ? options["3d-tiles"].assetGltfUpAxis : "Y";
+    tile.gltfUpAxis = options?.["3d-tiles"] && options["3d-tiles"].assetGltfUpAxis ? options["3d-tiles"].assetGltfUpAxis : "Y";
     tile.gltfArrayBuffer = sliceArrayBuffer(arrayBuffer, byteOffset, gltfByteLength);
     tile.gltfByteOffset = 0;
     tile.gltfByteLength = gltfByteLength;
@@ -12101,19 +12356,25 @@
     } else {
       console.warn(`${tile.type}: embedded glb is not aligned to a 4-byte boundary.`);
     }
-    return tile.byteOffset + tile.byteLength;
+    return (tile.byteOffset || 0) + (tile.byteLength || 0);
   }
   async function extractGLTF(tile, gltfFormat, options, context) {
-    const tile3DOptions = options["3d-tiles"] || {};
+    const tile3DOptions = options?.["3d-tiles"] || {};
     extractGLTFBufferOrURL(tile, gltfFormat, options);
     if (tile3DOptions.loadGLTF) {
+      if (!context) {
+        return;
+      }
       const { parse: parse5, fetch: fetch2 } = context;
       if (tile.gltfUrl) {
-        tile.gltfArrayBuffer = await fetch2(tile.gltfUrl, options);
+        const response = await fetch2(tile.gltfUrl, options);
+        tile.gltfArrayBuffer = await response.arrayBuffer();
         tile.gltfByteOffset = 0;
       }
       if (tile.gltfArrayBuffer) {
-        tile.gltf = await parse5(tile.gltfArrayBuffer, GLTFLoader, options, context);
+        const gltfWithBuffers = await parse5(tile.gltfArrayBuffer, GLTFLoader, options, context);
+        tile.gltf = postProcessGLTF(gltfWithBuffers);
+        tile.gpuMemoryUsageInBytes = getMemoryUsageGLTF(tile.gltf);
         delete tile.gltfArrayBuffer;
         delete tile.gltfByteOffset;
         delete tile.gltfByteLength;
@@ -12123,10 +12384,12 @@
   function extractGLTFBufferOrURL(tile, gltfFormat, options) {
     switch (gltfFormat) {
       case GLTF_FORMAT.URI:
-        const gltfUrlBytes = new Uint8Array(tile.gltfArrayBuffer, tile.gltfByteOffset);
-        const textDecoder = new TextDecoder();
-        const gltfUrl = textDecoder.decode(gltfUrlBytes);
-        tile.gltfUrl = gltfUrl.replace(/[\s\0]+$/, "");
+        if (tile.gltfArrayBuffer) {
+          const gltfUrlBytes = new Uint8Array(tile.gltfArrayBuffer, tile.gltfByteOffset);
+          const textDecoder = new TextDecoder();
+          const gltfUrl = textDecoder.decode(gltfUrlBytes);
+          tile.gltfUrl = gltfUrl.replace(/[\s\0]+$/, "");
+        }
         delete tile.gltfArrayBuffer;
         delete tile.gltfByteOffset;
         delete tile.gltfByteLength;
@@ -12181,7 +12444,7 @@
   // src/lib/parsers/parse-3d-tile-instanced-model.ts
   async function parseInstancedModel3DTile(tile, arrayBuffer, byteOffset, options, context) {
     byteOffset = parseInstancedModel(tile, arrayBuffer, byteOffset, options, context);
-    await extractGLTF(tile, tile.gltfFormat, options, context);
+    await extractGLTF(tile, tile.gltfFormat || 0, options, context);
     return byteOffset;
   }
   function parseInstancedModel(tile, arrayBuffer, byteOffset, options, context) {
@@ -12195,7 +12458,7 @@
     byteOffset += 4;
     byteOffset = parse3DTileTablesSync(tile, arrayBuffer, byteOffset, options);
     byteOffset = parse3DTileGLTFViewSync(tile, arrayBuffer, byteOffset, options);
-    if (tile.featureTableJsonByteLength === 0) {
+    if (!tile?.header?.featureTableJsonByteLength || tile.header.featureTableJsonByteLength === 0) {
       throw new Error("i3dm parser: featureTableJsonByteLength is zero.");
     }
     const featureTable = new Tile3DFeatureTable(tile.featureTableJson, tile.featureTableBinary);
@@ -12211,17 +12474,7 @@
     return byteOffset;
   }
   function extractInstancedAttributes(tile, featureTable, batchTable, instancesLength) {
-    const collectionOptions = {
-      instances: new Array(instancesLength),
-      batchTable: tile._batchTable,
-      cull: false,
-      url: void 0,
-      gltf: void 0,
-      basePath: void 0,
-      incrementallyLoadTextures: false,
-      forwardAxis: [1, 0, 0]
-    };
-    const instances = collectionOptions.instances;
+    const instances = new Array(instancesLength);
     const instancePosition = new Vector3();
     const instanceNormalRight = new Vector3();
     const instanceNormalUp = new Vector3();
@@ -12233,19 +12486,19 @@
     const instanceTransform = new Matrix4();
     const scratch1 = [];
     const scratch2 = [];
-    const scratchVector12 = new Vector3();
-    const scratchVector26 = new Vector3();
+    const scratch3 = [];
+    const scratch4 = [];
     for (let i2 = 0; i2 < instancesLength; i2++) {
       let position;
       if (featureTable.hasProperty("POSITION")) {
         position = featureTable.getProperty("POSITION", GL2.FLOAT, 3, i2, instancePosition);
       } else if (featureTable.hasProperty("POSITION_QUANTIZED")) {
         position = featureTable.getProperty("POSITION_QUANTIZED", GL2.UNSIGNED_SHORT, 3, i2, instancePosition);
-        const quantizedVolumeOffset = featureTable.getGlobalProperty("QUANTIZED_VOLUME_OFFSET", GL2.FLOAT, 3, scratchVector12);
+        const quantizedVolumeOffset = featureTable.getGlobalProperty("QUANTIZED_VOLUME_OFFSET", GL2.FLOAT, 3);
         if (!quantizedVolumeOffset) {
           throw new Error("i3dm parser: QUANTIZED_VOLUME_OFFSET must be defined for quantized positions.");
         }
-        const quantizedVolumeScale = featureTable.getGlobalProperty("QUANTIZED_VOLUME_SCALE", GL2.FLOAT, 3, scratchVector26);
+        const quantizedVolumeScale = featureTable.getGlobalProperty("QUANTIZED_VOLUME_SCALE", GL2.FLOAT, 3);
         if (!quantizedVolumeScale) {
           throw new Error("i3dm parser: QUANTIZED_VOLUME_SCALE must be defined for quantized positions.");
         }
@@ -12268,8 +12521,8 @@
         }
         tile.hasCustomOrientation = true;
       } else {
-        tile.octNormalUp = featureTable.getProperty("NORMAL_UP_OCT32P", GL2.UNSIGNED_SHORT, 2, scratch1);
-        tile.octNormalRight = featureTable.getProperty("NORMAL_RIGHT_OCT32P", GL2.UNSIGNED_SHORT, 2, scratch2);
+        tile.octNormalUp = featureTable.getProperty("NORMAL_UP_OCT32P", GL2.UNSIGNED_SHORT, 2, i2, scratch1);
+        tile.octNormalRight = featureTable.getProperty("NORMAL_RIGHT_OCT32P", GL2.UNSIGNED_SHORT, 2, i2, scratch2);
         if (tile.octNormalUp) {
           if (!tile.octNormalRight) {
             throw new Error("i3dm: oct-encoded orientation requires NORMAL_UP_OCT32P and NORMAL_RIGHT_OCT32P");
@@ -12291,7 +12544,7 @@
       instanceQuaternion.fromMatrix3(instanceRotation);
       instanceTranslationRotationScale.rotation = instanceQuaternion;
       instanceScale.set(1, 1, 1);
-      const scale5 = featureTable.getProperty("SCALE", GL2.FLOAT, 1, i2);
+      const scale5 = featureTable.getProperty("SCALE", GL2.FLOAT, 1, i2, scratch3);
       if (Number.isFinite(scale5)) {
         instanceScale.multiplyByScalar(scale5);
       }
@@ -12300,7 +12553,7 @@
         instanceScale.scale(nonUniformScale);
       }
       instanceTranslationRotationScale.scale = instanceScale;
-      let batchId = featureTable.getProperty("BATCH_ID", GL2.UNSIGNED_SHORT, 1, i2);
+      let batchId = featureTable.getProperty("BATCH_ID", GL2.UNSIGNED_SHORT, 1, i2, scratch4);
       if (batchId === void 0) {
         batchId = i2;
       }
@@ -12337,7 +12590,7 @@
     tile.tilesLength = view.getUint32(byteOffset, true);
     byteOffset += 4;
     tile.tiles = [];
-    while (tile.tiles.length < tile.tilesLength && tile.byteLength - byteOffset > 12) {
+    while (tile.tiles.length < tile.tilesLength && (tile.byteLength || 0) - byteOffset > 12) {
       const subtile = {};
       tile.tiles.push(subtile);
       byteOffset = await parse3DTile2(arrayBuffer, byteOffset, options, context, subtile);
@@ -12353,9 +12606,18 @@
   // src/lib/parsers/parse-3d-tile-gltf.ts
   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: parse5 } = context;
-    tile.gltf = await parse5(arrayBuffer, GLTFLoader, options, context);
+    tile.gltfUpAxis = options?.["3d-tiles"] && options["3d-tiles"].assetGltfUpAxis ? options["3d-tiles"].assetGltfUpAxis : "Y";
+    if (options?.["3d-tiles"]?.loadGLTF) {
+      if (!context) {
+        return;
+      }
+      const { parse: parse5 } = context;
+      const gltfWithBuffers = await parse5(arrayBuffer, GLTFLoader, options, context);
+      tile.gltf = postProcessGLTF(gltfWithBuffers);
+      tile.gpuMemoryUsageInBytes = getMemoryUsageGLTF(tile.gltf);
+    } else {
+      tile.gltfArrayBuffer = arrayBuffer;
+    }
   }
   var init_parse_3d_tile_gltf = __esm({
     "src/lib/parsers/parse-3d-tile-gltf.ts"() {
@@ -13932,11 +14194,11 @@
   });
 
   // src/lib/parsers/parse-3d-tile-header.ts
-  function getTileType(tile) {
-    if (!tile.contentUrl) {
+  function getTileType(tile, tileContentUrl = "") {
+    if (!tileContentUrl) {
       return TILE_TYPE.EMPTY;
     }
-    const contentUrl = tile.contentUrl;
+    const contentUrl = tileContentUrl.split("?")[0];
     const fileExtension = contentUrl.split(".").pop();
     switch (fileExtension) {
       case "pnts":
@@ -13947,7 +14209,7 @@
       case "gltf":
         return TILE_TYPE.SCENEGRAPH;
       default:
-        return fileExtension;
+        return fileExtension || TILE_TYPE.EMPTY;
     }
   }
   function getRefine(refine) {
@@ -13962,7 +14224,7 @@
         return refine;
     }
   }
-  function resolveUri(uri, basePath) {
+  function resolveUri(uri = "", basePath) {
     const urlSchemeRegex = /^[a-z][0-9a-z+.-]*:/i;
     if (urlSchemeRegex.test(basePath)) {
       const url = new URL(uri, `${basePath}/`);
@@ -13972,50 +14234,59 @@
     }
     return `${basePath}/${uri}`;
   }
-  function normalizeTileData(tile, options) {
+  function normalizeTileData(tile, basePath) {
     if (!tile) {
       return null;
     }
+    let tileContentUrl;
     if (tile.content) {
-      const contentUri = tile.content.uri || tile.content.url;
-      tile.contentUrl = resolveUri(contentUri, options.basePath);
-    }
-    tile.id = tile.contentUrl;
-    tile.lodMetricType = LOD_METRIC_TYPE.GEOMETRIC_ERROR;
-    tile.lodMetricValue = tile.geometricError;
-    tile.transformMatrix = tile.transform;
-    tile.type = getTileType(tile);
-    tile.refine = getRefine(tile.refine);
-    return tile;
+      const contentUri = tile.content.uri || tile.content?.url;
+      tileContentUrl = resolveUri(contentUri, basePath);
+    }
+    const tilePostprocessed = {
+      ...tile,
+      id: tileContentUrl,
+      contentUrl: tileContentUrl,
+      lodMetricType: LOD_METRIC_TYPE.GEOMETRIC_ERROR,
+      lodMetricValue: tile.geometricError,
+      transformMatrix: tile.transform,
+      type: getTileType(tile, tileContentUrl),
+      refine: getRefine(tile.refine)
+    };
+    return tilePostprocessed;
   }
-  async function normalizeTileHeaders(tileset, options) {
-    const basePath = tileset.basePath;
-    let root;
-    const rootImplicitTilingExtension = getImplicitTilingExtensionData(tileset?.root);
+  async function normalizeTileHeaders(tileset, basePath, options) {
+    let root = null;
+    const rootImplicitTilingExtension = getImplicitTilingExtensionData(tileset.root);
     if (rootImplicitTilingExtension && tileset.root) {
-      root = await normalizeImplicitTileHeaders(tileset.root, tileset, rootImplicitTilingExtension, options);
+      root = await normalizeImplicitTileHeaders(tileset.root, tileset, basePath, rootImplicitTilingExtension, options);
     } else {
-      root = normalizeTileData(tileset.root, tileset);
+      root = normalizeTileData(tileset.root, basePath);
     }
     const stack2 = [];
     stack2.push(root);
     while (stack2.length > 0) {
       const tile = stack2.pop() || {};
       const children = tile.children || [];
-      for (let childHeader of children) {
+      const childrenPostprocessed = [];
+      for (const childHeader of children) {
         const childImplicitTilingExtension = getImplicitTilingExtensionData(childHeader);
+        let childHeaderPostprocessed;
         if (childImplicitTilingExtension) {
-          childHeader = await normalizeImplicitTileHeaders(childHeader, tileset, childImplicitTilingExtension, options);
+          childHeaderPostprocessed = await normalizeImplicitTileHeaders(childHeader, tileset, basePath, childImplicitTilingExtension, options);
         } else {
-          normalizeTileData(childHeader, { basePath });
+          childHeaderPostprocessed = normalizeTileData(childHeader, basePath);
+        }
+        if (childHeaderPostprocessed) {
+          childrenPostprocessed.push(childHeaderPostprocessed);
+          stack2.push(childHeaderPostprocessed);
         }
-        stack2.push(childHeader);
       }
+      tile.children = childrenPostprocessed;
     }
     return root;
   }
-  async function normalizeImplicitTileHeaders(tile, tileset, implicitTilingExtension, options) {
-    const basePath = tileset.basePath;
+  async function normalizeImplicitTileHeaders(tile, tileset, basePath, implicitTilingExtension, options) {
     const {
       subdivisionScheme,
       maximumLevel,
@@ -14025,7 +14296,7 @@
     const replacedUrlTemplate = replaceContentUrlTemplate(subtreesUriTemplate, 0, 0, 0, 0);
     const subtreeUrl = resolveUri(replacedUrlTemplate, basePath);
     const subtree = await load(subtreeUrl, Tile3DSubtreeLoader, options);
-    const contentUrlTemplate = resolveUri(tile.content.uri, basePath);
+    const contentUrlTemplate = resolveUri(tile.content?.uri, basePath);
     const refine = tileset?.root?.refine;
     const rootLodMetricValue = tile.geometricError;
     const s2VolumeInfo = tile.boundingVolume.extensions?.["3DTILES_bounding_volume_S2"];
@@ -14049,29 +14320,35 @@
       getTileType,
       getRefine
     };
-    return await normalizeImplicitTileData(tile, subtree, implicitOptions);
+    return await normalizeImplicitTileData(tile, basePath, subtree, implicitOptions);
   }
-  async function normalizeImplicitTileData(tile, rootSubtree, options) {
+  async function normalizeImplicitTileData(tile, basePath, rootSubtree, options) {
     if (!tile) {
       return null;
     }
-    tile.lodMetricType = LOD_METRIC_TYPE.GEOMETRIC_ERROR;
-    tile.lodMetricValue = tile.geometricError;
-    tile.transformMatrix = tile.transform;
     const { children, contentUrl } = await parseImplicitTiles({
       subtree: rootSubtree,
-      options,
-      s2VolumeBox: tile
+      options
     });
+    let tileContentUrl;
+    let tileContent = null;
     if (contentUrl) {
-      tile.contentUrl = contentUrl;
-      tile.content = { uri: contentUrl.replace(`${options.basePath}/`, "") };
+      tileContentUrl = contentUrl;
+      tileContent = { uri: contentUrl.replace(`${basePath}/`, "") };
     }
-    tile.refine = getRefine(tile.refine);
-    tile.type = getTileType(tile);
-    tile.children = children;
-    tile.id = tile.contentUrl;
-    return tile;
+    const tilePostprocessed = {
+      ...tile,
+      id: tileContentUrl,
+      contentUrl: tileContentUrl,
+      lodMetricType: LOD_METRIC_TYPE.GEOMETRIC_ERROR,
+      lodMetricValue: tile.geometricError,
+      transformMatrix: tile.transform,
+      type: getTileType(tile, tileContentUrl),
+      refine: getRefine(tile.refine),
+      content: tileContent || tile.content,
+      children
+    };
+    return tilePostprocessed;
   }
   function getImplicitTilingExtensionData(tile) {
     return tile?.extensions?.["3DTILES_implicit_tiling"] || tile?.implicitTiling;
@@ -14087,8 +14364,33 @@
   });
 
   // src/tiles-3d-loader.ts
-  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 isTileset ? parseTileset(data, options, context) : parseTile(data, options, context);
+  }
+  async function parseTileset(data, options, context) {
+    const tilesetJson = JSON.parse(new TextDecoder().decode(data));
+    const tilesetUrl = context?.url || "";
+    const basePath = getBaseUri(tilesetUrl);
+    const normalizedRoot = await normalizeTileHeaders(tilesetJson, basePath, options || {});
+    const tilesetJsonPostprocessed = {
+      ...tilesetJson,
+      loader: Tiles3DLoader,
+      url: tilesetUrl,
+      queryString: context?.queryString || "",
+      basePath,
+      root: normalizedRoot || tilesetJson.root,
+      type: TILESET_TYPE.TILES3D,
+      lodMetricType: LOD_METRIC_TYPE.GEOMETRIC_ERROR,
+      lodMetricValue: tilesetJson.root?.geometricError || 0
+    };
+    return tilesetJsonPostprocessed;
   }
   async function parseTile(arrayBuffer, options, context) {
     const tile = {
@@ -14100,31 +14402,8 @@
     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(tilesetUrl) {
+    return path_exports.dirname(tilesetUrl);
   }
   var Tiles3DLoader;
   var init_tiles_3d_loader = __esm({