npm - @loaders.gl/3d-tiles - Versions diffs - 4.0.0-alpha.6 → 4.0.0-alpha.7 - Mend

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

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (57) hide show

package/dist/dist.min.js CHANGED Viewed

@@ -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) {
@@ -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,
@@ -8791,763 +8821,300 @@
     }
   });
-  // ../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 initializeBasisTrascoderModule(BasisModule, wasmBinary) {
-    const options = {};
-    if (wasmBinary) {
-      options.wasmBinary = wasmBinary;
+  function getDefaultImageType() {
+    if (IMAGE_BITMAP_SUPPORTED) {
+      return "imagebitmap";
     }
-    return new Promise((resolve2) => {
-      BasisModule(options).then((module) => {
-        const { BasisFile, initializeBasis } = module;
-        initializeBasis();
-        resolve2({ BasisFile });
-      });
-    });
-  }
-  async function loadBasisEncoderModule(options) {
-    const modules = options.modules || {};
-    if (modules.basisEncoder) {
-      return modules.basisEncoder;
+    if (IMAGE_SUPPORTED) {
+      return "image";
     }
-    loadBasisEncoderPromise = loadBasisEncoderPromise || loadBasisEncoder(options);
-    return await loadBasisEncoderPromise;
-  }
-  async function loadBasisEncoder(options) {
-    let BASIS_ENCODER = null;
-    let wasmBinary = null;
-    [BASIS_ENCODER, wasmBinary] = await Promise.all([
-      await loadLibrary(BASIS_CDN_ENCODER_JS, "textures", options),
-      await loadLibrary(BASIS_CDN_ENCODER_WASM, "textures", options)
-    ]);
-    BASIS_ENCODER = BASIS_ENCODER || globalThis.BASIS;
-    return await initializeBasisEncoderModule(BASIS_ENCODER, wasmBinary);
-  }
-  function initializeBasisEncoderModule(BasisEncoderModule, wasmBinary) {
-    const options = {};
-    if (wasmBinary) {
-      options.wasmBinary = wasmBinary;
+    if (DATA_SUPPORTED) {
+      return "data";
     }
-    return new Promise((resolve2) => {
-      BasisEncoderModule(options).then((module) => {
-        const { BasisFile, KTX2File, initializeBasis, BasisEncoder } = module;
-        initializeBasis();
-        resolve2({ BasisFile, KTX2File, BasisEncoder });
-      });
-    });
+    throw new Error("Install '@loaders.gl/polyfills' to parse images under Node.js");
   }
-  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 _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;
     }
   });
-  // ../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/category-api/parsed-image-api.ts
+  function getImageType(image) {
+    const format = getImageTypeOrNull(image);
+    if (!format) {
+      throw new Error("Not an image");
     }
-  });
-  // ../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);
-          }
+    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");
         }
-      }
+        canvas.width = image.width;
+        canvas.height = image.height;
+        context.drawImage(image, 0, 0);
+        return context.getImageData(0, 0, image.width, image.height);
+      default:
+        throw new Error("getImageData");
     }
-    return formats;
   }
-  function getWebGLContext() {
-    try {
-      const canvas = document.createElement("canvas");
-      return canvas.getContext("webgl");
-    } catch (error) {
-      return null;
+  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 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;
+  var init_parsed_image_api = __esm({
+    "../images/src/lib/category-api/parsed-image-api.ts"() {
     }
   });
-  // ../../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 = {}));
+  // ../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;
     }
-  });
-  // ../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;
+    return getBlob(arrayBuffer, url);
   }
-  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
-      ];
+  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((\?|#).*)?$/;
     }
   });
-  // ../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);
+  // ../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);
       }
-      const { BasisFile } = await loadBasisTrascoderModule(options);
-      return parseBasisFile(BasisFile, data, options);
-    }
-    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:
-        const { BasisFile } = await loadBasisTrascoderModule(options);
-        return parseBasisFile(BasisFile, data, options);
     }
   }
-  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();
+  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);
+      }
+    });
   }
-  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_to_image = __esm({
+    "../images/src/lib/parsers/parse-to-image.ts"() {
+      init_svg_utils();
     }
-    return {
-      width,
-      height,
-      data: decodedData,
-      compressed,
-      format,
-      hasAlpha
-    };
+  });
+  // ../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);
   }
-  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;
+  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 [levels];
-    } finally {
-      ktx2File.close();
-      ktx2File.delete();
     }
+    return await createImageBitmap(blob);
   }
-  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 isEmptyObject(object) {
+    for (const key in object || EMPTY_OBJECT) {
+      return false;
     }
-    return {
-      width,
-      height,
-      data: decodedData,
-      compressed,
-      levelSize: decodedSize,
-      hasAlpha: alphaFlag,
-      format
-    };
+    return true;
   }
-  function getBasisOptions(options, hasAlpha) {
-    let format = options && options.basis && options.basis.format;
-    if (format === "auto") {
-      format = selectSupportedBasisFormat();
+  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;
     }
-    if (typeof format === "object") {
-      format = hasAlpha ? format.alpha : format.noAlpha;
+  });
+  // ../images/src/lib/category-api/parse-isobmff-binary.ts
+  function getISOBMFFMediaType(buffer) {
+    if (!checkString(buffer, "ftyp", 4)) {
+      return null;
     }
-    format = format.toLowerCase();
-    return OutputFormat[format];
-  }
-  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";
+    if ((buffer[8] & 96) === 0) {
+      return null;
     }
-    return "rgb565";
+    return decodeMajorBrand(buffer);
   }
-  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 }
-      };
-    }
-  });
-  // ../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
-      };
-    }
-  });
-  // ../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/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;
+  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:
-        throw new Error(`@loaders.gl/images: image ${type} not supported in this environment`);
+        return null;
     }
   }
-  function getDefaultImageType() {
-    if (IMAGE_BITMAP_SUPPORTED) {
-      return "imagebitmap";
-    }
-    if (IMAGE_SUPPORTED) {
-      return "image";
-    }
-    if (DATA_SUPPORTED) {
-      return "data";
+  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;
+      }
     }
-    throw new Error("Install '@loaders.gl/polyfills' to parse images under Node.js");
+    return true;
   }
-  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;
+  var init_parse_isobmff_binary = __esm({
+    "../images/src/lib/category-api/parse-isobmff-binary.ts"() {
     }
   });
-  // ../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;
+  // ../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 getImageData(image) {
-    switch (getImageType(image)) {
-      case "data":
-        return image;
-      case "image":
-      case "imagebitmap":
-        const canvas = document.createElement("canvas");
-        const context = canvas.getContext("2d");
-        if (!context) {
-          throw new Error("getImageData");
-        }
-        canvas.width = image.width;
-        canvas.height = image.height;
-        context.drawImage(image, 0, 0);
-        return context.getImageData(0, 0, image.width, image.height);
-      default:
-        throw new Error("getImageData");
+  function 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 getImageTypeOrNull(image) {
-    if (typeof ImageBitmap !== "undefined" && image instanceof ImageBitmap) {
-      return "imagebitmap";
-    }
-    if (typeof Image !== "undefined" && image instanceof Image) {
-      return "image";
+  function getPngMetadata(binaryData) {
+    const dataView = toDataView(binaryData);
+    const isPng = dataView.byteLength >= 24 && dataView.getUint32(0, BIG_ENDIAN) === 2303741511;
+    if (!isPng) {
+      return null;
     }
-    if (image && typeof image === "object" && image.data && image.width && image.height) {
-      return "data";
+    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 null;
+    return {
+      mimeType: "image/gif",
+      width: dataView.getUint16(6, LITTLE_ENDIAN),
+      height: dataView.getUint16(8, LITTLE_ENDIAN)
+    };
   }
-  var init_parsed_image_api = __esm({
-    "../images/src/lib/category-api/parsed-image-api.ts"() {
+  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;
     }
-  });
-  // ../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 init_parse_to_image = __esm({
-    "../images/src/lib/parsers/parse-to-image.ts"() {
-      init_svg_utils();
-    }
-  });
-  // ../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;
-      }
-    }
-    return await createImageBitmap(blob);
-  }
-  function isEmptyObject(object) {
-    for (const key in object || EMPTY_OBJECT) {
-      return false;
-    }
-    return true;
-  }
-  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;
-    }
-    return decodeMajorBrand(buffer);
-  }
-  function decodeMajorBrand(buffer) {
-    const brandMajor = getUTF8String(buffer, 8, 12).replace("\0", " ").trim();
-    switch (brandMajor) {
-      case "avif":
-      case "avis":
-        return { extension: "avif", mimeType: "image/avif" };
-      default:
-        return null;
-    }
-  }
-  function getUTF8String(array, start, end) {
-    return String.fromCharCode(...array.slice(start, end));
-  }
-  function stringToBytes(string) {
-    return [...string].map((character) => character.charCodeAt(0));
-  }
-  function checkString(buffer, header, offset = 0) {
-    const headerBytes = stringToBytes(header);
-    for (let i2 = 0; i2 < headerBytes.length; ++i2) {
-      if (headerBytes[i2] !== buffer[i2 + offset]) {
-        return false;
-      }
-    }
-    return true;
-  }
-  var init_parse_isobmff_binary = __esm({
-    "../images/src/lib/category-api/parse-isobmff-binary.ts"() {
-    }
-  });
-  // ../images/src/lib/category-api/binary-image-api.ts
-  function getBinaryImageMetadata(binaryData) {
-    const dataView = toDataView(binaryData);
-    return getPngMetadata(dataView) || getJpegMetadata(dataView) || getGifMetadata(dataView) || getBmpMetadata(dataView) || 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)
-    };
+    return {
+      mimeType: "image/bmp",
+      width: dataView.getUint32(18, LITTLE_ENDIAN),
+      height: dataView.getUint32(22, LITTLE_ENDIAN)
+    };
   }
   function getJpegMetadata(binaryData) {
     const dataView = toDataView(binaryData);
@@ -9618,150 +9185,612 @@
     }
   });
-  // ../images/src/lib/parsers/parse-to-node-image.ts
-  async function parseToNodeImage(arrayBuffer, options) {
-    const { mimeType } = getBinaryImageMetadata(arrayBuffer) || {};
-    const _parseImageNode2 = globalThis._parseImageNode;
-    assert2(_parseImageNode2);
-    return await _parseImageNode2(arrayBuffer, mimeType);
+  // ../images/src/lib/parsers/parse-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/parsers/parse-image.ts
+  async function parseImage(arrayBuffer, options, context) {
+    options = options || {};
+    const imageOptions = options.image || {};
+    const imageType = imageOptions.type || "auto";
+    const { url } = context || {};
+    const loadType = getLoadableImageType(imageType);
+    let image;
+    switch (loadType) {
+      case "imagebitmap":
+        image = await parseToImageBitmap(arrayBuffer, options, url);
+        break;
+      case "image":
+        image = await parseToImage(arrayBuffer, options, url);
+        break;
+      case "data":
+        image = await parseToNodeImage(arrayBuffer, options);
+        break;
+      default:
+        assert2(false);
+    }
+    if (imageType === "data") {
+      image = getImageData(image);
+    }
+    return image;
+  }
+  function getLoadableImageType(type) {
+    switch (type) {
+      case "auto":
+      case "data":
+        return getDefaultImageType();
+      default:
+        isImageTypeSupported(type);
+        return type;
+    }
+  }
+  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_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
+        }
+      };
+      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/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 checkNodeImageFormatSupport(mimeType) {
+    const NODE_FORMAT_SUPPORT = ["image/png", "image/jpeg", "image/gif"];
+    const { _parseImageNode: _parseImageNode2, _imageFormatsNode = NODE_FORMAT_SUPPORT } = globalThis;
+    return Boolean(_parseImageNode2) && _imageFormatsNode.includes(mimeType);
+  }
+  function checkBrowserImageFormatSupport(mimeType) {
+    switch (mimeType) {
+      case "image/avif":
+      case "image/webp":
+        return testBrowserImageFormatSupport(mimeType);
+      default:
+        return true;
+    }
+  }
+  function testBrowserImageFormatSupport(mimeType) {
+    try {
+      const element = document.createElement("canvas");
+      const dataURL = element.toDataURL(mimeType);
+      return dataURL.indexOf(`data:${mimeType}`) === 0;
+    } catch {
+      return false;
+    }
+  }
+  var mimeTypeSupportedSync;
+  var init_image_format = __esm({
+    "../images/src/lib/category-api/image-format.ts"() {
+      init_src2();
+      mimeTypeSupportedSync = {};
+    }
+  });
+  // ../images/src/index.ts
+  var init_src8 = __esm({
+    "../images/src/index.ts"() {
+      init_image_loader();
+      init_binary_image_api();
+      init_image_format();
+    }
+  });
+  // ../textures/src/lib/utils/version.ts
+  var VERSION8;
+  var init_version6 = __esm({
+    "../textures/src/lib/utils/version.ts"() {
+      VERSION8 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "beta";
+    }
+  });
+  // ../textures/src/lib/parsers/basis-module-loader.ts
+  async function loadBasisTrascoderModule(options) {
+    const modules = options.modules || {};
+    if (modules.basis) {
+      return modules.basis;
+    }
+    loadBasisTranscoderPromise = loadBasisTranscoderPromise || loadBasisTrascoder(options);
+    return await loadBasisTranscoderPromise;
+  }
+  async function loadBasisTrascoder(options) {
+    let BASIS = null;
+    let wasmBinary = null;
+    [BASIS, wasmBinary] = await Promise.all([
+      await loadLibrary("basis_transcoder.js", "textures", options),
+      await loadLibrary("basis_transcoder.wasm", "textures", options)
+    ]);
+    BASIS = BASIS || globalThis.BASIS;
+    return await initializeBasisTrascoderModule(BASIS, wasmBinary);
+  }
+  function initializeBasisTrascoderModule(BasisModule, wasmBinary) {
+    const options = {};
+    if (wasmBinary) {
+      options.wasmBinary = wasmBinary;
+    }
+    return new Promise((resolve2) => {
+      BasisModule(options).then((module) => {
+        const { BasisFile, initializeBasis } = module;
+        initializeBasis();
+        resolve2({ BasisFile });
+      });
+    });
+  }
+  async function loadBasisEncoderModule(options) {
+    const modules = options.modules || {};
+    if (modules.basisEncoder) {
+      return modules.basisEncoder;
+    }
+    loadBasisEncoderPromise = loadBasisEncoderPromise || loadBasisEncoder(options);
+    return await loadBasisEncoderPromise;
+  }
+  async function loadBasisEncoder(options) {
+    let BASIS_ENCODER = null;
+    let wasmBinary = null;
+    [BASIS_ENCODER, wasmBinary] = await Promise.all([
+      await loadLibrary(BASIS_CDN_ENCODER_JS, "textures", options),
+      await loadLibrary(BASIS_CDN_ENCODER_WASM, "textures", options)
+    ]);
+    BASIS_ENCODER = BASIS_ENCODER || globalThis.BASIS;
+    return await initializeBasisEncoderModule(BASIS_ENCODER, wasmBinary);
+  }
+  function initializeBasisEncoderModule(BasisEncoderModule, wasmBinary) {
+    const options = {};
+    if (wasmBinary) {
+      options.wasmBinary = wasmBinary;
+    }
+    return new Promise((resolve2) => {
+      BasisEncoderModule(options).then((module) => {
+        const { BasisFile, KTX2File, initializeBasis, BasisEncoder } = module;
+        initializeBasis();
+        resolve2({ BasisFile, KTX2File, BasisEncoder });
+      });
+    });
+  }
+  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`;
+    }
+  });
+  // ../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
+      };
+    }
+  });
+  // ../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);
+          }
+        }
+      }
+    }
+    return formats;
+  }
+  function getWebGLContext() {
+    try {
+      const canvas = document.createElement("canvas");
+      return canvas.getContext("webgl");
+    } catch (error) {
+      return null;
+    }
+  }
+  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 = {}));
+    }
+  });
+  // ../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 init_parse_to_node_image = __esm({
-    "../images/src/lib/parsers/parse-to-node-image.ts"() {
-      init_src2();
-      init_binary_image_api();
+  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-image.ts
-  async function parseImage(arrayBuffer, options, context) {
-    options = options || {};
-    const imageOptions = options.image || {};
-    const imageType = imageOptions.type || "auto";
-    const { url } = context || {};
-    const loadType = getLoadableImageType(imageType);
-    let image;
-    switch (loadType) {
-      case "imagebitmap":
-        image = await parseToImageBitmap(arrayBuffer, options, url);
-        break;
-      case "image":
-        image = await parseToImage(arrayBuffer, options, url);
-        break;
-      case "data":
-        image = await parseToNodeImage(arrayBuffer, options);
-        break;
-      default:
-        assert2(false);
-    }
-    if (imageType === "data") {
-      image = getImageData(image);
+  // ../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);
     }
-    return image;
-  }
-  function getLoadableImageType(type) {
-    switch (type) {
-      case "auto":
-      case "data":
-        return getDefaultImageType();
+    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:
-        isImageTypeSupported(type);
-        return type;
+        const { BasisFile } = await loadBasisTrascoderModule(options);
+        return parseBasisFile(BasisFile, data, options);
     }
   }
-  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
+  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));
         }
-      };
-      ImageLoader = {
-        id: "image",
-        module: "images",
-        name: "Images",
-        version: VERSION9,
-        mimeTypes: MIME_TYPES,
-        extensions: EXTENSIONS,
-        parse: parseImage,
-        tests: [(arrayBuffer) => Boolean(getBinaryImageMetadata(new DataView(arrayBuffer)))],
-        options: DEFAULT_IMAGE_LOADER_OPTIONS
-      };
+        images.push(levels);
+      }
+      return images;
+    } finally {
+      basisFile.close();
+      basisFile.delete();
     }
-  });
-  // ../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;
+  }
+  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");
     }
-    return mimeTypeSupportedSync[mimeType];
+    return {
+      width,
+      height,
+      data: decodedData,
+      compressed,
+      format,
+      hasAlpha
+    };
   }
-  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 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 checkBrowserImageFormatSupport(mimeType) {
-    switch (mimeType) {
-      case "image/avif":
-      case "image/webp":
-        return testBrowserImageFormatSupport(mimeType);
-      default:
-        return true;
+  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 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 +9813,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 +9980,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 +10038,30 @@
   });
   // ../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 || []
           };
           this.sourceBuffers = [];
           this.byteLength = 0;
@@ -9920,10 +10081,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 +10196,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 +10233,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 +10249,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;
@@ -10515,9 +10683,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 +10743,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 +10877,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 +10960,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 +11095,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({
@@ -11459,7 +11627,197 @@
     }
   });
+  // ../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 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 +11827,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 +11864,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 +11873,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 +12080,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 +12117,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 +12142,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);
+          if (gltfBufferView.byteOffset) {
+            byteOffset += gltfBufferView.byteOffset;
           }
-          break;
-        case GLB_CHUNK_TYPE_BIX_XVIZ_DEPRECATED:
-          if (!options.strict) {
-            parseBINChunk(glb, dataView, byteOffset, chunkLength);
+          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) {
           }
-          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"
+          if (camera.orthographic) {
           }
+          return camera;
         }
       };
     }
@@ -12083,6 +12189,8 @@
   var init_src10 = __esm({
     "../gltf/src/index.ts"() {
       init_gltf_loader();
+      init_post_process_gltf();
+      init_gltf_utils();
     }
   });
@@ -12113,7 +12221,9 @@
         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;
@@ -12355,7 +12465,9 @@
     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);
+    const gltfWithBuffers = await parse5(arrayBuffer, GLTFLoader, options, context);
+    tile.gltf = postProcessGLTF(gltfWithBuffers);
+    tile.gpuMemoryUsageInBytes = getMemoryUsageGLTF(tile.gltf);
   }
   var init_parse_3d_tile_gltf = __esm({
     "src/lib/parsers/parse-3d-tile-gltf.ts"() {
@@ -13936,7 +14048,7 @@
     if (!tile.contentUrl) {
       return TILE_TYPE.EMPTY;
     }
-    const contentUrl = tile.contentUrl;
+    const contentUrl = tile.contentUrl.split("?")[0];
     const fileExtension = contentUrl.split(".").pop();
     switch (fileExtension) {
       case "pnts":
@@ -14087,8 +14199,27 @@
   });
   // 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 await isTileset ? parseTileset(data, options, context) : parseTile(data, options, context);
+  }
+  async function parseTileset(data, options, context) {
+    const tilesetJson = JSON.parse(new TextDecoder().decode(data));
+    tilesetJson.loader = options?.loader || Tiles3DLoader;
+    tilesetJson.url = context?.url || "";
+    tilesetJson.queryString = context?.queryString || "";
+    tilesetJson.basePath = getBaseUri(tilesetJson);
+    tilesetJson.root = await normalizeTileHeaders(tilesetJson, options || {});
+    tilesetJson.type = TILESET_TYPE.TILES3D;
+    tilesetJson.lodMetricType = LOD_METRIC_TYPE.GEOMETRIC_ERROR;
+    tilesetJson.lodMetricValue = tilesetJson.root?.lodMetricValue || 0;
+    return tilesetJson;
   }
   async function parseTile(arrayBuffer, options, context) {
     const tile = {
@@ -14100,31 +14231,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(tileset) {
+    return path_exports.dirname(tileset.url);
   }
   var Tiles3DLoader;
   var init_tiles_3d_loader = __esm({