@loaders.gl/textures 4.4.0-alpha.2 → 4.4.0

package/dist/dist.dev.js

@@ -45,13 +45,6 @@ var __exports__ = (() => {
     }
   });
 
-  // (disabled):../worker-utils/src/lib/process-utils/child-process-proxy
-  var require_child_process_proxy = __commonJS({
-    "(disabled):../worker-utils/src/lib/process-utils/child-process-proxy"() {
-      "use strict";
-    }
-  });
-
   // bundle.ts
   var bundle_exports = {};
   __export(bundle_exports, {
@@ -64,70 +57,108 @@ var __exports__ = (() => {
     CompressedTextureWriter: () => CompressedTextureWriter,
     CrunchLoader: () => CrunchLoader,
     CrunchWorkerLoader: () => CrunchLoader,
+    GL_COMPRESSED_R11_EAC: () => GL_COMPRESSED_R11_EAC,
+    GL_COMPRESSED_RED_GREEN_RGTC2_EXT: () => GL_COMPRESSED_RED_GREEN_RGTC2_EXT,
+    GL_COMPRESSED_RED_RGTC1_EXT: () => GL_COMPRESSED_RED_RGTC1_EXT,
+    GL_COMPRESSED_RG11_EAC: () => GL_COMPRESSED_RG11_EAC,
+    GL_COMPRESSED_RGB8_ETC2: () => GL_COMPRESSED_RGB8_ETC2,
+    GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2: () => GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2,
+    GL_COMPRESSED_RGBA8_ETC2_EAC: () => GL_COMPRESSED_RGBA8_ETC2_EAC,
+    GL_COMPRESSED_RGBA_ASTC_10x10_KHR: () => GL_COMPRESSED_RGBA_ASTC_10x10_KHR,
+    GL_COMPRESSED_RGBA_ASTC_10x5_KHR: () => GL_COMPRESSED_RGBA_ASTC_10x5_KHR,
+    GL_COMPRESSED_RGBA_ASTC_10x6_KHR: () => GL_COMPRESSED_RGBA_ASTC_10x6_KHR,
+    GL_COMPRESSED_RGBA_ASTC_10x8_KHR: () => GL_COMPRESSED_RGBA_ASTC_10x8_KHR,
+    GL_COMPRESSED_RGBA_ASTC_12x10_KHR: () => GL_COMPRESSED_RGBA_ASTC_12x10_KHR,
+    GL_COMPRESSED_RGBA_ASTC_12x12_KHR: () => GL_COMPRESSED_RGBA_ASTC_12x12_KHR,
+    GL_COMPRESSED_RGBA_ASTC_4x4_KHR: () => GL_COMPRESSED_RGBA_ASTC_4x4_KHR,
+    GL_COMPRESSED_RGBA_ASTC_5x4_KHR: () => GL_COMPRESSED_RGBA_ASTC_5x4_KHR,
+    GL_COMPRESSED_RGBA_ASTC_5x5_KHR: () => GL_COMPRESSED_RGBA_ASTC_5x5_KHR,
+    GL_COMPRESSED_RGBA_ASTC_6x5_KHR: () => GL_COMPRESSED_RGBA_ASTC_6x5_KHR,
+    GL_COMPRESSED_RGBA_ASTC_6x6_KHR: () => GL_COMPRESSED_RGBA_ASTC_6x6_KHR,
+    GL_COMPRESSED_RGBA_ASTC_8x5_KHR: () => GL_COMPRESSED_RGBA_ASTC_8x5_KHR,
+    GL_COMPRESSED_RGBA_ASTC_8x6_KHR: () => GL_COMPRESSED_RGBA_ASTC_8x6_KHR,
+    GL_COMPRESSED_RGBA_ASTC_8x8_KHR: () => GL_COMPRESSED_RGBA_ASTC_8x8_KHR,
+    GL_COMPRESSED_RGBA_ATC_EXPLICIT_ALPHA_WEBGL: () => GL_COMPRESSED_RGBA_ATC_EXPLICIT_ALPHA_WEBGL,
+    GL_COMPRESSED_RGBA_ATC_INTERPOLATED_ALPHA_WEBGL: () => GL_COMPRESSED_RGBA_ATC_INTERPOLATED_ALPHA_WEBGL,
+    GL_COMPRESSED_RGBA_BPTC_UNORM_EXT: () => GL_COMPRESSED_RGBA_BPTC_UNORM_EXT,
+    GL_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG: () => GL_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG,
+    GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG: () => GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG,
+    GL_COMPRESSED_RGBA_S3TC_DXT1_EXT: () => GL_COMPRESSED_RGBA_S3TC_DXT1_EXT,
+    GL_COMPRESSED_RGBA_S3TC_DXT3_EXT: () => GL_COMPRESSED_RGBA_S3TC_DXT3_EXT,
+    GL_COMPRESSED_RGBA_S3TC_DXT5_EXT: () => GL_COMPRESSED_RGBA_S3TC_DXT5_EXT,
+    GL_COMPRESSED_RGB_ATC_WEBGL: () => GL_COMPRESSED_RGB_ATC_WEBGL,
+    GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT_EXT: () => GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT_EXT,
+    GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_EXT: () => GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_EXT,
+    GL_COMPRESSED_RGB_ETC1_WEBGL: () => GL_COMPRESSED_RGB_ETC1_WEBGL,
+    GL_COMPRESSED_RGB_PVRTC_2BPPV1_IMG: () => GL_COMPRESSED_RGB_PVRTC_2BPPV1_IMG,
+    GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG: () => GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG,
+    GL_COMPRESSED_RGB_S3TC_DXT1_EXT: () => GL_COMPRESSED_RGB_S3TC_DXT1_EXT,
+    GL_COMPRESSED_SIGNED_R11_EAC: () => GL_COMPRESSED_SIGNED_R11_EAC,
+    GL_COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT: () => GL_COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT,
+    GL_COMPRESSED_SIGNED_RED_RGTC1_EXT: () => GL_COMPRESSED_SIGNED_RED_RGTC1_EXT,
+    GL_COMPRESSED_SIGNED_RG11_EAC: () => GL_COMPRESSED_SIGNED_RG11_EAC,
+    GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR: () => GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR,
+    GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR: () => GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR,
+    GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR: () => GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR,
+    GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR: () => GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR,
+    GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR: () => GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR,
+    GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR: () => GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR,
+    GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR: () => GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR,
+    GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR: () => GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR,
+    GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR: () => GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR,
+    GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR: () => GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR,
+    GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR: () => GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR,
+    GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR: () => GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR,
+    GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR: () => GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR,
+    GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR: () => GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR,
+    GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC: () => GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC,
+    GL_COMPRESSED_SRGB8_ETC2: () => GL_COMPRESSED_SRGB8_ETC2,
+    GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2: () => GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2,
+    GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM_EXT: () => GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM_EXT,
+    GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT: () => GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT,
+    GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT: () => GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT,
+    GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT: () => GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT,
+    GL_COMPRESSED_SRGB_S3TC_DXT1_EXT: () => GL_COMPRESSED_SRGB_S3TC_DXT1_EXT,
     GL_EXTENSIONS_CONSTANTS: () => GL_EXTENSIONS_CONSTANTS,
+    GL_RGB: () => GL_RGB,
+    GL_RGB565: () => GL_RGB565,
+    GL_RGB5_A1: () => GL_RGB5_A1,
+    GL_RGBA: () => GL_RGBA,
+    GL_RGBA32F: () => GL_RGBA32F,
+    GL_RGBA4: () => GL_RGBA4,
+    GL_RGBA8: () => GL_RGBA8,
     KTX2BasisWriter: () => KTX2BasisWriter,
     KTX2BasisWriterWorker: () => KTX2BasisWriterWorker,
     NPYLoader: () => NPYLoader,
     NPYWorkerLoader: () => NPYWorkerLoader,
-    getSupportedGPUTextureFormats: () => getSupportedGPUTextureFormats,
+    RadianceHDRLoader: () => RadianceHDRLoader,
+    TextureArrayLoader: () => TextureArrayLoader,
+    TextureCubeArrayLoader: () => TextureCubeArrayLoader,
+    TextureCubeLoader: () => TextureCubeLoader,
+    TextureLoader: () => TextureLoader,
     loadImageTexture: () => loadImageTexture,
     loadImageTextureArray: () => loadImageTextureArray,
-    loadImageTextureCube: () => loadImageTextureCube,
-    selectSupportedBasisFormat: () => selectSupportedBasisFormat
+    loadImageTextureCube: () => loadImageTextureCube
   });
   __reExport(bundle_exports, __toESM(require_core(), 1));
 
   // src/lib/utils/version.ts
   var VERSION = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
 
-  // ../loader-utils/src/lib/env-utils/assert.ts
-  function assert(condition, message) {
-    if (!condition) {
-      throw new Error(message || "loader assertion failed.");
-    }
-  }
-
-  // ../loader-utils/src/lib/env-utils/globals.ts
-  var globals = {
-    self: typeof self !== "undefined" && self,
-    window: typeof window !== "undefined" && window,
-    global: typeof global !== "undefined" && global,
-    document: typeof document !== "undefined" && document
-  };
-  var self_ = globals.self || globals.window || globals.global || {};
-  var window_ = globals.window || globals.self || globals.global || {};
-  var global_ = globals.global || globals.self || globals.window || {};
-  var document_ = globals.document || {};
-  var isBrowser = (
-    // @ts-ignore process does not exist on browser
-    Boolean(typeof process !== "object" || String(process) !== "[object process]" || process.browser)
-  );
-  var matches = typeof process !== "undefined" && process.version && /v([0-9]*)/.exec(process.version);
-  var nodeVersion = matches && parseFloat(matches[1]) || 0;
-
-  // ../loader-utils/src/lib/module-utils/js-module-utils.ts
-  function registerJSModules(modules) {
-    globalThis.loaders ||= {};
-    globalThis.loaders.modules ||= {};
-    Object.assign(globalThis.loaders.modules, modules);
-  }
-  function getJSModuleOrNull(name) {
-    const module = globalThis.loaders?.modules?.[name];
-    return module || null;
-  }
-
   // ../worker-utils/src/lib/npm-tag.ts
   var NPM_TAG = "beta";
 
   // ../worker-utils/src/lib/env-utils/version.ts
+  var warningIssued = false;
   function getVersion() {
     if (!globalThis._loadersgl_?.version) {
       globalThis._loadersgl_ = globalThis._loadersgl_ || {};
-      if (typeof __VERSION__ === "undefined") {
+      if (typeof __VERSION__ === "undefined" && !warningIssued) {
         console.warn(
           "loaders.gl: The __VERSION__ variable is not injected using babel plugin. Latest unstable workers would be fetched from the CDN."
         );
         globalThis._loadersgl_.version = NPM_TAG;
+        warningIssued = true;
       } else {
         globalThis._loadersgl_.version = __VERSION__;
       }
@@ -137,34 +168,44 @@ var __exports__ = (() => {
   var VERSION2 = getVersion();
 
   // ../worker-utils/src/lib/env-utils/assert.ts
-  function assert2(condition, message) {
+  function assert(condition, message) {
     if (!condition) {
       throw new Error(message || "loaders.gl assertion failed.");
     }
   }
 
   // ../worker-utils/src/lib/env-utils/globals.ts
-  var globals2 = {
+  var globals = {
     self: typeof self !== "undefined" && self,
     window: typeof window !== "undefined" && window,
     global: typeof global !== "undefined" && global,
     document: typeof document !== "undefined" && document
   };
-  var self_2 = globals2.self || globals2.window || globals2.global || {};
-  var window_2 = globals2.window || globals2.self || globals2.global || {};
-  var global_2 = globals2.global || globals2.self || globals2.window || {};
-  var document_2 = globals2.document || {};
-  var isBrowser2 = (
+  var self_ = globals.self || globals.window || globals.global || {};
+  var window_ = globals.window || globals.self || globals.global || {};
+  var global_ = globals.global || globals.self || globals.window || {};
+  var document_ = globals.document || {};
+  var isBrowser = (
     // @ts-ignore process.browser
     typeof process !== "object" || String(process) !== "[object process]" || process.browser
   );
   var isWorker = typeof importScripts === "function";
   var isMobile = typeof window !== "undefined" && typeof window.orientation !== "undefined";
-  var matches2 = typeof process !== "undefined" && process.version && /v([0-9]*)/.exec(process.version);
-  var nodeVersion2 = matches2 && parseFloat(matches2[1]) || 0;
+  var matches = typeof process !== "undefined" && process.version && /v([0-9]*)/.exec(process.version);
+  var nodeVersion = matches && parseFloat(matches[1]) || 0;
 
   // ../worker-utils/src/lib/library-utils/library-utils.ts
   var loadLibraryPromises = {};
+  function extractLoadLibraryOptions(options = {}) {
+    const useLocalLibraries = options.useLocalLibraries ?? options.core?.useLocalLibraries;
+    const CDN = options.CDN ?? options.core?.CDN;
+    const modules = options.modules;
+    return {
+      ...useLocalLibraries !== void 0 ? { useLocalLibraries } : {},
+      ...CDN !== void 0 ? { CDN } : {},
+      ...modules !== void 0 ? { modules } : {}
+    };
+  }
   async function loadLibrary(libraryUrl, moduleName = null, options = {}, libraryName = null) {
     if (moduleName) {
       libraryUrl = getLibraryUrl(libraryUrl, moduleName, options, libraryName);
@@ -174,6 +215,9 @@ var __exports__ = (() => {
     return await loadLibraryPromises[libraryUrl];
   }
   function getLibraryUrl(library, moduleName, options = {}, libraryName = null) {
+    if (options?.core) {
+      throw new Error("loadLibrary: options.core must be pre-normalized");
+    }
     if (!options.useLocalLibraries && library.startsWith("http")) {
       return library;
     }
@@ -182,11 +226,11 @@ var __exports__ = (() => {
     if (modules[libraryName]) {
       return modules[libraryName];
     }
-    if (!isBrowser2) {
+    if (!isBrowser) {
       return `modules/${moduleName}/dist/libs/${libraryName}`;
     }
     if (options.CDN) {
-      assert2(options.CDN.startsWith("http"));
+      assert(options.CDN.startsWith("http"));
       return `${options.CDN}/${moduleName}@${VERSION2}/dist/libs/${libraryName}`;
     }
     if (isWorker) {
@@ -198,11 +242,21 @@ var __exports__ = (() => {
     if (libraryUrl.endsWith("wasm")) {
       return await loadAsArrayBuffer(libraryUrl);
     }
-    if (!isBrowser2) {
+    if (!isBrowser) {
+      const { requireFromFile } = globalThis.loaders || {};
       try {
-        const { requireFromFile } = globalThis.loaders || {};
-        return await requireFromFile?.(libraryUrl);
+        const result = await requireFromFile?.(libraryUrl);
+        if (result || !libraryUrl.includes("/dist/libs/")) {
+          return result;
+        }
+        return await requireFromFile?.(libraryUrl.replace("/dist/libs/", "/src/libs/"));
       } catch (error) {
+        if (libraryUrl.includes("/dist/libs/")) {
+          try {
+            return await requireFromFile?.(libraryUrl.replace("/dist/libs/", "/src/libs/"));
+          } catch {
+          }
+        }
         console.error(error);
         return null;
       }
@@ -214,7 +268,7 @@ var __exports__ = (() => {
     return loadLibraryFromString(scriptSource, libraryUrl);
   }
   function loadLibraryFromString(scriptSource, id) {
-    if (!isBrowser2) {
+    if (!isBrowser) {
       const { requireFromString } = globalThis.loaders || {};
       return requireFromString?.(scriptSource, id);
     }
@@ -234,230 +288,1143 @@ var __exports__ = (() => {
   }
   async function loadAsArrayBuffer(url) {
     const { readFileAsArrayBuffer } = globalThis.loaders || {};
-    if (isBrowser2 || !readFileAsArrayBuffer || url.startsWith("http")) {
+    if (isBrowser || !readFileAsArrayBuffer || url.startsWith("http")) {
       const response = await fetch(url);
       return await response.arrayBuffer();
     }
-    return await readFileAsArrayBuffer(url);
+    try {
+      return await readFileAsArrayBuffer(url);
+    } catch {
+      if (url.includes("/dist/libs/")) {
+        return await readFileAsArrayBuffer(url.replace("/dist/libs/", "/src/libs/"));
+      }
+      throw new Error(`Failed to load ArrayBuffer from ${url}`);
+    }
   }
   async function loadAsText(url) {
     const { readFileAsText } = globalThis.loaders || {};
-    if (isBrowser2 || !readFileAsText || url.startsWith("http")) {
+    if (isBrowser || !readFileAsText || url.startsWith("http")) {
       const response = await fetch(url);
       return await response.text();
     }
-    return await readFileAsText(url);
+    try {
+      return await readFileAsText(url);
+    } catch {
+      if (url.includes("/dist/libs/")) {
+        return await readFileAsText(url.replace("/dist/libs/", "/src/libs/"));
+      }
+      throw new Error(`Failed to load text from ${url}`);
+    }
   }
 
-  // ../worker-utils/src/index.ts
-  var import_child_process_proxy = __toESM(require_child_process_proxy(), 1);
-
-  // ../loader-utils/src/lib/path-utils/file-aliases.ts
-  var pathPrefix = "";
-  var fileAliases = {};
-  function resolvePath(filename) {
-    for (const alias in fileAliases) {
-      if (filename.startsWith(alias)) {
-        const replacement = fileAliases[alias];
-        filename = filename.replace(alias, replacement);
-      }
+  // ../worker-utils/src/lib/process-utils/child-process-proxy.browser.ts
+  var ChildProcessProxy = class {
+    constructor() {
+      throw new Error("ChildProcessProxy is not available in browser environments");
+    }
+    async start(props) {
+      return await Promise.resolve({});
+    }
+    async stop() {
+      return await Promise.resolve();
     }
-    if (!filename.startsWith("http://") && !filename.startsWith("https://")) {
-      filename = `${pathPrefix}${filename}`;
+    async exit() {
+      return await Promise.resolve();
     }
-    return filename;
+  };
+
+  // ../loader-utils/src/loader-types.ts
+  async function parseFromContext(data, loaders, options, context) {
+    return context._parse(data, loaders, options, context);
   }
 
-  // src/lib/parsers/basis-module-loader.ts
-  var BASIS_EXTERNAL_LIBRARIES = {
-    /** Basis transcoder, javascript wrapper part */
-    TRANSCODER: "basis_transcoder.js",
-    /** Basis transcoder, compiled web assembly part */
-    TRANSCODER_WASM: "basis_transcoder.wasm",
-    /** Basis encoder, javascript wrapper part */
-    ENCODER: "basis_encoder.js",
-    /** Basis encoder, compiled web assembly part */
-    ENCODER_WASM: "basis_encoder.wasm"
+  // ../loader-utils/src/lib/env-utils/assert.ts
+  function assert2(condition, message) {
+    if (!condition) {
+      throw new Error(message || "loader assertion failed.");
+    }
+  }
+
+  // ../loader-utils/src/lib/env-utils/globals.ts
+  var globals2 = {
+    self: typeof self !== "undefined" && self,
+    window: typeof window !== "undefined" && window,
+    global: typeof global !== "undefined" && global,
+    document: typeof document !== "undefined" && document
   };
-  var loadBasisTranscoderPromise;
-  async function loadBasisTranscoderModule(options) {
-    registerJSModules(options.modules);
-    const basis = getJSModuleOrNull("basis");
-    if (basis) {
-      return basis;
+  var self_2 = globals2.self || globals2.window || globals2.global || {};
+  var window_2 = globals2.window || globals2.self || globals2.global || {};
+  var global_2 = globals2.global || globals2.self || globals2.window || {};
+  var document_2 = globals2.document || {};
+  var isBrowser2 = (
+    // @ts-ignore process does not exist on browser
+    Boolean(typeof process !== "object" || String(process) !== "[object process]" || process.browser)
+  );
+  var matches2 = typeof process !== "undefined" && process.version && /v([0-9]*)/.exec(process.version);
+  var nodeVersion2 = matches2 && parseFloat(matches2[1]) || 0;
+
+  // ../../node_modules/@probe.gl/env/dist/lib/globals.js
+  var window_3 = globalThis;
+  var document_3 = globalThis.document || {};
+  var process_ = globalThis.process || {};
+  var console_ = globalThis.console;
+  var navigator_ = globalThis.navigator || {};
+
+  // ../../node_modules/@probe.gl/env/dist/lib/is-electron.js
+  function isElectron(mockUserAgent) {
+    if (typeof window !== "undefined" && window.process?.type === "renderer") {
+      return true;
     }
-    loadBasisTranscoderPromise ||= loadBasisTranscoder(options);
-    return await loadBasisTranscoderPromise;
+    if (typeof process !== "undefined" && Boolean(process.versions?.["electron"])) {
+      return true;
+    }
+    const realUserAgent = typeof navigator !== "undefined" && navigator.userAgent;
+    const userAgent = mockUserAgent || realUserAgent;
+    return Boolean(userAgent && userAgent.indexOf("Electron") >= 0);
   }
-  async function loadBasisTranscoder(options) {
-    let BASIS = null;
-    let wasmBinary = null;
-    [BASIS, wasmBinary] = await Promise.all([
-      await loadLibrary(BASIS_EXTERNAL_LIBRARIES.TRANSCODER, "textures", options),
-      await loadLibrary(BASIS_EXTERNAL_LIBRARIES.TRANSCODER_WASM, "textures", options)
-    ]);
-    BASIS = BASIS || globalThis.BASIS;
-    return await initializeBasisTranscoderModule(BASIS, wasmBinary);
+
+  // ../../node_modules/@probe.gl/env/dist/lib/is-browser.js
+  function isBrowser3() {
+    const isNode = (
+      // @ts-expect-error
+      typeof process === "object" && String(process) === "[object process]" && !process?.browser
+    );
+    return !isNode || isElectron();
   }
-  function initializeBasisTranscoderModule(BasisModule, wasmBinary) {
-    const options = {};
-    if (wasmBinary) {
-      options.wasmBinary = wasmBinary;
+
+  // ../../node_modules/@probe.gl/env/dist/index.js
+  var VERSION3 = true ? "4.1.1" : "untranspiled source";
+
+  // ../../node_modules/@probe.gl/log/dist/utils/assert.js
+  function assert3(condition, message) {
+    if (!condition) {
+      throw new Error(message || "Assertion failed");
     }
-    return new Promise((resolve) => {
-      BasisModule(options).then((module) => {
-        const { BasisFile, initializeBasis } = module;
-        initializeBasis();
-        resolve({ BasisFile });
-      });
-    });
   }
-  var loadBasisEncoderPromise;
-  async function loadBasisEncoderModule(options) {
-    const modules = options.modules || {};
-    if (modules.basisEncoder) {
-      return modules.basisEncoder;
+
+  // ../../node_modules/@probe.gl/log/dist/loggers/log-utils.js
+  function normalizeLogLevel(logLevel) {
+    if (!logLevel) {
+      return 0;
     }
-    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_EXTERNAL_LIBRARIES.ENCODER, "textures", options),
-      await loadLibrary(BASIS_EXTERNAL_LIBRARIES.ENCODER_WASM, "textures", options)
-    ]);
-    BASIS_ENCODER = BASIS_ENCODER || globalThis.BASIS;
-    return await initializeBasisEncoderModule(BASIS_ENCODER, wasmBinary);
+    let resolvedLevel;
+    switch (typeof logLevel) {
+      case "number":
+        resolvedLevel = logLevel;
+        break;
+      case "object":
+        resolvedLevel = logLevel.logLevel || logLevel.priority || 0;
+        break;
+      default:
+        return 0;
+    }
+    assert3(Number.isFinite(resolvedLevel) && resolvedLevel >= 0);
+    return resolvedLevel;
   }
-  function initializeBasisEncoderModule(BasisEncoderModule, wasmBinary) {
-    const options = {};
-    if (wasmBinary) {
-      options.wasmBinary = wasmBinary;
+  function normalizeArguments(opts) {
+    const { logLevel, message } = opts;
+    opts.logLevel = normalizeLogLevel(logLevel);
+    const args = opts.args ? Array.from(opts.args) : [];
+    while (args.length && args.shift() !== message) {
     }
-    return new Promise((resolve) => {
-      BasisEncoderModule(options).then((module) => {
-        const { BasisFile, KTX2File, initializeBasis, BasisEncoder } = module;
-        initializeBasis();
-        resolve({ BasisFile, KTX2File, BasisEncoder });
-      });
-    });
+    switch (typeof logLevel) {
+      case "string":
+      case "function":
+        if (message !== void 0) {
+          args.unshift(message);
+        }
+        opts.message = logLevel;
+        break;
+      case "object":
+        Object.assign(opts, logLevel);
+        break;
+      default:
+    }
+    if (typeof opts.message === "function") {
+      opts.message = opts.message();
+    }
+    const messageType = typeof opts.message;
+    assert3(messageType === "string" || messageType === "object");
+    return Object.assign(opts, { args }, opts.opts);
   }
 
-  // src/lib/gl-extensions.ts
-  var GL_EXTENSIONS_CONSTANTS = {
-    // WEBGL_compressed_texture_s3tc
-    COMPRESSED_RGB_S3TC_DXT1_EXT: 33776,
-    COMPRESSED_RGBA_S3TC_DXT1_EXT: 33777,
-    COMPRESSED_RGBA_S3TC_DXT3_EXT: 33778,
-    COMPRESSED_RGBA_S3TC_DXT5_EXT: 33779,
-    // WEBGL_compressed_texture_es3
-    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,
-    // WEBGL_compressed_texture_pvrtc
-    COMPRESSED_RGB_PVRTC_4BPPV1_IMG: 35840,
-    COMPRESSED_RGBA_PVRTC_4BPPV1_IMG: 35842,
-    COMPRESSED_RGB_PVRTC_2BPPV1_IMG: 35841,
-    COMPRESSED_RGBA_PVRTC_2BPPV1_IMG: 35843,
-    // WEBGL_compressed_texture_etc1
-    COMPRESSED_RGB_ETC1_WEBGL: 36196,
-    // WEBGL_compressed_texture_atc
-    COMPRESSED_RGB_ATC_WEBGL: 35986,
-    COMPRESSED_RGBA_ATC_EXPLICIT_ALPHA_WEBGL: 35987,
-    COMPRESSED_RGBA_ATC_INTERPOLATED_ALPHA_WEBGL: 34798,
-    // WEBGL_compressed_texture_astc
-    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,
-    // EXT_texture_compression_rgtc
-    COMPRESSED_RED_RGTC1_EXT: 36283,
-    COMPRESSED_SIGNED_RED_RGTC1_EXT: 36284,
-    COMPRESSED_RED_GREEN_RGTC2_EXT: 36285,
-    COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT: 36286,
-    // WEBGL_compressed_texture_s3tc_srgb
-    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
+  // ../../node_modules/@probe.gl/log/dist/loggers/base-log.js
+  var noop = () => {
+  };
+  var BaseLog = class {
+    constructor({ level = 0 } = {}) {
+      this.userData = {};
+      this._onceCache = /* @__PURE__ */ new Set();
+      this._level = level;
+    }
+    set level(newLevel) {
+      this.setLevel(newLevel);
+    }
+    get level() {
+      return this.getLevel();
+    }
+    setLevel(level) {
+      this._level = level;
+      return this;
+    }
+    getLevel() {
+      return this._level;
+    }
+    // Unconditional logging
+    warn(message, ...args) {
+      return this._log("warn", 0, message, args, { once: true });
+    }
+    error(message, ...args) {
+      return this._log("error", 0, message, args);
+    }
+    // Conditional logging
+    log(logLevel, message, ...args) {
+      return this._log("log", logLevel, message, args);
+    }
+    info(logLevel, message, ...args) {
+      return this._log("info", logLevel, message, args);
+    }
+    once(logLevel, message, ...args) {
+      return this._log("once", logLevel, message, args, { once: true });
+    }
+    _log(type, logLevel, message, args, options = {}) {
+      const normalized = normalizeArguments({
+        logLevel,
+        message,
+        args: this._buildArgs(logLevel, message, args),
+        opts: options
+      });
+      return this._createLogFunction(type, normalized, options);
+    }
+    _buildArgs(logLevel, message, args) {
+      return [logLevel, message, ...args];
+    }
+    _createLogFunction(type, normalized, options) {
+      if (!this._shouldLog(normalized.logLevel)) {
+        return noop;
+      }
+      const tag = this._getOnceTag(options.tag ?? normalized.tag ?? normalized.message);
+      if ((options.once || normalized.once) && tag !== void 0) {
+        if (this._onceCache.has(tag)) {
+          return noop;
+        }
+        this._onceCache.add(tag);
+      }
+      return this._emit(type, normalized);
+    }
+    _shouldLog(logLevel) {
+      return this.getLevel() >= normalizeLogLevel(logLevel);
+    }
+    _getOnceTag(tag) {
+      if (tag === void 0) {
+        return void 0;
+      }
+      try {
+        return typeof tag === "string" ? tag : String(tag);
+      } catch {
+        return void 0;
+      }
+    }
   };
 
-  // src/lib/utils/texture-formats.ts
-  var BROWSER_PREFIXES = ["", "WEBKIT_", "MOZ_"];
-  var WEBGL_EXTENSIONS = {
-    /* eslint-disable camelcase */
-    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"
-    /* eslint-enable camelcase */
+  // ../../node_modules/@probe.gl/log/dist/utils/local-storage.js
+  function getStorage(type) {
+    try {
+      const storage = window[type];
+      const x = "__storage_test__";
+      storage.setItem(x, x);
+      storage.removeItem(x);
+      return storage;
+    } catch (e) {
+      return null;
+    }
+  }
+  var LocalStorage = class {
+    constructor(id, defaultConfig, type = "sessionStorage") {
+      this.storage = getStorage(type);
+      this.id = id;
+      this.config = defaultConfig;
+      this._loadConfiguration();
+    }
+    getConfiguration() {
+      return this.config;
+    }
+    setConfiguration(configuration) {
+      Object.assign(this.config, configuration);
+      if (this.storage) {
+        const serialized = JSON.stringify(this.config);
+        this.storage.setItem(this.id, serialized);
+      }
+    }
+    // Get config from persistent store, if available
+    _loadConfiguration() {
+      let configuration = {};
+      if (this.storage) {
+        const serializedConfiguration = this.storage.getItem(this.id);
+        configuration = serializedConfiguration ? JSON.parse(serializedConfiguration) : {};
+      }
+      Object.assign(this.config, configuration);
+      return this;
+    }
   };
-  var formats = null;
-  function getSupportedGPUTextureFormats(gl) {
-    if (!formats) {
-      gl = gl || getWebGLContext() || void 0;
-      formats = /* @__PURE__ */ 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);
-          }
+
+  // ../../node_modules/@probe.gl/log/dist/utils/formatters.js
+  function formatTime(ms) {
+    let formatted;
+    if (ms < 10) {
+      formatted = `${ms.toFixed(2)}ms`;
+    } else if (ms < 100) {
+      formatted = `${ms.toFixed(1)}ms`;
+    } else if (ms < 1e3) {
+      formatted = `${ms.toFixed(0)}ms`;
+    } else {
+      formatted = `${(ms / 1e3).toFixed(2)}s`;
+    }
+    return formatted;
+  }
+  function leftPad(string, length = 8) {
+    const padLength = Math.max(length - string.length, 0);
+    return `${" ".repeat(padLength)}${string}`;
+  }
+
+  // ../../node_modules/@probe.gl/log/dist/utils/color.js
+  var COLOR;
+  (function(COLOR2) {
+    COLOR2[COLOR2["BLACK"] = 30] = "BLACK";
+    COLOR2[COLOR2["RED"] = 31] = "RED";
+    COLOR2[COLOR2["GREEN"] = 32] = "GREEN";
+    COLOR2[COLOR2["YELLOW"] = 33] = "YELLOW";
+    COLOR2[COLOR2["BLUE"] = 34] = "BLUE";
+    COLOR2[COLOR2["MAGENTA"] = 35] = "MAGENTA";
+    COLOR2[COLOR2["CYAN"] = 36] = "CYAN";
+    COLOR2[COLOR2["WHITE"] = 37] = "WHITE";
+    COLOR2[COLOR2["BRIGHT_BLACK"] = 90] = "BRIGHT_BLACK";
+    COLOR2[COLOR2["BRIGHT_RED"] = 91] = "BRIGHT_RED";
+    COLOR2[COLOR2["BRIGHT_GREEN"] = 92] = "BRIGHT_GREEN";
+    COLOR2[COLOR2["BRIGHT_YELLOW"] = 93] = "BRIGHT_YELLOW";
+    COLOR2[COLOR2["BRIGHT_BLUE"] = 94] = "BRIGHT_BLUE";
+    COLOR2[COLOR2["BRIGHT_MAGENTA"] = 95] = "BRIGHT_MAGENTA";
+    COLOR2[COLOR2["BRIGHT_CYAN"] = 96] = "BRIGHT_CYAN";
+    COLOR2[COLOR2["BRIGHT_WHITE"] = 97] = "BRIGHT_WHITE";
+  })(COLOR || (COLOR = {}));
+  var BACKGROUND_INCREMENT = 10;
+  function getColor(color) {
+    if (typeof color !== "string") {
+      return color;
+    }
+    color = color.toUpperCase();
+    return COLOR[color] || COLOR.WHITE;
+  }
+  function addColor(string, color, background) {
+    if (!isBrowser3 && typeof string === "string") {
+      if (color) {
+        const colorCode = getColor(color);
+        string = `\x1B[${colorCode}m${string}\x1B[39m`;
+      }
+      if (background) {
+        const colorCode = getColor(background);
+        string = `\x1B[${colorCode + BACKGROUND_INCREMENT}m${string}\x1B[49m`;
+      }
+    }
+    return string;
+  }
+
+  // ../../node_modules/@probe.gl/log/dist/utils/autobind.js
+  function autobind(obj, predefined = ["constructor"]) {
+    const proto = Object.getPrototypeOf(obj);
+    const propNames = Object.getOwnPropertyNames(proto);
+    const object = obj;
+    for (const key of propNames) {
+      const value = object[key];
+      if (typeof value === "function") {
+        if (!predefined.find((name) => key === name)) {
+          object[key] = value.bind(obj);
         }
       }
     }
-    return formats;
   }
-  function getWebGLContext() {
-    try {
-      const canvas = document.createElement("canvas");
-      return canvas.getContext("webgl");
-    } catch (error) {
-      return null;
+
+  // ../../node_modules/@probe.gl/log/dist/utils/hi-res-timestamp.js
+  function getHiResTimestamp() {
+    let timestamp;
+    if (isBrowser3() && window_3.performance) {
+      timestamp = window_3?.performance?.now?.();
+    } else if ("hrtime" in process_) {
+      const timeParts = process_?.hrtime?.();
+      timestamp = timeParts[0] * 1e3 + timeParts[1] / 1e6;
+    } else {
+      timestamp = Date.now();
     }
+    return timestamp;
   }
 
-  // ../../node_modules/ktx-parse/dist/ktx-parse.modern.js
-  var KHR_SUPERCOMPRESSION_NONE = 0;
-  var KHR_DF_KHR_DESCRIPTORTYPE_BASICFORMAT = 0;
-  var KHR_DF_VENDORID_KHRONOS = 0;
+  // ../../node_modules/@probe.gl/log/dist/loggers/probe-log.js
+  var originalConsole = {
+    debug: isBrowser3() ? console.debug || console.log : console.log,
+    log: console.log,
+    info: console.info,
+    warn: console.warn,
+    error: console.error
+  };
+  var DEFAULT_LOG_CONFIGURATION = {
+    enabled: true,
+    level: 0
+  };
+  var ProbeLog = class extends BaseLog {
+    constructor({ id } = { id: "" }) {
+      super({ level: 0 });
+      this.VERSION = VERSION3;
+      this._startTs = getHiResTimestamp();
+      this._deltaTs = getHiResTimestamp();
+      this.userData = {};
+      this.LOG_THROTTLE_TIMEOUT = 0;
+      this.id = id;
+      this.userData = {};
+      this._storage = new LocalStorage(`__probe-${this.id}__`, { [this.id]: DEFAULT_LOG_CONFIGURATION });
+      this.timeStamp(`${this.id} started`);
+      autobind(this);
+      Object.seal(this);
+    }
+    isEnabled() {
+      return this._getConfiguration().enabled;
+    }
+    getLevel() {
+      return this._getConfiguration().level;
+    }
+    /** @return milliseconds, with fractions */
+    getTotal() {
+      return Number((getHiResTimestamp() - this._startTs).toPrecision(10));
+    }
+    /** @return milliseconds, with fractions */
+    getDelta() {
+      return Number((getHiResTimestamp() - this._deltaTs).toPrecision(10));
+    }
+    /** @deprecated use logLevel */
+    set priority(newPriority) {
+      this.level = newPriority;
+    }
+    /** @deprecated use logLevel */
+    get priority() {
+      return this.level;
+    }
+    /** @deprecated use logLevel */
+    getPriority() {
+      return this.level;
+    }
+    // Configure
+    enable(enabled = true) {
+      this._updateConfiguration({ enabled });
+      return this;
+    }
+    setLevel(level) {
+      this._updateConfiguration({ level });
+      return this;
+    }
+    /** return the current status of the setting */
+    get(setting) {
+      return this._getConfiguration()[setting];
+    }
+    // update the status of the setting
+    set(setting, value) {
+      this._updateConfiguration({ [setting]: value });
+    }
+    /** Logs the current settings as a table */
+    settings() {
+      if (console.table) {
+        console.table(this._storage.config);
+      } else {
+        console.log(this._storage.config);
+      }
+    }
+    // Unconditional logging
+    assert(condition, message) {
+      if (!condition) {
+        throw new Error(message || "Assertion failed");
+      }
+    }
+    warn(message, ...args) {
+      return this._log("warn", 0, message, args, {
+        method: originalConsole.warn,
+        once: true
+      });
+    }
+    error(message, ...args) {
+      return this._log("error", 0, message, args, {
+        method: originalConsole.error
+      });
+    }
+    /** Print a deprecation warning */
+    deprecated(oldUsage, newUsage) {
+      return this.warn(`\`${oldUsage}\` is deprecated and will be removed in a later version. Use \`${newUsage}\` instead`);
+    }
+    /** Print a removal warning */
+    removed(oldUsage, newUsage) {
+      return this.error(`\`${oldUsage}\` has been removed. Use \`${newUsage}\` instead`);
+    }
+    probe(logLevel, message, ...args) {
+      return this._log("log", logLevel, message, args, {
+        method: originalConsole.log,
+        time: true,
+        once: true
+      });
+    }
+    log(logLevel, message, ...args) {
+      return this._log("log", logLevel, message, args, {
+        method: originalConsole.debug
+      });
+    }
+    info(logLevel, message, ...args) {
+      return this._log("info", logLevel, message, args, { method: console.info });
+    }
+    once(logLevel, message, ...args) {
+      return this._log("once", logLevel, message, args, {
+        method: originalConsole.debug || originalConsole.info,
+        once: true
+      });
+    }
+    /** Logs an object as a table */
+    table(logLevel, table, columns) {
+      if (table) {
+        return this._log("table", logLevel, table, columns && [columns] || [], {
+          method: console.table || noop,
+          tag: getTableHeader(table)
+        });
+      }
+      return noop;
+    }
+    time(logLevel, message) {
+      return this._log("time", logLevel, message, [], {
+        method: console.time ? console.time : console.info
+      });
+    }
+    timeEnd(logLevel, message) {
+      return this._log("time", logLevel, message, [], {
+        method: console.timeEnd ? console.timeEnd : console.info
+      });
+    }
+    timeStamp(logLevel, message) {
+      return this._log("time", logLevel, message, [], {
+        method: console.timeStamp || noop
+      });
+    }
+    group(logLevel, message, opts = { collapsed: false }) {
+      const method = (opts.collapsed ? console.groupCollapsed : console.group) || console.info;
+      return this._log("group", logLevel, message, [], { method });
+    }
+    groupCollapsed(logLevel, message, opts = {}) {
+      return this.group(logLevel, message, Object.assign({}, opts, { collapsed: true }));
+    }
+    groupEnd(logLevel) {
+      return this._log("groupEnd", logLevel, "", [], {
+        method: console.groupEnd || noop
+      });
+    }
+    // EXPERIMENTAL
+    withGroup(logLevel, message, func) {
+      this.group(logLevel, message)();
+      try {
+        func();
+      } finally {
+        this.groupEnd(logLevel)();
+      }
+    }
+    trace() {
+      if (console.trace) {
+        console.trace();
+      }
+    }
+    _shouldLog(logLevel) {
+      return this.isEnabled() && super._shouldLog(logLevel);
+    }
+    _emit(_type, normalized) {
+      const method = normalized.method;
+      assert3(method);
+      normalized.total = this.getTotal();
+      normalized.delta = this.getDelta();
+      this._deltaTs = getHiResTimestamp();
+      const message = decorateMessage(this.id, normalized.message, normalized);
+      return method.bind(console, message, ...normalized.args);
+    }
+    _getConfiguration() {
+      if (!this._storage.config[this.id]) {
+        this._updateConfiguration(DEFAULT_LOG_CONFIGURATION);
+      }
+      return this._storage.config[this.id];
+    }
+    _updateConfiguration(configuration) {
+      const currentConfiguration = this._storage.config[this.id] || {
+        ...DEFAULT_LOG_CONFIGURATION
+      };
+      this._storage.setConfiguration({
+        [this.id]: { ...currentConfiguration, ...configuration }
+      });
+    }
+  };
+  ProbeLog.VERSION = VERSION3;
+  function decorateMessage(id, message, opts) {
+    if (typeof message === "string") {
+      const time = opts.time ? leftPad(formatTime(opts.total)) : "";
+      message = opts.time ? `${id}: ${time}  ${message}` : `${id}: ${message}`;
+      message = addColor(message, opts.color, opts.background);
+    }
+    return message;
+  }
+  function getTableHeader(table) {
+    for (const key in table) {
+      for (const title in table[key]) {
+        return title || "untitled";
+      }
+    }
+    return "empty";
+  }
+
+  // ../../node_modules/@probe.gl/log/dist/init.js
+  globalThis.probe = {};
+
+  // ../../node_modules/@probe.gl/log/dist/index.js
+  var dist_default = new ProbeLog({ id: "@probe.gl/log" });
+
+  // ../loader-utils/src/lib/log-utils/log.ts
+  var VERSION4 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+  var version = VERSION4[0] >= "0" && VERSION4[0] <= "9" ? `v${VERSION4}` : "";
+  function createLog() {
+    const log2 = new ProbeLog({ id: "loaders.gl" });
+    globalThis.loaders ||= {};
+    globalThis.loaders.log = log2;
+    globalThis.loaders.version = version;
+    globalThis.probe ||= {};
+    globalThis.probe.loaders = log2;
+    return log2;
+  }
+  var log = createLog();
+
+  // ../loader-utils/src/lib/module-utils/js-module-utils.ts
+  function registerJSModules(modules) {
+    globalThis.loaders ||= {};
+    globalThis.loaders.modules ||= {};
+    Object.assign(globalThis.loaders.modules, modules);
+  }
+  function getJSModuleOrNull(name) {
+    const module = globalThis.loaders?.modules?.[name];
+    return module || null;
+  }
+
+  // ../loader-utils/src/lib/path-utils/file-aliases.ts
+  var pathPrefix = "";
+  var fileAliases = {};
+  function resolvePath(filename2) {
+    for (const alias in fileAliases) {
+      if (filename2.startsWith(alias)) {
+        const replacement = fileAliases[alias];
+        filename2 = filename2.replace(alias, replacement);
+      }
+    }
+    if (!filename2.startsWith("http://") && !filename2.startsWith("https://")) {
+      filename2 = `${pathPrefix}${filename2}`;
+    }
+    return filename2;
+  }
+
+  // ../loader-utils/src/lib/path-utils/path.ts
+  var path_exports = {};
+  __export(path_exports, {
+    dirname: () => dirname,
+    filename: () => filename,
+    join: () => join,
+    resolve: () => resolve
+  });
+
+  // ../loader-utils/src/lib/path-utils/get-cwd.ts
+  function getCWD() {
+    if (typeof process !== "undefined" && typeof process.cwd !== "undefined") {
+      return process.cwd();
+    }
+    const pathname = window.location?.pathname;
+    return pathname?.slice(0, pathname.lastIndexOf("/") + 1) || "";
+  }
+
+  // ../loader-utils/src/lib/path-utils/path.ts
+  function filename(url) {
+    const slashIndex = url ? url.lastIndexOf("/") : -1;
+    return slashIndex >= 0 ? url.substr(slashIndex + 1) : url;
+  }
+  function dirname(url) {
+    const slashIndex = url ? url.lastIndexOf("/") : -1;
+    return slashIndex >= 0 ? url.substr(0, slashIndex) : "";
+  }
+  function join(...parts) {
+    const separator = "/";
+    parts = parts.map((part, index) => {
+      if (index) {
+        part = part.replace(new RegExp(`^${separator}`), "");
+      }
+      if (index !== parts.length - 1) {
+        part = part.replace(new RegExp(`${separator}$`), "");
+      }
+      return part;
+    });
+    return parts.join(separator);
+  }
+  function resolve(...components) {
+    const paths = [];
+    for (let _i = 0; _i < components.length; _i++) {
+      paths[_i] = components[_i];
+    }
+    let resolvedPath = "";
+    let resolvedAbsolute = false;
+    let cwd;
+    for (let i = paths.length - 1; i >= -1 && !resolvedAbsolute; i--) {
+      let path;
+      if (i >= 0) {
+        path = paths[i];
+      } else {
+        if (cwd === void 0) {
+          cwd = getCWD();
+        }
+        path = cwd;
+      }
+      if (path.length === 0) {
+        continue;
+      }
+      resolvedPath = `${path}/${resolvedPath}`;
+      resolvedAbsolute = path.charCodeAt(0) === SLASH;
+    }
+    resolvedPath = normalizeStringPosix(resolvedPath, !resolvedAbsolute);
+    if (resolvedAbsolute) {
+      return `/${resolvedPath}`;
+    } else if (resolvedPath.length > 0) {
+      return resolvedPath;
+    }
+    return ".";
+  }
+  var SLASH = 47;
+  var DOT = 46;
+  function normalizeStringPosix(path, allowAboveRoot) {
+    let res = "";
+    let lastSlash = -1;
+    let dots = 0;
+    let code;
+    let isAboveRoot = false;
+    for (let i = 0; i <= path.length; ++i) {
+      if (i < path.length) {
+        code = path.charCodeAt(i);
+      } else if (code === SLASH) {
+        break;
+      } else {
+        code = SLASH;
+      }
+      if (code === SLASH) {
+        if (lastSlash === i - 1 || dots === 1) {
+        } else if (lastSlash !== i - 1 && dots === 2) {
+          if (res.length < 2 || !isAboveRoot || res.charCodeAt(res.length - 1) !== DOT || res.charCodeAt(res.length - 2) !== DOT) {
+            if (res.length > 2) {
+              const start = res.length - 1;
+              let j = start;
+              for (; j >= 0; --j) {
+                if (res.charCodeAt(j) === SLASH) {
+                  break;
+                }
+              }
+              if (j !== start) {
+                res = j === -1 ? "" : res.slice(0, j);
+                lastSlash = i;
+                dots = 0;
+                isAboveRoot = false;
+                continue;
+              }
+            } else if (res.length === 2 || res.length === 1) {
+              res = "";
+              lastSlash = i;
+              dots = 0;
+              isAboveRoot = false;
+              continue;
+            }
+          }
+          if (allowAboveRoot) {
+            if (res.length > 0) {
+              res += "/..";
+            } else {
+              res = "..";
+            }
+            isAboveRoot = true;
+          }
+        } else {
+          const slice = path.slice(lastSlash + 1, i);
+          if (res.length > 0) {
+            res += `/${slice}`;
+          } else {
+            res = slice;
+          }
+          isAboveRoot = false;
+        }
+        lastSlash = i;
+        dots = 0;
+      } else if (code === DOT && dots !== -1) {
+        ++dots;
+      } else {
+        dots = -1;
+      }
+    }
+    return res;
+  }
+
+  // src/lib/parsers/basis-module-loader.ts
+  var BASIS_EXTERNAL_LIBRARIES = {
+    /** Basis transcoder, javascript wrapper part */
+    TRANSCODER: "basis_transcoder.js",
+    /** Basis transcoder, compiled web assembly part */
+    TRANSCODER_WASM: "basis_transcoder.wasm",
+    /** Basis encoder, javascript wrapper part */
+    ENCODER: "basis_encoder.js",
+    /** Basis encoder, compiled web assembly part */
+    ENCODER_WASM: "basis_encoder.wasm"
+  };
+  var loadBasisTranscoderPromise;
+  async function loadBasisTranscoderModule(options) {
+    registerJSModules(options.modules);
+    const basis = getJSModuleOrNull("basis");
+    if (basis) {
+      return basis;
+    }
+    loadBasisTranscoderPromise ||= loadBasisTranscoder(options);
+    return await loadBasisTranscoderPromise;
+  }
+  async function loadBasisTranscoder(options) {
+    let BASIS = null;
+    let wasmBinary = null;
+    [BASIS, wasmBinary] = await Promise.all([
+      await loadLibrary(BASIS_EXTERNAL_LIBRARIES.TRANSCODER, "textures", options),
+      await loadLibrary(BASIS_EXTERNAL_LIBRARIES.TRANSCODER_WASM, "textures", options)
+    ]);
+    BASIS = BASIS || globalThis.BASIS;
+    return await initializeBasisTranscoderModule(BASIS, wasmBinary);
+  }
+  function initializeBasisTranscoderModule(BasisModule, wasmBinary) {
+    const options = {};
+    if (wasmBinary) {
+      options.wasmBinary = wasmBinary;
+    }
+    return new Promise((resolve2) => {
+      BasisModule(options).then((module) => {
+        const { BasisFile, initializeBasis } = module;
+        initializeBasis();
+        resolve2({ BasisFile });
+      });
+    });
+  }
+  var loadBasisEncoderPromise;
+  async function loadBasisEncoderModule(options) {
+    const modules = options.modules || {};
+    if (modules.basisEncoder) {
+      return modules.basisEncoder;
+    }
+    loadBasisEncoderPromise = loadBasisEncoderPromise || loadBasisEncoder(options);
+    return await loadBasisEncoderPromise;
+  }
+  async function loadBasisEncoder(options) {
+    let BASIS_ENCODER = null;
+    let wasmBinary = null;
+    [BASIS_ENCODER, wasmBinary] = await Promise.all([
+      await loadLibrary(BASIS_EXTERNAL_LIBRARIES.ENCODER, "textures", options),
+      await loadLibrary(BASIS_EXTERNAL_LIBRARIES.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 });
+      });
+    });
+  }
+
+  // src/lib/gl-extensions.ts
+  var GL_RGB = 6407;
+  var GL_RGBA = 6408;
+  var GL_RGBA4 = 32854;
+  var GL_RGB5_A1 = 32855;
+  var GL_RGBA8 = 32856;
+  var GL_RGB565 = 36194;
+  var GL_RGBA32F = 34836;
+  var GL_COMPRESSED_RGB_S3TC_DXT1_EXT = 33776;
+  var GL_COMPRESSED_RGBA_S3TC_DXT1_EXT = 33777;
+  var GL_COMPRESSED_RGBA_S3TC_DXT3_EXT = 33778;
+  var GL_COMPRESSED_RGBA_S3TC_DXT5_EXT = 33779;
+  var GL_COMPRESSED_R11_EAC = 37488;
+  var GL_COMPRESSED_SIGNED_R11_EAC = 37489;
+  var GL_COMPRESSED_RG11_EAC = 37490;
+  var GL_COMPRESSED_SIGNED_RG11_EAC = 37491;
+  var GL_COMPRESSED_RGB8_ETC2 = 37492;
+  var GL_COMPRESSED_RGBA8_ETC2_EAC = 37493;
+  var GL_COMPRESSED_SRGB8_ETC2 = 37494;
+  var GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC = 37495;
+  var GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 = 37496;
+  var GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 = 37497;
+  var GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG = 35840;
+  var GL_COMPRESSED_RGB_PVRTC_2BPPV1_IMG = 35841;
+  var GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG = 35842;
+  var GL_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG = 35843;
+  var GL_COMPRESSED_RGB_ETC1_WEBGL = 36196;
+  var GL_COMPRESSED_RGB_ATC_WEBGL = 35986;
+  var GL_COMPRESSED_RGBA_ATC_EXPLICIT_ALPHA_WEBGL = 35987;
+  var GL_COMPRESSED_RGBA_ATC_INTERPOLATED_ALPHA_WEBGL = 34798;
+  var GL_COMPRESSED_RGBA_ASTC_4x4_KHR = 37808;
+  var GL_COMPRESSED_RGBA_ASTC_5x4_KHR = 37809;
+  var GL_COMPRESSED_RGBA_ASTC_5x5_KHR = 37810;
+  var GL_COMPRESSED_RGBA_ASTC_6x5_KHR = 37811;
+  var GL_COMPRESSED_RGBA_ASTC_6x6_KHR = 37812;
+  var GL_COMPRESSED_RGBA_ASTC_8x5_KHR = 37813;
+  var GL_COMPRESSED_RGBA_ASTC_8x6_KHR = 37814;
+  var GL_COMPRESSED_RGBA_ASTC_8x8_KHR = 37815;
+  var GL_COMPRESSED_RGBA_ASTC_10x5_KHR = 37816;
+  var GL_COMPRESSED_RGBA_ASTC_10x6_KHR = 37817;
+  var GL_COMPRESSED_RGBA_ASTC_10x8_KHR = 37818;
+  var GL_COMPRESSED_RGBA_ASTC_10x10_KHR = 37819;
+  var GL_COMPRESSED_RGBA_ASTC_12x10_KHR = 37820;
+  var GL_COMPRESSED_RGBA_ASTC_12x12_KHR = 37821;
+  var GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR = 37840;
+  var GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR = 37841;
+  var GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR = 37842;
+  var GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR = 37843;
+  var GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR = 37844;
+  var GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR = 37845;
+  var GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR = 37846;
+  var GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR = 37847;
+  var GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR = 37848;
+  var GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR = 37849;
+  var GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR = 37850;
+  var GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR = 37851;
+  var GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR = 37852;
+  var GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR = 37853;
+  var GL_COMPRESSED_RED_RGTC1_EXT = 36283;
+  var GL_COMPRESSED_SIGNED_RED_RGTC1_EXT = 36284;
+  var GL_COMPRESSED_RED_GREEN_RGTC2_EXT = 36285;
+  var GL_COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT = 36286;
+  var GL_COMPRESSED_RGBA_BPTC_UNORM_EXT = 36492;
+  var GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM_EXT = 36493;
+  var GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT_EXT = 36494;
+  var GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_EXT = 36495;
+  var GL_COMPRESSED_SRGB_S3TC_DXT1_EXT = 35916;
+  var GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT = 35917;
+  var GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT = 35918;
+  var GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT = 35919;
+  var GL_EXTENSIONS_CONSTANTS = {
+    RGB: GL_RGB,
+    RGBA: GL_RGBA,
+    RGBA4: GL_RGBA4,
+    RGB5_A1: GL_RGB5_A1,
+    RGBA8: GL_RGBA8,
+    RGB565: GL_RGB565,
+    RGBA32F: GL_RGBA32F,
+    COMPRESSED_RGB_S3TC_DXT1_EXT: GL_COMPRESSED_RGB_S3TC_DXT1_EXT,
+    COMPRESSED_RGBA_S3TC_DXT1_EXT: GL_COMPRESSED_RGBA_S3TC_DXT1_EXT,
+    COMPRESSED_RGBA_S3TC_DXT3_EXT: GL_COMPRESSED_RGBA_S3TC_DXT3_EXT,
+    COMPRESSED_RGBA_S3TC_DXT5_EXT: GL_COMPRESSED_RGBA_S3TC_DXT5_EXT,
+    COMPRESSED_R11_EAC: GL_COMPRESSED_R11_EAC,
+    COMPRESSED_SIGNED_R11_EAC: GL_COMPRESSED_SIGNED_R11_EAC,
+    COMPRESSED_RG11_EAC: GL_COMPRESSED_RG11_EAC,
+    COMPRESSED_SIGNED_RG11_EAC: GL_COMPRESSED_SIGNED_RG11_EAC,
+    COMPRESSED_RGB8_ETC2: GL_COMPRESSED_RGB8_ETC2,
+    COMPRESSED_RGBA8_ETC2_EAC: GL_COMPRESSED_RGBA8_ETC2_EAC,
+    COMPRESSED_SRGB8_ETC2: GL_COMPRESSED_SRGB8_ETC2,
+    COMPRESSED_SRGB8_ALPHA8_ETC2_EAC: GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC,
+    COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2: GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2,
+    COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2: GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2,
+    COMPRESSED_RGB_PVRTC_4BPPV1_IMG: GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG,
+    COMPRESSED_RGB_PVRTC_2BPPV1_IMG: GL_COMPRESSED_RGB_PVRTC_2BPPV1_IMG,
+    COMPRESSED_RGBA_PVRTC_4BPPV1_IMG: GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG,
+    COMPRESSED_RGBA_PVRTC_2BPPV1_IMG: GL_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG,
+    COMPRESSED_RGB_ETC1_WEBGL: GL_COMPRESSED_RGB_ETC1_WEBGL,
+    COMPRESSED_RGB_ATC_WEBGL: GL_COMPRESSED_RGB_ATC_WEBGL,
+    COMPRESSED_RGBA_ATC_EXPLICIT_ALPHA_WEBGL: GL_COMPRESSED_RGBA_ATC_EXPLICIT_ALPHA_WEBGL,
+    COMPRESSED_RGBA_ATC_INTERPOLATED_ALPHA_WEBGL: GL_COMPRESSED_RGBA_ATC_INTERPOLATED_ALPHA_WEBGL,
+    COMPRESSED_RGBA_ASTC_4x4_KHR: GL_COMPRESSED_RGBA_ASTC_4x4_KHR,
+    COMPRESSED_RGBA_ASTC_5x4_KHR: GL_COMPRESSED_RGBA_ASTC_5x4_KHR,
+    COMPRESSED_RGBA_ASTC_5x5_KHR: GL_COMPRESSED_RGBA_ASTC_5x5_KHR,
+    COMPRESSED_RGBA_ASTC_6x5_KHR: GL_COMPRESSED_RGBA_ASTC_6x5_KHR,
+    COMPRESSED_RGBA_ASTC_6x6_KHR: GL_COMPRESSED_RGBA_ASTC_6x6_KHR,
+    COMPRESSED_RGBA_ASTC_8x5_KHR: GL_COMPRESSED_RGBA_ASTC_8x5_KHR,
+    COMPRESSED_RGBA_ASTC_8x6_KHR: GL_COMPRESSED_RGBA_ASTC_8x6_KHR,
+    COMPRESSED_RGBA_ASTC_8x8_KHR: GL_COMPRESSED_RGBA_ASTC_8x8_KHR,
+    COMPRESSED_RGBA_ASTC_10x5_KHR: GL_COMPRESSED_RGBA_ASTC_10x5_KHR,
+    COMPRESSED_RGBA_ASTC_10x6_KHR: GL_COMPRESSED_RGBA_ASTC_10x6_KHR,
+    COMPRESSED_RGBA_ASTC_10x8_KHR: GL_COMPRESSED_RGBA_ASTC_10x8_KHR,
+    COMPRESSED_RGBA_ASTC_10x10_KHR: GL_COMPRESSED_RGBA_ASTC_10x10_KHR,
+    COMPRESSED_RGBA_ASTC_12x10_KHR: GL_COMPRESSED_RGBA_ASTC_12x10_KHR,
+    COMPRESSED_RGBA_ASTC_12x12_KHR: GL_COMPRESSED_RGBA_ASTC_12x12_KHR,
+    COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR: GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR,
+    COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR: GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR,
+    COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR: GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR,
+    COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR: GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR,
+    COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR: GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR,
+    COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR: GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR,
+    COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR: GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR,
+    COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR: GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR,
+    COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR: GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR,
+    COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR: GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR,
+    COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR: GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR,
+    COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR: GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR,
+    COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR: GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR,
+    COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR: GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR,
+    COMPRESSED_RED_RGTC1_EXT: GL_COMPRESSED_RED_RGTC1_EXT,
+    COMPRESSED_SIGNED_RED_RGTC1_EXT: GL_COMPRESSED_SIGNED_RED_RGTC1_EXT,
+    COMPRESSED_RED_GREEN_RGTC2_EXT: GL_COMPRESSED_RED_GREEN_RGTC2_EXT,
+    COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT: GL_COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT,
+    COMPRESSED_RGBA_BPTC_UNORM_EXT: GL_COMPRESSED_RGBA_BPTC_UNORM_EXT,
+    COMPRESSED_SRGB_ALPHA_BPTC_UNORM_EXT: GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM_EXT,
+    COMPRESSED_RGB_BPTC_SIGNED_FLOAT_EXT: GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT_EXT,
+    COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_EXT: GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_EXT,
+    COMPRESSED_SRGB_S3TC_DXT1_EXT: GL_COMPRESSED_SRGB_S3TC_DXT1_EXT,
+    COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT: GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT,
+    COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT: GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT,
+    COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT: GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT,
+    // Deprecated legacy aliases with non-standard ASTC casing.
+    COMPRESSED_RGBA_ASTC_4X4_KHR: GL_COMPRESSED_RGBA_ASTC_4x4_KHR,
+    COMPRESSED_RGBA_ASTC_5X4_KHR: GL_COMPRESSED_RGBA_ASTC_5x4_KHR,
+    COMPRESSED_RGBA_ASTC_5X5_KHR: GL_COMPRESSED_RGBA_ASTC_5x5_KHR,
+    COMPRESSED_RGBA_ASTC_6X5_KHR: GL_COMPRESSED_RGBA_ASTC_6x5_KHR,
+    COMPRESSED_RGBA_ASTC_6X6_KHR: GL_COMPRESSED_RGBA_ASTC_6x6_KHR,
+    COMPRESSED_RGBA_ASTC_8X5_KHR: GL_COMPRESSED_RGBA_ASTC_8x5_KHR,
+    COMPRESSED_RGBA_ASTC_8X6_KHR: GL_COMPRESSED_RGBA_ASTC_8x6_KHR,
+    COMPRESSED_RGBA_ASTC_8X8_KHR: GL_COMPRESSED_RGBA_ASTC_8x8_KHR,
+    COMPRESSED_RGBA_ASTC_10X5_KHR: GL_COMPRESSED_RGBA_ASTC_10x5_KHR,
+    COMPRESSED_RGBA_ASTC_10X6_KHR: GL_COMPRESSED_RGBA_ASTC_10x6_KHR,
+    COMPRESSED_RGBA_ASTC_10X8_KHR: GL_COMPRESSED_RGBA_ASTC_10x8_KHR,
+    COMPRESSED_RGBA_ASTC_10X10_KHR: GL_COMPRESSED_RGBA_ASTC_10x10_KHR,
+    COMPRESSED_RGBA_ASTC_12X10_KHR: GL_COMPRESSED_RGBA_ASTC_12x10_KHR,
+    COMPRESSED_RGBA_ASTC_12X12_KHR: GL_COMPRESSED_RGBA_ASTC_12x12_KHR,
+    COMPRESSED_SRGB8_ALPHA8_ASTC_4X4_KHR: GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR,
+    COMPRESSED_SRGB8_ALPHA8_ASTC_5X4_KHR: GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR,
+    COMPRESSED_SRGB8_ALPHA8_ASTC_5X5_KHR: GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR,
+    COMPRESSED_SRGB8_ALPHA8_ASTC_6X5_KHR: GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR,
+    COMPRESSED_SRGB8_ALPHA8_ASTC_6X6_KHR: GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR,
+    COMPRESSED_SRGB8_ALPHA8_ASTC_8X5_KHR: GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR,
+    COMPRESSED_SRGB8_ALPHA8_ASTC_8X6_KHR: GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR,
+    COMPRESSED_SRGB8_ALPHA8_ASTC_8X8_KHR: GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR,
+    COMPRESSED_SRGB8_ALPHA8_ASTC_10X5_KHR: GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR,
+    COMPRESSED_SRGB8_ALPHA8_ASTC_10X6_KHR: GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR,
+    COMPRESSED_SRGB8_ALPHA8_ASTC_10X8_KHR: GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR,
+    COMPRESSED_SRGB8_ALPHA8_ASTC_10X10_KHR: GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR,
+    COMPRESSED_SRGB8_ALPHA8_ASTC_12X10_KHR: GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR,
+    COMPRESSED_SRGB8_ALPHA8_ASTC_12X12_KHR: GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR
+  };
+
+  // src/lib/utils/detect-supported-texture-formats.ts
+  var BROWSER_PREFIXES = ["", "WEBKIT_", "MOZ_"];
+  var WEBGL_TEXTURE_FORMATS = {
+    /* eslint-disable camelcase */
+    WEBGL_compressed_texture_s3tc: [
+      "bc1-rgb-unorm-webgl",
+      "bc1-rgba-unorm",
+      "bc2-rgba-unorm",
+      "bc3-rgba-unorm"
+    ],
+    WEBGL_compressed_texture_s3tc_srgb: [
+      "bc1-rgb-unorm-srgb-webgl",
+      "bc1-rgba-unorm-srgb",
+      "bc2-rgba-unorm-srgb",
+      "bc3-rgba-unorm-srgb"
+    ],
+    EXT_texture_compression_rgtc: ["bc4-r-unorm", "bc4-r-snorm", "bc5-rg-unorm", "bc5-rg-snorm"],
+    EXT_texture_compression_bptc: [
+      "bc6h-rgb-ufloat",
+      "bc6h-rgb-float",
+      "bc7-rgba-unorm",
+      "bc7-rgba-unorm-srgb"
+    ],
+    WEBGL_compressed_texture_etc1: ["etc1-rgb-unorm-webgl"],
+    WEBGL_compressed_texture_etc: [
+      "etc2-rgb8unorm",
+      "etc2-rgb8unorm-srgb",
+      "etc2-rgb8a1unorm",
+      "etc2-rgb8a1unorm-srgb",
+      "etc2-rgba8unorm",
+      "etc2-rgba8unorm-srgb",
+      "eac-r11unorm",
+      "eac-r11snorm",
+      "eac-rg11unorm",
+      "eac-rg11snorm"
+    ],
+    WEBGL_compressed_texture_pvrtc: [
+      "pvrtc-rgb4unorm-webgl",
+      "pvrtc-rgba4unorm-webgl",
+      "pvrtc-rgb2unorm-webgl",
+      "pvrtc-rgba2unorm-webgl"
+    ],
+    WEBGL_compressed_texture_atc: [
+      "atc-rgb-unorm-webgl",
+      "atc-rgba-unorm-webgl",
+      "atc-rgbai-unorm-webgl"
+    ],
+    WEBGL_compressed_texture_astc: [
+      "astc-4x4-unorm",
+      "astc-4x4-unorm-srgb",
+      "astc-5x4-unorm",
+      "astc-5x4-unorm-srgb",
+      "astc-5x5-unorm",
+      "astc-5x5-unorm-srgb",
+      "astc-6x5-unorm",
+      "astc-6x5-unorm-srgb",
+      "astc-6x6-unorm",
+      "astc-6x6-unorm-srgb",
+      "astc-8x5-unorm",
+      "astc-8x5-unorm-srgb",
+      "astc-8x6-unorm",
+      "astc-8x6-unorm-srgb",
+      "astc-8x8-unorm",
+      "astc-8x8-unorm-srgb",
+      "astc-10x5-unorm",
+      "astc-10x5-unorm-srgb",
+      "astc-10x6-unorm",
+      "astc-10x6-unorm-srgb",
+      "astc-10x8-unorm",
+      "astc-10x8-unorm-srgb",
+      "astc-10x10-unorm",
+      "astc-10x10-unorm-srgb",
+      "astc-12x10-unorm",
+      "astc-12x10-unorm-srgb",
+      "astc-12x12-unorm",
+      "astc-12x12-unorm-srgb"
+    ]
+    /* eslint-enable camelcase */
+  };
+  var textureFormats = null;
+  function detectSupportedTextureFormats(gl) {
+    if (!textureFormats) {
+      gl = gl || getWebGLContext() || void 0;
+      textureFormats = /* @__PURE__ */ new Set();
+      for (const prefix of BROWSER_PREFIXES) {
+        for (const extension in WEBGL_TEXTURE_FORMATS) {
+          if (gl && gl.getExtension(`${prefix}${extension}`)) {
+            for (const textureFormat of WEBGL_TEXTURE_FORMATS[extension]) {
+              textureFormats.add(textureFormat);
+            }
+          }
+        }
+      }
+    }
+    return textureFormats;
+  }
+  function getWebGLContext() {
+    try {
+      const canvas = document.createElement("canvas");
+      return canvas.getContext("webgl");
+    } catch (error) {
+      return null;
+    }
+  }
+
+  // ../../node_modules/ktx-parse/dist/ktx-parse.modern.js
+  var KHR_SUPERCOMPRESSION_NONE = 0;
+  var KHR_DF_KHR_DESCRIPTORTYPE_BASICFORMAT = 0;
+  var KHR_DF_VENDORID_KHRONOS = 0;
   var KHR_DF_VERSION = 2;
   var KHR_DF_MODEL_UNSPECIFIED = 0;
   var KHR_DF_FLAG_ALPHA_STRAIGHT = 0;
@@ -703,23 +1670,113 @@ var __exports__ = (() => {
     return container;
   }
 
+  // src/lib/utils/texture-format-map.ts
+  var WEBGL_TO_TEXTURE_FORMAT = {
+    [GL_RGBA32F]: "rgba32float",
+    [GL_COMPRESSED_RGB_S3TC_DXT1_EXT]: "bc1-rgb-unorm-webgl",
+    [GL_COMPRESSED_SRGB_S3TC_DXT1_EXT]: "bc1-rgb-unorm-srgb-webgl",
+    [GL_COMPRESSED_RGBA_S3TC_DXT1_EXT]: "bc1-rgba-unorm",
+    [GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT]: "bc1-rgba-unorm-srgb",
+    [GL_COMPRESSED_RGBA_S3TC_DXT3_EXT]: "bc2-rgba-unorm",
+    [GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT]: "bc2-rgba-unorm-srgb",
+    [GL_COMPRESSED_RGBA_S3TC_DXT5_EXT]: "bc3-rgba-unorm",
+    [GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT]: "bc3-rgba-unorm-srgb",
+    [GL_COMPRESSED_RED_RGTC1_EXT]: "bc4-r-unorm",
+    [GL_COMPRESSED_SIGNED_RED_RGTC1_EXT]: "bc4-r-snorm",
+    [GL_COMPRESSED_RED_GREEN_RGTC2_EXT]: "bc5-rg-unorm",
+    [GL_COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT]: "bc5-rg-snorm",
+    [GL_COMPRESSED_RGB8_ETC2]: "etc2-rgb8unorm",
+    [GL_COMPRESSED_SRGB8_ETC2]: "etc2-rgb8unorm-srgb",
+    [GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2]: "etc2-rgb8a1unorm",
+    [GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2]: "etc2-rgb8a1unorm-srgb",
+    [GL_COMPRESSED_RGBA8_ETC2_EAC]: "etc2-rgba8unorm",
+    [GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC]: "etc2-rgba8unorm-srgb",
+    [GL_COMPRESSED_R11_EAC]: "eac-r11unorm",
+    [GL_COMPRESSED_SIGNED_R11_EAC]: "eac-r11snorm",
+    [GL_COMPRESSED_RG11_EAC]: "eac-rg11unorm",
+    [GL_COMPRESSED_SIGNED_RG11_EAC]: "eac-rg11snorm",
+    [GL_COMPRESSED_RGBA_ASTC_4x4_KHR]: "astc-4x4-unorm",
+    [GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR]: "astc-4x4-unorm-srgb",
+    [GL_COMPRESSED_RGBA_ASTC_5x4_KHR]: "astc-5x4-unorm",
+    [GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR]: "astc-5x4-unorm-srgb",
+    [GL_COMPRESSED_RGBA_ASTC_5x5_KHR]: "astc-5x5-unorm",
+    [GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR]: "astc-5x5-unorm-srgb",
+    [GL_COMPRESSED_RGBA_ASTC_6x5_KHR]: "astc-6x5-unorm",
+    [GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR]: "astc-6x5-unorm-srgb",
+    [GL_COMPRESSED_RGBA_ASTC_6x6_KHR]: "astc-6x6-unorm",
+    [GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR]: "astc-6x6-unorm-srgb",
+    [GL_COMPRESSED_RGBA_ASTC_8x5_KHR]: "astc-8x5-unorm",
+    [GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR]: "astc-8x5-unorm-srgb",
+    [GL_COMPRESSED_RGBA_ASTC_8x6_KHR]: "astc-8x6-unorm",
+    [GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR]: "astc-8x6-unorm-srgb",
+    [GL_COMPRESSED_RGBA_ASTC_8x8_KHR]: "astc-8x8-unorm",
+    [GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR]: "astc-8x8-unorm-srgb",
+    [GL_COMPRESSED_RGBA_ASTC_10x5_KHR]: "astc-10x5-unorm",
+    [GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR]: "astc-10x5-unorm-srgb",
+    [GL_COMPRESSED_RGBA_ASTC_10x6_KHR]: "astc-10x6-unorm",
+    [GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR]: "astc-10x6-unorm-srgb",
+    [GL_COMPRESSED_RGBA_ASTC_10x8_KHR]: "astc-10x8-unorm",
+    [GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR]: "astc-10x8-unorm-srgb",
+    [GL_COMPRESSED_RGBA_ASTC_10x10_KHR]: "astc-10x10-unorm",
+    [GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR]: "astc-10x10-unorm-srgb",
+    [GL_COMPRESSED_RGBA_ASTC_12x10_KHR]: "astc-12x10-unorm",
+    [GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR]: "astc-12x10-unorm-srgb",
+    [GL_COMPRESSED_RGBA_ASTC_12x12_KHR]: "astc-12x12-unorm",
+    [GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR]: "astc-12x12-unorm-srgb",
+    [GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG]: "pvrtc-rgb4unorm-webgl",
+    [GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG]: "pvrtc-rgba4unorm-webgl",
+    [GL_COMPRESSED_RGB_PVRTC_2BPPV1_IMG]: "pvrtc-rgb2unorm-webgl",
+    [GL_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG]: "pvrtc-rgba2unorm-webgl",
+    [GL_COMPRESSED_RGB_ETC1_WEBGL]: "etc1-rgb-unorm-webgl",
+    [GL_COMPRESSED_RGB_ATC_WEBGL]: "atc-rgb-unorm-webgl",
+    [GL_COMPRESSED_RGBA_ATC_EXPLICIT_ALPHA_WEBGL]: "atc-rgba-unorm-webgl",
+    [GL_COMPRESSED_RGBA_ATC_INTERPOLATED_ALPHA_WEBGL]: "atc-rgbai-unorm-webgl"
+  };
+  var TEXTURE_FORMAT_TO_WEBGL = Object.fromEntries(
+    Object.entries(WEBGL_TO_TEXTURE_FORMAT).map(([format, textureFormat]) => [
+      textureFormat,
+      Number(format)
+    ])
+  );
+  function getTextureFormatFromWebGLFormat(format) {
+    if (format === void 0) {
+      return void 0;
+    }
+    return WEBGL_TO_TEXTURE_FORMAT[format];
+  }
+  function getWebGLFormatFromTextureFormat(textureFormat) {
+    if (textureFormat === void 0) {
+      return void 0;
+    }
+    return TEXTURE_FORMAT_TO_WEBGL[textureFormat];
+  }
+
   // src/lib/utils/extract-mipmap-images.ts
   function extractMipmapImages(data, options) {
     const images = new Array(options.mipMapLevels);
+    const textureFormat = options.textureFormat || getTextureFormatFromWebGLFormat(options.internalFormat);
+    const format = options.internalFormat || getWebGLFormatFromTextureFormat(options.textureFormat);
     let levelWidth = options.width;
     let levelHeight = options.height;
     let offset = 0;
     for (let i = 0; i < options.mipMapLevels; ++i) {
       const levelSize = getLevelSize(options, levelWidth, levelHeight, data, i);
       const levelData = getLevelData(data, i, offset, levelSize);
-      images[i] = {
+      const image = {
+        shape: "texture-level",
         compressed: true,
-        format: options.internalFormat,
         data: levelData,
         width: levelWidth,
         height: levelHeight,
         levelSize
       };
+      if (format !== void 0) {
+        image.format = format;
+      }
+      if (textureFormat) {
+        image.textureFormat = textureFormat;
+      }
+      images[i] = image;
       levelWidth = Math.max(1, levelWidth >> 1);
       levelHeight = Math.max(1, levelHeight >> 1);
       offset += levelSize;
@@ -741,118 +1798,79 @@ var __exports__ = (() => {
 
   // src/lib/utils/ktx-format-helper.ts
   var VULKAN_TO_WEBGL_FORMAT_MAP = {
-    131: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGB_S3TC_DXT1_EXT,
-    132: GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB_S3TC_DXT1_EXT,
-    133: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_S3TC_DXT1_EXT,
-    134: GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT,
-    135: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_S3TC_DXT3_EXT,
-    136: GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT,
-    137: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_S3TC_DXT5_EXT,
-    138: GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT,
-    139: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RED_RGTC1_EXT,
-    140: GL_EXTENSIONS_CONSTANTS.COMPRESSED_SIGNED_RED_RGTC1_EXT,
-    141: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RED_GREEN_RGTC2_EXT,
-    142: GL_EXTENSIONS_CONSTANTS.COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT,
-    147: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGB8_ETC2,
-    148: GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ETC2,
-    149: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2,
-    150: GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2,
-    151: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA8_ETC2_EAC,
-    152: GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ETC2_EAC,
-    153: GL_EXTENSIONS_CONSTANTS.COMPRESSED_R11_EAC,
-    154: GL_EXTENSIONS_CONSTANTS.COMPRESSED_SIGNED_R11_EAC,
-    155: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RG11_EAC,
-    156: GL_EXTENSIONS_CONSTANTS.COMPRESSED_SIGNED_RG11_EAC,
-    // @ts-ignore
-    157: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_4x4_KHR,
-    // @ts-ignore
-    158: GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR,
-    // @ts-ignore
-    159: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_5x4_KHR,
-    // @ts-ignore
-    160: GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_5X4_KHR,
-    // @ts-ignore
-    161: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_5x5_KHR,
-    // @ts-ignore
-    162: GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR,
-    // @ts-ignore
-    163: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_6x5_KHR,
-    // @ts-ignore
-    164: GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR,
-    // @ts-ignore
-    165: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_6x6_KHR,
-    // @ts-ignore
-    166: GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR,
-    // @ts-ignore
-    167: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_8x5_KHR,
-    // @ts-ignore
-    168: GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR,
-    // @ts-ignore
-    169: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_8x6_KHR,
-    // @ts-ignore
-    170: GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR,
-    // @ts-ignore
-    171: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_8x8_KHR,
-    // @ts-ignore
-    172: GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR,
-    // @ts-ignore
-    173: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_10x5_KHR,
-    // @ts-ignore
-    174: GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR,
-    // @ts-ignore
-    175: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_10x6_KHR,
-    // @ts-ignore
-    176: GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR,
-    // @ts-ignore
-    177: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_10x8_KHR,
-    // @ts-ignore
-    178: GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR,
-    // @ts-ignore
-    179: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_10x10_KHR,
-    // @ts-ignore
-    180: GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR,
-    // @ts-ignore
-    181: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_12x10_KHR,
-    // @ts-ignore
-    182: GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR,
-    // @ts-ignore
-    183: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_12x12_KHR,
-    // @ts-ignore
-    184: GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR,
-    1000054e3: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_PVRTC_2BPPV1_IMG,
-    1000054001: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_PVRTC_4BPPV1_IMG,
-    // @ts-ignore
-    1000066e3: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_4x4_KHR,
-    // @ts-ignore
-    1000066001: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_5x4_KHR,
-    // @ts-ignore
-    1000066002: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_5x5_KHR,
-    // @ts-ignore
-    1000066003: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_6x5_KHR,
-    // @ts-ignore
-    1000066004: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_6x6_KHR,
-    // @ts-ignore
-    1000066005: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_8x5_KHR,
-    // @ts-ignore
-    1000066006: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_8x6_KHR,
-    // @ts-ignore
-    1000066007: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_8x8_KHR,
-    // @ts-ignore
-    1000066008: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_10x5_KHR,
-    // @ts-ignore
-    1000066009: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_10x6_KHR,
-    // @ts-ignore
-    1000066010: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_10x8_KHR,
-    // @ts-ignore
-    1000066011: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_10x10_KHR,
-    // @ts-ignore
-    1000066012: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_12x10_KHR,
-    // @ts-ignore
-    1000066013: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_12x12_KHR
+    131: GL_COMPRESSED_RGB_S3TC_DXT1_EXT,
+    132: GL_COMPRESSED_SRGB_S3TC_DXT1_EXT,
+    133: GL_COMPRESSED_RGBA_S3TC_DXT1_EXT,
+    134: GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT,
+    135: GL_COMPRESSED_RGBA_S3TC_DXT3_EXT,
+    136: GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT,
+    137: GL_COMPRESSED_RGBA_S3TC_DXT5_EXT,
+    138: GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT,
+    139: GL_COMPRESSED_RED_RGTC1_EXT,
+    140: GL_COMPRESSED_SIGNED_RED_RGTC1_EXT,
+    141: GL_COMPRESSED_RED_GREEN_RGTC2_EXT,
+    142: GL_COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT,
+    147: GL_COMPRESSED_RGB8_ETC2,
+    148: GL_COMPRESSED_SRGB8_ETC2,
+    149: GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2,
+    150: GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2,
+    151: GL_COMPRESSED_RGBA8_ETC2_EAC,
+    152: GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC,
+    153: GL_COMPRESSED_R11_EAC,
+    154: GL_COMPRESSED_SIGNED_R11_EAC,
+    155: GL_COMPRESSED_RG11_EAC,
+    156: GL_COMPRESSED_SIGNED_RG11_EAC,
+    157: GL_COMPRESSED_RGBA_ASTC_4x4_KHR,
+    158: GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR,
+    159: GL_COMPRESSED_RGBA_ASTC_5x4_KHR,
+    160: GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR,
+    161: GL_COMPRESSED_RGBA_ASTC_5x5_KHR,
+    162: GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR,
+    163: GL_COMPRESSED_RGBA_ASTC_6x5_KHR,
+    164: GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR,
+    165: GL_COMPRESSED_RGBA_ASTC_6x6_KHR,
+    166: GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR,
+    167: GL_COMPRESSED_RGBA_ASTC_8x5_KHR,
+    168: GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR,
+    169: GL_COMPRESSED_RGBA_ASTC_8x6_KHR,
+    170: GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR,
+    171: GL_COMPRESSED_RGBA_ASTC_8x8_KHR,
+    172: GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR,
+    173: GL_COMPRESSED_RGBA_ASTC_10x5_KHR,
+    174: GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR,
+    175: GL_COMPRESSED_RGBA_ASTC_10x6_KHR,
+    176: GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR,
+    177: GL_COMPRESSED_RGBA_ASTC_10x8_KHR,
+    178: GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR,
+    179: GL_COMPRESSED_RGBA_ASTC_10x10_KHR,
+    180: GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR,
+    181: GL_COMPRESSED_RGBA_ASTC_12x10_KHR,
+    182: GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR,
+    183: GL_COMPRESSED_RGBA_ASTC_12x12_KHR,
+    184: GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR,
+    1000054e3: GL_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG,
+    1000054001: GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG,
+    1000066e3: GL_COMPRESSED_RGBA_ASTC_4x4_KHR,
+    1000066001: GL_COMPRESSED_RGBA_ASTC_5x4_KHR,
+    1000066002: GL_COMPRESSED_RGBA_ASTC_5x5_KHR,
+    1000066003: GL_COMPRESSED_RGBA_ASTC_6x5_KHR,
+    1000066004: GL_COMPRESSED_RGBA_ASTC_6x6_KHR,
+    1000066005: GL_COMPRESSED_RGBA_ASTC_8x5_KHR,
+    1000066006: GL_COMPRESSED_RGBA_ASTC_8x6_KHR,
+    1000066007: GL_COMPRESSED_RGBA_ASTC_8x8_KHR,
+    1000066008: GL_COMPRESSED_RGBA_ASTC_10x5_KHR,
+    1000066009: GL_COMPRESSED_RGBA_ASTC_10x6_KHR,
+    1000066010: GL_COMPRESSED_RGBA_ASTC_10x8_KHR,
+    1000066011: GL_COMPRESSED_RGBA_ASTC_10x10_KHR,
+    1000066012: GL_COMPRESSED_RGBA_ASTC_12x10_KHR,
+    1000066013: GL_COMPRESSED_RGBA_ASTC_12x12_KHR
   };
   function mapVkFormatToWebGL(vkFormat) {
     return VULKAN_TO_WEBGL_FORMAT_MAP[vkFormat];
   }
+  function mapVkFormatToTextureFormat(vkFormat) {
+    return getTextureFormatFromWebGLFormat(mapVkFormatToWebGL(vkFormat));
+  }
 
   // src/lib/parsers/parse-ktx.ts
   var KTX2_ID2 = [
@@ -892,85 +1910,171 @@ var __exports__ = (() => {
     const mipMapLevels = Math.max(1, ktx.levels.length);
     const width = ktx.pixelWidth;
     const height = ktx.pixelHeight;
-    const internalFormat = mapVkFormatToWebGL(ktx.vkFormat);
+    const textureFormat = mapVkFormatToTextureFormat(ktx.vkFormat);
+    if (textureFormat === void 0) {
+      log.warn(
+        `KTX2 container vkFormat ${ktx.vkFormat} does not map to a known texture format; returning texture levels without format metadata.`
+      )();
+    }
     return extractMipmapImages(ktx.levels, {
       mipMapLevels,
       width,
       height,
       sizeFunction: (level) => level.uncompressedByteLength,
-      internalFormat
+      textureFormat
     });
   }
 
   // src/lib/parsers/parse-basis.ts
-  var OutputFormat = {
+  var basisTranscodingLock = Promise.resolve();
+  var BASIS_FORMAT_TO_OUTPUT_OPTIONS = {
     etc1: {
       basisFormat: 0,
       compressed: true,
-      format: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGB_ETC1_WEBGL
+      format: GL_COMPRESSED_RGB_ETC1_WEBGL,
+      textureFormat: "etc1-rgb-unorm-webgl"
+    },
+    etc2: {
+      basisFormat: 1,
+      compressed: true,
+      format: GL_COMPRESSED_RGBA8_ETC2_EAC,
+      textureFormat: "etc2-rgba8unorm"
     },
-    etc2: { basisFormat: 1, compressed: true },
     bc1: {
       basisFormat: 2,
       compressed: true,
-      format: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGB_S3TC_DXT1_EXT
+      format: GL_COMPRESSED_RGB_S3TC_DXT1_EXT,
+      textureFormat: "bc1-rgb-unorm-webgl"
     },
     bc3: {
       basisFormat: 3,
       compressed: true,
-      format: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_S3TC_DXT5_EXT
+      format: GL_COMPRESSED_RGBA_S3TC_DXT5_EXT,
+      textureFormat: "bc3-rgba-unorm"
+    },
+    bc4: {
+      basisFormat: 4,
+      compressed: true,
+      format: GL_COMPRESSED_RED_RGTC1_EXT,
+      textureFormat: "bc4-r-unorm"
+    },
+    bc5: {
+      basisFormat: 5,
+      compressed: true,
+      format: GL_COMPRESSED_RED_GREEN_RGTC2_EXT,
+      textureFormat: "bc5-rg-unorm"
+    },
+    "bc7-m6-opaque-only": {
+      basisFormat: 6,
+      compressed: true,
+      format: GL_COMPRESSED_RGBA_BPTC_UNORM_EXT,
+      textureFormat: "bc7-rgba-unorm"
+    },
+    "bc7-m5": {
+      basisFormat: 7,
+      compressed: true,
+      format: GL_COMPRESSED_RGBA_BPTC_UNORM_EXT,
+      textureFormat: "bc7-rgba-unorm"
     },
-    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
+      format: GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG,
+      textureFormat: "pvrtc-rgb4unorm-webgl"
     },
     "pvrtc1-4-rgba": {
       basisFormat: 9,
       compressed: true,
-      format: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_PVRTC_4BPPV1_IMG
+      format: GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG,
+      textureFormat: "pvrtc-rgba4unorm-webgl"
     },
     "astc-4x4": {
       basisFormat: 10,
       compressed: true,
-      format: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_4X4_KHR
+      format: GL_COMPRESSED_RGBA_ASTC_4x4_KHR,
+      textureFormat: "astc-4x4-unorm"
     },
-    "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 }
-  };
-  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 loadBasisTranscoderModule(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 loadBasisTranscoderModule(options);
-        return parseBasisFile(BasisFile, data, options);
+    "atc-rgb": {
+      basisFormat: 11,
+      compressed: true,
+      format: GL_COMPRESSED_RGB_ATC_WEBGL,
+      textureFormat: "atc-rgb-unorm-webgl"
+    },
+    "atc-rgba-interpolated-alpha": {
+      basisFormat: 12,
+      compressed: true,
+      format: GL_COMPRESSED_RGBA_ATC_INTERPOLATED_ALPHA_WEBGL,
+      textureFormat: "atc-rgbai-unorm-webgl"
+    },
+    rgba32: {
+      basisFormat: 13,
+      compressed: false,
+      format: GL_RGBA8,
+      textureFormat: "rgba8unorm"
+    },
+    rgb565: {
+      basisFormat: 14,
+      compressed: false,
+      format: GL_RGB565,
+      textureFormat: "rgb565unorm-webgl"
+    },
+    bgr565: {
+      basisFormat: 15,
+      compressed: false,
+      format: GL_RGB565,
+      textureFormat: "rgb565unorm-webgl"
+    },
+    rgba4444: {
+      basisFormat: 16,
+      compressed: false,
+      format: GL_RGBA4,
+      textureFormat: "rgba4unorm-webgl"
+    }
+  };
+  var BASIS_FORMATS = Object.freeze(
+    Object.keys(BASIS_FORMAT_TO_OUTPUT_OPTIONS)
+  );
+  async function withBasisTranscodingLock(transcode) {
+    const previousLock = basisTranscodingLock;
+    let releaseLock;
+    basisTranscodingLock = new Promise((resolve2) => {
+      releaseLock = resolve2;
+    });
+    await previousLock;
+    try {
+      return await transcode();
+    } finally {
+      releaseLock();
     }
   }
+  async function parseBasis(data, options = {}) {
+    const loadLibraryOptions = extractLoadLibraryOptions(options);
+    return await withBasisTranscodingLock(async () => {
+      if (!options.basis?.containerFormat || options.basis.containerFormat === "auto") {
+        if (isKTX(data)) {
+          const fileConstructors = await loadBasisEncoderModule(loadLibraryOptions);
+          return parseKTX2File(fileConstructors.KTX2File, data, options);
+        }
+        const { BasisFile } = await loadBasisTranscoderModule(loadLibraryOptions);
+        return parseBasisFile(BasisFile, data, options);
+      }
+      switch (options.basis.module) {
+        case "encoder":
+          const fileConstructors = await loadBasisEncoderModule(loadLibraryOptions);
+          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 loadBasisTranscoderModule(loadLibraryOptions);
+          return parseBasisFile(BasisFile, data, options);
+      }
+    });
+  }
   function parseBasisFile(BasisFile, data, options) {
     const basisFile = new BasisFile(new Uint8Array(data));
     try {
@@ -999,7 +2103,7 @@ var __exports__ = (() => {
     const hasAlpha = basisFile.getHasAlpha(
       /* imageIndex, levelIndex */
     );
-    const { compressed, format, basisFormat } = getBasisOptions(options, hasAlpha);
+    const { compressed, format, basisFormat, textureFormat } = getBasisOptions(options, hasAlpha);
     const decodedSize = basisFile.getImageTranscodedSizeInBytes(imageIndex, levelIndex, basisFormat);
     const decodedData = new Uint8Array(decodedSize);
     if (!basisFile.transcodeImage(decodedData, imageIndex, levelIndex, basisFormat, 0, 0)) {
@@ -1007,11 +2111,13 @@ var __exports__ = (() => {
     }
     return {
       // standard loaders.gl image category payload
+      shape: "texture-level",
       width,
       height,
       data: decodedData,
       compressed,
-      format,
+      ...format !== void 0 ? { format } : {},
+      ...textureFormat !== void 0 ? { textureFormat } : {},
       // Additional fields
       // Add levelSize field.
       hasAlpha
@@ -1036,7 +2142,7 @@ var __exports__ = (() => {
   }
   function transcodeKTX2Image(ktx2File, levelIndex, options) {
     const { alphaFlag, height, width } = ktx2File.getImageLevelInfo(levelIndex, 0, 0);
-    const { compressed, format, basisFormat } = getBasisOptions(options, alphaFlag);
+    const { compressed, format, basisFormat, textureFormat } = getBasisOptions(options, alphaFlag);
     const decodedSize = ktx2File.getImageTranscodedSizeInBytes(
       levelIndex,
       0,
@@ -1059,48 +2165,98 @@ var __exports__ = (() => {
     }
     return {
       // standard loaders.gl image category payload
+      shape: "texture-level",
       width,
       height,
       data: decodedData,
       compressed,
+      ...format !== void 0 ? { format } : {},
+      ...textureFormat !== void 0 ? { textureFormat } : {},
       // Additional fields
       levelSize: decodedSize,
-      hasAlpha: alphaFlag,
-      format
+      hasAlpha: alphaFlag
     };
   }
   function getBasisOptions(options, hasAlpha) {
-    let format = options && options.basis && options.basis.format;
+    let format = options.basis?.format || "auto";
     if (format === "auto") {
-      format = selectSupportedBasisFormat();
+      format = options.basis?.supportedTextureFormats ? selectSupportedBasisFormat(options.basis.supportedTextureFormats) : selectSupportedBasisFormat();
     }
     if (typeof format === "object") {
       format = hasAlpha ? format.alpha : format.noAlpha;
     }
-    format = format.toLowerCase();
-    return OutputFormat[format];
+    const normalizedFormat = format.toLowerCase();
+    const basisOutputOptions = BASIS_FORMAT_TO_OUTPUT_OPTIONS[normalizedFormat];
+    if (!basisOutputOptions) {
+      throw new Error(`Unknown Basis format ${format}`);
+    }
+    return basisOutputOptions;
   }
-  function selectSupportedBasisFormat() {
-    const supportedFormats = getSupportedGPUTextureFormats();
-    if (supportedFormats.has("astc")) {
+  function selectSupportedBasisFormat(supportedTextureFormats = detectSupportedTextureFormats()) {
+    const textureFormats2 = new Set(supportedTextureFormats);
+    if (hasSupportedTextureFormat(textureFormats2, ["astc-4x4-unorm", "astc-4x4-unorm-srgb"])) {
       return "astc-4x4";
-    } else if (supportedFormats.has("dxt")) {
+    } else if (hasSupportedTextureFormat(textureFormats2, ["bc7-rgba-unorm", "bc7-rgba-unorm-srgb"])) {
+      return {
+        alpha: "bc7-m5",
+        noAlpha: "bc7-m6-opaque-only"
+      };
+    } else if (hasSupportedTextureFormat(textureFormats2, [
+      "bc1-rgb-unorm-webgl",
+      "bc1-rgb-unorm-srgb-webgl",
+      "bc1-rgba-unorm",
+      "bc1-rgba-unorm-srgb",
+      "bc2-rgba-unorm",
+      "bc2-rgba-unorm-srgb",
+      "bc3-rgba-unorm",
+      "bc3-rgba-unorm-srgb"
+    ])) {
       return {
         alpha: "bc3",
         noAlpha: "bc1"
       };
-    } else if (supportedFormats.has("pvrtc")) {
+    } else if (hasSupportedTextureFormat(textureFormats2, [
+      "pvrtc-rgb4unorm-webgl",
+      "pvrtc-rgba4unorm-webgl",
+      "pvrtc-rgb2unorm-webgl",
+      "pvrtc-rgba2unorm-webgl"
+    ])) {
       return {
         alpha: "pvrtc1-4-rgba",
         noAlpha: "pvrtc1-4-rgb"
       };
-    } else if (supportedFormats.has("etc1")) {
-      return "etc1";
-    } else if (supportedFormats.has("etc2")) {
+    } else if (hasSupportedTextureFormat(textureFormats2, [
+      "etc2-rgb8unorm",
+      "etc2-rgb8unorm-srgb",
+      "etc2-rgb8a1unorm",
+      "etc2-rgb8a1unorm-srgb",
+      "etc2-rgba8unorm",
+      "etc2-rgba8unorm-srgb",
+      "eac-r11unorm",
+      "eac-r11snorm",
+      "eac-rg11unorm",
+      "eac-rg11snorm"
+    ])) {
       return "etc2";
+    } else if (textureFormats2.has("etc1-rgb-unorm-webgl")) {
+      return "etc1";
+    } else if (hasSupportedTextureFormat(textureFormats2, [
+      "atc-rgb-unorm-webgl",
+      "atc-rgba-unorm-webgl",
+      "atc-rgbai-unorm-webgl"
+    ])) {
+      return {
+        alpha: "atc-rgba-interpolated-alpha",
+        noAlpha: "atc-rgb"
+      };
     }
     return "rgb565";
   }
+  function hasSupportedTextureFormat(supportedTextureFormats, candidateTextureFormats) {
+    return candidateTextureFormats.some(
+      (textureFormat) => supportedTextureFormats.has(textureFormat)
+    );
+  }
 
   // src/basis-loader.ts
   var BasisWorkerLoader = {
@@ -1118,7 +2274,6 @@ var __exports__ = (() => {
     options: {
       basis: {
         format: "auto",
-        libraryPath: "libs/",
         containerFormat: "auto",
         module: "transcoder"
       }
@@ -1144,13 +2299,13 @@ var __exports__ = (() => {
     DDSD_MIPMAPCOUNT: 131072,
     DDPF_FOURCC: 4
   };
-  var DDS_PIXEL_FORMATS = {
-    DXT1: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGB_S3TC_DXT1_EXT,
-    DXT3: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_S3TC_DXT3_EXT,
-    DXT5: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_S3TC_DXT5_EXT,
-    "ATC ": GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGB_ATC_WEBGL,
-    ATCA: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ATC_EXPLICIT_ALPHA_WEBGL,
-    ATCI: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ATC_INTERPOLATED_ALPHA_WEBGL
+  var DDS_TEXTURE_FORMATS = {
+    DXT1: "bc1-rgb-unorm-webgl",
+    DXT3: "bc2-rgba-unorm",
+    DXT5: "bc3-rgba-unorm",
+    "ATC ": "atc-rgb-unorm-webgl",
+    ATCA: "atc-rgba-unorm-webgl",
+    ATCI: "atc-rgbai-unorm-webgl"
   };
   var getATCLevelSize = getDxt1LevelSize;
   var getATCALevelSize = getDxtXLevelSize;
@@ -1171,14 +2326,14 @@ var __exports__ = (() => {
   function parseDDS(data) {
     const header = new Int32Array(data, 0, DDS_CONSTANTS.HEADER_LENGTH);
     const pixelFormatNumber = header[DDS_CONSTANTS.HEADER_PF_FOURCC_INDEX];
-    assert(
+    assert2(
       Boolean(header[DDS_CONSTANTS.HEADER_PF_FLAGS_INDEX] & DDS_CONSTANTS.DDPF_FOURCC),
       "DDS: Unsupported format, must contain a FourCC code"
     );
     const fourCC = int32ToFourCC(pixelFormatNumber);
-    const internalFormat = DDS_PIXEL_FORMATS[fourCC];
+    const textureFormat = DDS_TEXTURE_FORMATS[fourCC];
     const sizeFunction = DDS_SIZE_FUNCTIONS[fourCC];
-    assert(internalFormat && sizeFunction, `DDS: Unknown pixel format ${pixelFormatNumber}`);
+    assert2(textureFormat && sizeFunction, `DDS: Unknown pixel format ${pixelFormatNumber}`);
     let mipMapLevels = 1;
     if (header[DDS_CONSTANTS.HEADER_FLAGS_INDEX] & DDS_CONSTANTS.DDSD_MIPMAPCOUNT) {
       mipMapLevels = Math.max(1, header[DDS_CONSTANTS.MIPMAPCOUNT_INDEX]);
@@ -1192,7 +2347,7 @@ var __exports__ = (() => {
       width,
       height,
       sizeFunction,
-      internalFormat
+      textureFormat
     });
   }
   function getDxt1LevelSize(width, height) {
@@ -1224,76 +2379,34 @@ var __exports__ = (() => {
     MIPMAPCOUNT_INDEX: 11,
     METADATA_SIZE_INDEX: 12
   };
-  var PVR_PIXEL_FORMATS = {
-    0: [GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGB_PVRTC_2BPPV1_IMG],
-    1: [GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_PVRTC_2BPPV1_IMG],
-    2: [GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGB_PVRTC_4BPPV1_IMG],
-    3: [GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_PVRTC_4BPPV1_IMG],
-    6: [GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGB_ETC1_WEBGL],
-    7: [GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGB_S3TC_DXT1_EXT],
-    9: [GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_S3TC_DXT3_EXT],
-    11: [GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_S3TC_DXT5_EXT],
-    22: [GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGB8_ETC2],
-    23: [GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA8_ETC2_EAC],
-    24: [GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2],
-    25: [GL_EXTENSIONS_CONSTANTS.COMPRESSED_R11_EAC],
-    26: [GL_EXTENSIONS_CONSTANTS.COMPRESSED_RG11_EAC],
-    27: [
-      GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_4X4_KHR,
-      GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_4X4_KHR
-    ],
-    28: [
-      GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_5X4_KHR,
-      GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_5X4_KHR
-    ],
-    29: [
-      GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_5X5_KHR,
-      GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_5X5_KHR
-    ],
-    30: [
-      GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_6X5_KHR,
-      GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_6X5_KHR
-    ],
-    31: [
-      GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_6X6_KHR,
-      GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_6X6_KHR
-    ],
-    32: [
-      GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_8X5_KHR,
-      GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_8X5_KHR
-    ],
-    33: [
-      GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_8X6_KHR,
-      GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_8X6_KHR
-    ],
-    34: [
-      GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_8X8_KHR,
-      GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_8X8_KHR
-    ],
-    35: [
-      GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_10X5_KHR,
-      GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_10X5_KHR
-    ],
-    36: [
-      GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_10X6_KHR,
-      GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_10X6_KHR
-    ],
-    37: [
-      GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_10X8_KHR,
-      GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_10X8_KHR
-    ],
-    38: [
-      GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_10X10_KHR,
-      GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_10X10_KHR
-    ],
-    39: [
-      GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_12X10_KHR,
-      GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_12X10_KHR
-    ],
-    40: [
-      GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_12X12_KHR,
-      GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_12X12_KHR
-    ]
+  var PVR_TEXTURE_FORMATS = {
+    0: ["pvrtc-rgb2unorm-webgl"],
+    1: ["pvrtc-rgba2unorm-webgl"],
+    2: ["pvrtc-rgb4unorm-webgl"],
+    3: ["pvrtc-rgba4unorm-webgl"],
+    6: ["etc1-rgb-unorm-webgl"],
+    7: ["bc1-rgb-unorm-webgl"],
+    9: ["bc2-rgba-unorm"],
+    11: ["bc3-rgba-unorm"],
+    22: ["etc2-rgb8unorm"],
+    23: ["etc2-rgba8unorm"],
+    24: ["etc2-rgb8a1unorm"],
+    25: ["eac-r11unorm"],
+    26: ["eac-rg11unorm"],
+    27: ["astc-4x4-unorm", "astc-4x4-unorm-srgb"],
+    28: ["astc-5x4-unorm", "astc-5x4-unorm-srgb"],
+    29: ["astc-5x5-unorm", "astc-5x5-unorm-srgb"],
+    30: ["astc-6x5-unorm", "astc-6x5-unorm-srgb"],
+    31: ["astc-6x6-unorm", "astc-6x6-unorm-srgb"],
+    32: ["astc-8x5-unorm", "astc-8x5-unorm-srgb"],
+    33: ["astc-8x6-unorm", "astc-8x6-unorm-srgb"],
+    34: ["astc-8x8-unorm", "astc-8x8-unorm-srgb"],
+    35: ["astc-10x5-unorm", "astc-10x5-unorm-srgb"],
+    36: ["astc-10x6-unorm", "astc-10x6-unorm-srgb"],
+    37: ["astc-10x8-unorm", "astc-10x8-unorm-srgb"],
+    38: ["astc-10x10-unorm", "astc-10x10-unorm-srgb"],
+    39: ["astc-12x10-unorm", "astc-12x10-unorm-srgb"],
+    40: ["astc-12x12-unorm", "astc-12x12-unorm-srgb"]
   };
   var PVR_SIZE_FUNCTIONS = {
     0: pvrtc2bppSize,
@@ -1326,15 +2439,15 @@ var __exports__ = (() => {
   };
   function isPVR(data) {
     const header = new Uint32Array(data, 0, PVR_CONSTANTS.HEADER_LENGTH);
-    const version = header[PVR_CONSTANTS.MAGIC_NUMBER_INDEX];
-    return version === PVR_CONSTANTS.MAGIC_NUMBER || version === PVR_CONSTANTS.MAGIC_NUMBER_EXTRA;
+    const version2 = header[PVR_CONSTANTS.MAGIC_NUMBER_INDEX];
+    return version2 === PVR_CONSTANTS.MAGIC_NUMBER || version2 === PVR_CONSTANTS.MAGIC_NUMBER_EXTRA;
   }
   function parsePVR(data) {
     const header = new Uint32Array(data, 0, PVR_CONSTANTS.HEADER_LENGTH);
     const pvrFormat = header[PVR_CONSTANTS.PIXEL_FORMAT_INDEX];
     const colourSpace = header[PVR_CONSTANTS.COLOUR_SPACE_INDEX];
-    const pixelFormats = PVR_PIXEL_FORMATS[pvrFormat] || [];
-    const internalFormat = pixelFormats.length > 1 && colourSpace ? pixelFormats[1] : pixelFormats[0];
+    const textureFormats2 = PVR_TEXTURE_FORMATS[pvrFormat] || [];
+    const textureFormat = textureFormats2.length > 1 && colourSpace ? textureFormats2[1] : textureFormats2[0];
     const sizeFunction = PVR_SIZE_FUNCTIONS[pvrFormat];
     const mipMapLevels = header[PVR_CONSTANTS.MIPMAPCOUNT_INDEX];
     const width = header[PVR_CONSTANTS.WIDTH_INDEX];
@@ -1346,7 +2459,7 @@ var __exports__ = (() => {
       width,
       height,
       sizeFunction,
-      internalFormat
+      textureFormat
     });
   }
   function pvrtc2bppSize(width, height) {
@@ -1446,7 +2559,6 @@ var __exports__ = (() => {
     binary: true,
     options: {
       "compressed-texture": {
-        libraryPath: "libs/",
         useBasis: false
       }
     }
@@ -1454,13 +2566,13 @@ var __exports__ = (() => {
   var CompressedTextureLoader = {
     ...CompressedTextureWorkerLoader,
     parse: async (arrayBuffer, options) => {
+      options = { ...options };
       if (options?.["compressed-texture"]?.useBasis) {
         options.basis = {
           format: {
             alpha: "BC3",
             noAlpha: "BC1"
           },
-          // @ts-expect-error TODO not allowed to modify inputs
           ...options.basis,
           containerFormat: "ktx2",
           module: "encoder"
@@ -1485,10 +2597,334 @@ var __exports__ = (() => {
     mimeTypes: ["image/crn", "image/x-crn", "application/octet-stream"],
     binary: true,
     options: {
-      crunch: {
-        libraryPath: "libs/"
+      crunch: {}
+    }
+  };
+
+  // src/lib/parsers/parse-hdr.ts
+  var HDR_MAGIC_HEADERS = ["#?RADIANCE", "#?RGBE"];
+  var HDR_FORMAT = "32-bit_rle_rgbe";
+  function isHDR(arrayBuffer) {
+    const state = {
+      data: new Uint8Array(arrayBuffer),
+      offset: 0
+    };
+    const firstLine = readLine(state);
+    return firstLine ? HDR_MAGIC_HEADERS.includes(firstLine) : false;
+  }
+  function parseHDR(arrayBuffer) {
+    const state = {
+      data: new Uint8Array(arrayBuffer),
+      offset: 0
+    };
+    const header = readHeader(state);
+    const { width, height } = header;
+    const rgbeData = readPixels(state, header);
+    const data = convertRGBEToFloat(rgbeData);
+    const level = {
+      shape: "texture-level",
+      compressed: false,
+      width,
+      height,
+      data,
+      levelSize: data.byteLength,
+      format: GL_RGBA32F,
+      textureFormat: "rgba32float"
+    };
+    return {
+      shape: "texture",
+      type: "2d",
+      format: "rgba32float",
+      ...header.metadata ? { metadata: header.metadata } : {},
+      data: [level]
+    };
+  }
+  function readHeader(state) {
+    const magicHeader = readLine(state);
+    if (!magicHeader || !HDR_MAGIC_HEADERS.includes(magicHeader)) {
+      throw new Error("RadianceHDRLoader: bad initial token");
+    }
+    let hasFormat = false;
+    const metadata = {};
+    while (state.offset < state.data.length) {
+      const line = readLine(state);
+      if (line === null) {
+        break;
+      }
+      if (!line || line.startsWith("#")) {
+        continue;
+      }
+      if (line.startsWith("FORMAT=")) {
+        hasFormat = line.slice("FORMAT=".length) === HDR_FORMAT;
+        if (!hasFormat) {
+          throw new Error("RadianceHDRLoader: unsupported format specifier");
+        }
+        continue;
+      }
+      parseMetadataLine(metadata, line);
+      const dimensions = parseDimensions(line);
+      if (dimensions) {
+        if (!hasFormat) {
+          throw new Error("RadianceHDRLoader: missing format specifier");
+        }
+        return {
+          ...dimensions,
+          ...hasMetadata(metadata) ? { metadata } : {}
+        };
+      }
+    }
+    if (!hasFormat) {
+      throw new Error("RadianceHDRLoader: missing format specifier");
+    }
+    throw new Error("RadianceHDRLoader: missing image size specifier");
+  }
+  function parseDimensions(line) {
+    const match = line.match(/^([+-])([YX])\s+(\d+)\s+([+-])([YX])\s+(\d+)$/);
+    if (!match) {
+      return null;
+    }
+    const majorSign = match[1] === "+" ? 1 : -1;
+    const majorAxis = match[2];
+    const majorLength = Number(match[3]);
+    const minorSign = match[4] === "+" ? 1 : -1;
+    const minorAxis = match[5];
+    const minorLength = Number(match[6]);
+    if (majorAxis === minorAxis) {
+      throw new Error("RadianceHDRLoader: invalid image dimensions");
+    }
+    const width = majorAxis === "X" ? majorLength : minorLength;
+    const height = majorAxis === "Y" ? majorLength : minorLength;
+    if (!Number.isFinite(width) || !Number.isFinite(height) || width <= 0 || height <= 0) {
+      throw new Error("RadianceHDRLoader: invalid image dimensions");
+    }
+    return { width, height, majorAxis, majorSign, minorAxis, minorSign };
+  }
+  function readPixels(state, header) {
+    const { width, height } = header;
+    const pixelCount = width * height;
+    const flatByteLength = pixelCount * 4;
+    const scanlineLength = header.minorAxis === "X" ? width : height;
+    const scanlineCount = header.majorAxis === "Y" ? height : width;
+    if (scanlineLength < 8 || scanlineLength > 32767) {
+      return reorderPixels(readFlatPixels(state, flatByteLength), header);
+    }
+    if (state.offset + 4 > state.data.length) {
+      throw new Error("RadianceHDRLoader: unexpected end of file");
+    }
+    const data = state.data;
+    const isRunLengthEncoded = data[state.offset] === 2 && data[state.offset + 1] === 2 && !(data[state.offset + 2] & 128);
+    if (!isRunLengthEncoded) {
+      return reorderPixels(readFlatPixels(state, flatByteLength), header);
+    }
+    const scanlineWidth = data[state.offset + 2] << 8 | data[state.offset + 3];
+    if (scanlineWidth !== scanlineLength) {
+      return reorderPixels(readFlatPixels(state, flatByteLength), header);
+    }
+    const pixels = new Uint8Array(flatByteLength);
+    const scanlineBuffer = new Uint8Array(scanlineLength * 4);
+    for (let scanlineIndex = 0; scanlineIndex < scanlineCount; scanlineIndex++) {
+      if (state.offset + 4 > data.length) {
+        throw new Error("RadianceHDRLoader: unexpected end of file");
+      }
+      const red = data[state.offset++];
+      const green = data[state.offset++];
+      const blue = data[state.offset++];
+      const exponent = data[state.offset++];
+      if (red !== 2 || green !== 2 || (blue << 8 | exponent) !== scanlineLength) {
+        throw new Error("RadianceHDRLoader: bad rgbe scanline format");
+      }
+      for (let channelIndex = 0; channelIndex < 4; channelIndex++) {
+        const channelOffset = channelIndex * scanlineLength;
+        const channelEnd = channelOffset + scanlineLength;
+        let pixelOffset = channelOffset;
+        while (pixelOffset < channelEnd) {
+          if (state.offset >= data.length) {
+            throw new Error("RadianceHDRLoader: unexpected end of file");
+          }
+          let count = data[state.offset++];
+          if (count > 128) {
+            count -= 128;
+            if (count === 0 || pixelOffset + count > channelEnd || state.offset >= data.length) {
+              throw new Error("RadianceHDRLoader: bad scanline data");
+            }
+            const value = data[state.offset++];
+            scanlineBuffer.fill(value, pixelOffset, pixelOffset + count);
+            pixelOffset += count;
+            continue;
+          }
+          if (count === 0 || pixelOffset + count > channelEnd || state.offset + count > data.length) {
+            throw new Error("RadianceHDRLoader: bad scanline data");
+          }
+          scanlineBuffer.set(data.subarray(state.offset, state.offset + count), pixelOffset);
+          pixelOffset += count;
+          state.offset += count;
+        }
+      }
+      for (let pixelIndex = 0; pixelIndex < scanlineLength; pixelIndex++) {
+        const outputOffset = getOutputOffset(header, scanlineIndex, pixelIndex);
+        pixels[outputOffset] = scanlineBuffer[pixelIndex];
+        pixels[outputOffset + 1] = scanlineBuffer[pixelIndex + scanlineLength];
+        pixels[outputOffset + 2] = scanlineBuffer[pixelIndex + scanlineLength * 2];
+        pixels[outputOffset + 3] = scanlineBuffer[pixelIndex + scanlineLength * 3];
+      }
+    }
+    return pixels;
+  }
+  function reorderPixels(data, header) {
+    const pixels = new Uint8Array(data.length);
+    const scanlineLength = header.minorAxis === "X" ? header.width : header.height;
+    const scanlineCount = header.majorAxis === "Y" ? header.height : header.width;
+    for (let scanlineIndex = 0; scanlineIndex < scanlineCount; scanlineIndex++) {
+      for (let pixelIndex = 0; pixelIndex < scanlineLength; pixelIndex++) {
+        const sourceOffset = (scanlineIndex * scanlineLength + pixelIndex) * 4;
+        const outputOffset = getOutputOffset(header, scanlineIndex, pixelIndex);
+        pixels[outputOffset] = data[sourceOffset];
+        pixels[outputOffset + 1] = data[sourceOffset + 1];
+        pixels[outputOffset + 2] = data[sourceOffset + 2];
+        pixels[outputOffset + 3] = data[sourceOffset + 3];
+      }
+    }
+    return pixels;
+  }
+  function getOutputOffset(header, scanlineIndex, pixelIndex) {
+    const majorCoordinate = getCoordinate(
+      header.majorAxis === "X" ? header.width : header.height,
+      header.majorSign,
+      scanlineIndex
+    );
+    const minorCoordinate = getCoordinate(
+      header.minorAxis === "X" ? header.width : header.height,
+      header.minorSign,
+      pixelIndex
+    );
+    const x = header.majorAxis === "X" ? majorCoordinate : minorCoordinate;
+    const y = header.majorAxis === "Y" ? majorCoordinate : minorCoordinate;
+    return ((header.height - 1 - y) * header.width + x) * 4;
+  }
+  function getCoordinate(length, sign, index) {
+    return sign === 1 ? index : length - 1 - index;
+  }
+  function readFlatPixels(state, byteLength) {
+    if (state.offset + byteLength > state.data.length) {
+      throw new Error("RadianceHDRLoader: unexpected end of file");
+    }
+    const pixels = state.data.slice(state.offset, state.offset + byteLength);
+    state.offset += byteLength;
+    return pixels;
+  }
+  function convertRGBEToFloat(data) {
+    const floatData = new Float32Array(data.length);
+    for (let sourceOffset = 0; sourceOffset < data.length; sourceOffset += 4) {
+      const exponent = data[sourceOffset + 3];
+      const destinationOffset = sourceOffset;
+      if (exponent > 0) {
+        const scale = Math.pow(2, exponent - 128) / 255;
+        floatData[destinationOffset] = data[sourceOffset] * scale;
+        floatData[destinationOffset + 1] = data[sourceOffset + 1] * scale;
+        floatData[destinationOffset + 2] = data[sourceOffset + 2] * scale;
+      }
+      floatData[destinationOffset + 3] = 1;
+    }
+    return floatData;
+  }
+  function readLine(state) {
+    if (state.offset >= state.data.length) {
+      return null;
+    }
+    const lineStart = state.offset;
+    while (state.offset < state.data.length) {
+      const byte = state.data[state.offset++];
+      if (byte === 10) {
+        const line2 = decodeASCII(state.data.subarray(lineStart, state.offset - 1));
+        return line2.endsWith("\r") ? line2.slice(0, -1) : line2;
+      }
+    }
+    const line = decodeASCII(state.data.subarray(lineStart, state.offset));
+    return line.endsWith("\r") ? line.slice(0, -1) : line;
+  }
+  function decodeASCII(data) {
+    let line = "";
+    for (const byte of data) {
+      line += String.fromCharCode(byte);
+    }
+    return line;
+  }
+  function parseMetadataLine(metadata, line) {
+    if (line.startsWith("COLORCORR=")) {
+      const values = parseNumberList(line.slice("COLORCORR=".length), 3);
+      if (values) {
+        metadata.colorCorrection = values;
+      }
+      return;
+    }
+    if (line.startsWith("EXPOSURE=")) {
+      const value = parseNumber(line.slice("EXPOSURE=".length));
+      if (value !== null) {
+        metadata.exposure = value;
+      }
+      return;
+    }
+    if (line.startsWith("GAMMA=")) {
+      const value = parseNumber(line.slice("GAMMA=".length));
+      if (value !== null) {
+        metadata.gamma = value;
+      }
+      return;
+    }
+    if (line.startsWith("PIXASPECT=")) {
+      const value = parseNumber(line.slice("PIXASPECT=".length));
+      if (value !== null) {
+        metadata.pixelAspectRatio = value;
+      }
+      return;
+    }
+    if (line.startsWith("PRIMARIES=")) {
+      const values = parseNumberList(line.slice("PRIMARIES=".length), 8);
+      if (values) {
+        metadata.primaries = values;
       }
+      return;
+    }
+    if (line.startsWith("SOFTWARE=")) {
+      metadata.software = line.slice("SOFTWARE=".length).trim();
+      return;
+    }
+    if (line.startsWith("VIEW=")) {
+      metadata.view = line.slice("VIEW=".length).trim();
+    }
+  }
+  function parseNumber(text) {
+    const value = Number(text.trim());
+    return Number.isFinite(value) ? value : null;
+  }
+  function parseNumberList(text, count) {
+    const values = text.trim().split(/\s+/).map((value) => Number(value));
+    if (values.length !== count || values.some((value) => !Number.isFinite(value))) {
+      return null;
     }
+    return values;
+  }
+  function hasMetadata(metadata) {
+    return Object.keys(metadata).length > 0;
+  }
+
+  // src/radiance-hdr-loader.ts
+  var RadianceHDRLoader = {
+    dataType: null,
+    batchType: null,
+    name: "Radiance HDR",
+    id: "hdr",
+    module: "textures",
+    version: VERSION,
+    extensions: ["hdr"],
+    mimeTypes: ["image/vnd.radiance", "image/x-hdr", "application/octet-stream"],
+    binary: true,
+    tests: [isHDR],
+    options: {
+      hdr: {}
+    },
+    parseSync: parseHDR,
+    parse: async (arrayBuffer) => parseHDR(arrayBuffer)
   };
 
   // src/lib/parsers/parse-npy.ts
@@ -1573,121 +3009,15 @@ var __exports__ = (() => {
     parse: async (arrayBuffer, options) => parseNPY(arrayBuffer, options)
   };
 
-  // src/lib/parsers/crunch-module-loader.ts
-  var CRUNCH_EXTERNAL_LIBRARIES = {
-    /** Crunch decoder library. It is used as dynamically imported script */
-    DECODER: "crunch.js"
-  };
-
-  // src/lib/encoders/encode-texture.ts
-  async function encodeImageURLToCompressedTextureURL(inputUrl, outputUrl, options) {
-    const args = [
-      // Note: our actual executable is `npx`, so `texture-compressor` is an argument
-      "texture-compressor",
-      "--type",
-      "s3tc",
-      "--compression",
-      "DXT1",
-      "--quality",
-      "normal",
-      "--input",
-      inputUrl,
-      "--output",
-      outputUrl
-    ];
-    const childProcess = new import_child_process_proxy.default();
-    await childProcess.start({
-      command: "npx",
-      arguments: args,
-      spawn: options
-    });
-    return outputUrl;
-  }
-
-  // src/compressed-texture-writer.ts
-  var CompressedTextureWriter = {
-    name: "DDS Texture Container",
-    id: "dds",
-    module: "textures",
-    version: VERSION,
-    extensions: ["dds"],
-    mimeTypes: ["image/vnd-ms.dds", "image/x-dds", "application/octet-stream"],
-    options: {
-      texture: {
-        format: "auto",
-        compression: "auto",
-        quality: "auto",
-        mipmap: false,
-        flipY: false,
-        toolFlags: ""
-      }
-    },
-    encodeURLtoURL: encodeImageURLToCompressedTextureURL,
-    encode() {
-      throw new Error("Not implemented");
-    }
-  };
-
-  // src/lib/encoders/encode-ktx2-basis-texture.ts
-  async function encodeKTX2BasisTexture(image, options = {}) {
-    const {
-      useSRGB = false,
-      qualityLevel = 10,
-      encodeUASTC = false,
-      mipmaps = false
-    } = options?.["ktx2-basis-writer"] || {};
-    const { BasisEncoder } = await loadBasisEncoderModule(options);
-    const basisEncoder = new BasisEncoder();
-    try {
-      const basisFileData = new Uint8Array(image.width * image.height * 4);
-      basisEncoder.setCreateKTX2File(true);
-      basisEncoder.setKTX2UASTCSupercompression(true);
-      basisEncoder.setKTX2SRGBTransferFunc(true);
-      basisEncoder.setSliceSourceImage(0, image.data, image.width, image.height, false);
-      basisEncoder.setPerceptual(useSRGB);
-      basisEncoder.setMipSRGB(useSRGB);
-      basisEncoder.setQualityLevel(qualityLevel);
-      basisEncoder.setUASTC(encodeUASTC);
-      basisEncoder.setMipGen(mipmaps);
-      const numOutputBytes = basisEncoder.encode(basisFileData);
-      const actualKTX2FileData = basisFileData.subarray(0, numOutputBytes).buffer;
-      return actualKTX2FileData;
-    } catch (error) {
-      console.error("Basis Universal Supercompressed GPU Texture encoder Error: ", error);
-      throw error;
-    } finally {
-      basisEncoder.delete();
-    }
-  }
-
-  // src/ktx2-basis-writer.ts
-  var KTX2BasisWriter = {
-    name: "Basis Universal Supercompressed GPU Texture",
-    id: "ktx2-basis-writer",
-    module: "textures",
-    version: VERSION,
-    extensions: ["ktx2"],
-    mimeTypes: ["image/ktx2"],
-    options: {
-      ["ktx2-basis-writer"]: {
-        useSRGB: false,
-        qualityLevel: 10,
-        encodeUASTC: false,
-        mipmaps: false
-      }
-    },
-    encode: encodeKTX2BasisTexture
-  };
-
   // ../images/src/lib/utils/version.ts
-  var VERSION3 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+  var VERSION5 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
 
   // ../images/src/lib/category-api/image-type.ts
   var parseImageNode = globalThis.loaders?.parseImageNode;
   var IMAGE_SUPPORTED = typeof Image !== "undefined";
   var IMAGE_BITMAP_SUPPORTED = typeof ImageBitmap !== "undefined";
   var NODE_IMAGE_SUPPORTED = Boolean(parseImageNode);
-  var DATA_SUPPORTED = isBrowser ? true : NODE_IMAGE_SUPPORTED;
+  var DATA_SUPPORTED = isBrowser2 ? true : NODE_IMAGE_SUPPORTED;
   function isImageTypeSupported(type) {
     switch (type) {
       case "auto":
@@ -1716,6 +3046,9 @@ var __exports__ = (() => {
   }
 
   // ../images/src/lib/category-api/parsed-image-api.ts
+  function isImage(image) {
+    return Boolean(getImageTypeOrNull(image));
+  }
   function getImageType(image) {
     const format = getImageTypeOrNull(image);
     if (!format) {
@@ -1790,13 +3123,13 @@ var __exports__ = (() => {
   // ../images/src/lib/parsers/parse-to-image.ts
   async function parseToImage(arrayBuffer, options, url) {
     const blobOrDataUrl = getBlobOrSVGDataUrl(arrayBuffer, url);
-    const URL = self.URL || self.webkitURL;
-    const objectUrl = typeof blobOrDataUrl !== "string" && URL.createObjectURL(blobOrDataUrl);
+    const URL2 = self.URL || self.webkitURL;
+    const objectUrl = typeof blobOrDataUrl !== "string" && URL2.createObjectURL(blobOrDataUrl);
     try {
       return await loadToImage(objectUrl || blobOrDataUrl, options);
     } finally {
       if (objectUrl) {
-        URL.revokeObjectURL(objectUrl);
+        URL2.revokeObjectURL(objectUrl);
       }
     }
   }
@@ -1807,9 +3140,9 @@ var __exports__ = (() => {
       await image.decode();
       return image;
     }
-    return await new Promise((resolve, reject) => {
+    return await new Promise((resolve2, reject) => {
       try {
-        image.onload = () => resolve(image);
+        image.onload = () => resolve2(image);
         image.onerror = (error) => {
           const message = error instanceof Error ? error.message : "error";
           reject(new Error(message));
@@ -1821,7 +3154,6 @@ var __exports__ = (() => {
   }
 
   // ../images/src/lib/parsers/parse-to-image-bitmap.ts
-  var EMPTY_OBJECT = {};
   var imagebitmapOptionsSupported = true;
   async function parseToImageBitmap(arrayBuffer, options, url) {
     let blob;
@@ -1849,8 +3181,13 @@ var __exports__ = (() => {
     return await createImageBitmap(blob);
   }
   function isEmptyObject(object) {
-    for (const key in object || EMPTY_OBJECT) {
-      return false;
+    if (!object) {
+      return true;
+    }
+    for (const key in object) {
+      if (Object.prototype.hasOwnProperty.call(object, key)) {
+        return false;
+      }
     }
     return true;
   }
@@ -2014,7 +3351,7 @@ var __exports__ = (() => {
   async function parseToNodeImage(arrayBuffer, options) {
     const { mimeType } = getBinaryImageMetadata(arrayBuffer) || {};
     const parseImageNode2 = globalThis.loaders?.parseImageNode;
-    assert(parseImageNode2);
+    assert2(parseImageNode2);
     return await parseImageNode2(arrayBuffer, mimeType);
   }
 
@@ -2037,7 +3374,7 @@ var __exports__ = (() => {
         image = await parseToNodeImage(arrayBuffer, options);
         break;
       default:
-        assert(false);
+        assert2(false);
     }
     if (imageType === "data") {
       image = getImageData(image);
@@ -2081,7 +3418,7 @@ var __exports__ = (() => {
     id: "image",
     module: "images",
     name: "Images",
-    version: VERSION3,
+    version: VERSION5,
     mimeTypes: MIME_TYPES,
     extensions: EXTENSIONS,
     parse: parseImage,
@@ -2090,16 +3427,6 @@ var __exports__ = (() => {
     options: DEFAULT_IMAGE_LOADER_OPTIONS
   };
 
-  // src/lib/texture-api/generate-url.ts
-  function generateUrl(getUrl, options, urlOptions) {
-    let url = typeof getUrl === "function" ? getUrl({ ...options, ...urlOptions }) : getUrl;
-    const baseUrl = options.baseUrl;
-    if (baseUrl) {
-      url = baseUrl[baseUrl.length - 1] === "/" ? `${baseUrl}${url}` : `${baseUrl}/${url}`;
-    }
-    return resolvePath(url);
-  }
-
   // src/lib/texture-api/async-deep-map.ts
   var isObject = (value) => value && typeof value === "object";
   async function asyncDeepMap(tree, func, options = {}) {
@@ -2133,35 +3460,729 @@ var __exports__ = (() => {
     return await Promise.all(promises);
   }
 
-  // src/lib/texture-api/deep-load.ts
-  async function deepLoad(urlTree, load, options) {
-    return await asyncDeepMap(urlTree, (url) => shallowLoad(url, load, options));
-  }
-  async function shallowLoad(url, load, options) {
-    const response = await fetch(url, options.fetch);
-    const arrayBuffer = await response.arrayBuffer();
-    return await load(arrayBuffer, options);
-  }
-
-  // src/lib/texture-api/load-image.ts
-  async function loadImageTexture(getUrl, options = {}) {
-    const imageUrls = await getImageUrls(getUrl, options);
-    return await deepLoad(imageUrls, ImageLoader.parse, options);
-  }
-  async function getImageUrls(getUrl, options, urlOptions = {}) {
+  // src/lib/composite-image/image-texture-cube.ts
+  var GL_TEXTURE_CUBE_MAP_POSITIVE_X = 34069;
+  var GL_TEXTURE_CUBE_MAP_NEGATIVE_X = 34070;
+  var GL_TEXTURE_CUBE_MAP_POSITIVE_Y = 34071;
+  var GL_TEXTURE_CUBE_MAP_NEGATIVE_Y = 34072;
+  var GL_TEXTURE_CUBE_MAP_POSITIVE_Z = 34073;
+  var GL_TEXTURE_CUBE_MAP_NEGATIVE_Z = 34074;
+  var IMAGE_TEXTURE_CUBE_FACES = [
+    {
+      face: GL_TEXTURE_CUBE_MAP_POSITIVE_X,
+      name: "+X",
+      direction: "right",
+      axis: "x",
+      sign: "positive"
+    },
+    {
+      face: GL_TEXTURE_CUBE_MAP_NEGATIVE_X,
+      name: "-X",
+      direction: "left",
+      axis: "x",
+      sign: "negative"
+    },
+    { face: GL_TEXTURE_CUBE_MAP_POSITIVE_Y, name: "+Y", direction: "top", axis: "y", sign: "positive" },
+    {
+      face: GL_TEXTURE_CUBE_MAP_NEGATIVE_Y,
+      name: "-Y",
+      direction: "bottom",
+      axis: "y",
+      sign: "negative"
+    },
+    {
+      face: GL_TEXTURE_CUBE_MAP_POSITIVE_Z,
+      name: "+Z",
+      direction: "front",
+      axis: "z",
+      sign: "positive"
+    },
+    { face: GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, name: "-Z", direction: "back", axis: "z", sign: "negative" }
+  ];
+
+  // src/lib/composite-image/parse-composite-image.ts
+  async function parseCompositeImageManifest(text, expectedShape, options = {}, context) {
+    const manifest = parseCompositeImageManifestJSON(text);
+    if (manifest.shape !== expectedShape) {
+      throw new Error(`Expected ${expectedShape} manifest, got ${manifest.shape}`);
+    }
+    return await loadCompositeImageManifest(manifest, options, context);
+  }
+  function testCompositeImageManifestShape(text, shape) {
+    try {
+      return parseCompositeImageManifestJSON(text).shape === shape;
+    } catch {
+      return false;
+    }
+  }
+  async function loadCompositeImageManifest(manifest, options = {}, context) {
+    const normalizedOptions = normalizeCompositeImageManifestOptions(options);
+    const urlTree = await getCompositeImageUrlTree(manifest, normalizedOptions, context);
+    const imageData = await loadCompositeImageUrlTree(urlTree, normalizedOptions, context);
+    return convertCompositeImageToTexture(manifest.shape, imageData);
+  }
+  async function loadCompositeImageUrlTree(urlTree, options = {}, context) {
+    const normalizedOptions = normalizeCompositeImageOptions(options);
+    return await asyncDeepMap(
+      urlTree,
+      async (url) => await loadCompositeImageMember(url, normalizedOptions, context)
+    );
+  }
+  async function loadCompositeImageMember(url, options = {}, context) {
+    const resolvedUrl = resolveCompositeImageUrl(url, options, context);
+    const fetch2 = getCompositeImageFetch(options, context);
+    const response = await fetch2(resolvedUrl);
+    const subloaderOptions = getCompositeImageSubloaderOptions(options);
+    if (context) {
+      const childContext = getCompositeImageMemberContext(resolvedUrl, response, context);
+      return await parseFromContext(
+        response,
+        [ImageLoader],
+        subloaderOptions,
+        childContext
+      );
+    }
+    const arrayBuffer = await response.arrayBuffer();
+    return await ImageLoader.parse(arrayBuffer, subloaderOptions);
+  }
+  async function getCompositeImageUrlTree(manifest, options = {}, context) {
+    switch (manifest.shape) {
+      case "image-texture":
+        return await getImageTextureSource(manifest, options, context);
+      case "image-texture-array":
+        if (!Array.isArray(manifest.layers) || manifest.layers.length === 0) {
+          throw new Error("image-texture-array manifest must define one or more layers");
+        }
+        return await Promise.all(
+          manifest.layers.map(
+            async (layer, index) => await getNormalizedImageTextureSource(layer, options, context, { index })
+          )
+        );
+      case "image-texture-cube":
+        return await getImageTextureCubeUrls(manifest, options, context);
+      case "image-texture-cube-array":
+        if (!Array.isArray(manifest.layers) || manifest.layers.length === 0) {
+          throw new Error("image-texture-cube-array manifest must define one or more layers");
+        }
+        return await Promise.all(
+          manifest.layers.map(
+            async (layer, index) => await getImageTextureCubeUrls(layer, options, context, { index })
+          )
+        );
+      default:
+        throw new Error("Unsupported composite image manifest");
+    }
+  }
+  function normalizeCompositeImageOptions(options = {}) {
+    if (options.core?.baseUrl) {
+      return options;
+    }
+    const fallbackBaseUrl = options.baseUrl;
+    if (!fallbackBaseUrl) {
+      return options;
+    }
+    return {
+      ...options,
+      core: {
+        ...options.core,
+        baseUrl: fallbackBaseUrl
+      }
+    };
+  }
+  function resolveCompositeImageUrl(url, options = {}, context) {
+    const resolvedUrl = resolvePath(url);
+    if (isAbsoluteCompositeImageUrl(url)) {
+      return resolvedUrl;
+    }
+    const baseUrl = getCompositeImageBaseUrl(options, context);
+    if (!baseUrl) {
+      if (resolvedUrl !== url || url.startsWith("@")) {
+        return resolvedUrl;
+      }
+      throw new Error(`Unable to resolve relative image URL ${url} without a base URL`);
+    }
+    return resolvePath(joinCompositeImageUrl(baseUrl, url));
+  }
+  function parseCompositeImageManifestJSON(text) {
+    const manifest = JSON.parse(text);
+    if (!manifest?.shape) {
+      throw new Error("Composite image manifest must contain a shape field");
+    }
+    return manifest;
+  }
+  async function getImageTextureSource(manifest, options, context) {
+    if ((manifest.image || manifest.mipmaps) && manifest.template) {
+      throw new Error("image-texture manifest must define image, mipmaps, or template source");
+    }
+    if (manifest.image && manifest.mipmaps) {
+      throw new Error("image-texture manifest must define image, mipmaps, or template source");
+    }
+    if (manifest.image) {
+      return manifest.image;
+    }
+    if (manifest.mipmaps?.length) {
+      return manifest.mipmaps;
+    }
+    if (manifest.template) {
+      return await expandImageTextureSource(
+        { mipLevels: manifest.mipLevels ?? "auto", template: manifest.template },
+        options,
+        context,
+        {}
+      );
+    }
+    throw new Error("image-texture manifest must define image, mipmaps, or template source");
+  }
+  async function getImageTextureCubeUrls(manifest, options, context, templateOptions = {}) {
+    const urls = {};
+    for (const { face, name, direction, axis, sign } of IMAGE_TEXTURE_CUBE_FACES) {
+      const source = manifest.faces?.[name] || manifest.faces?.[direction];
+      if (!source) {
+        throw new Error(`image-texture-cube manifest is missing ${name} face`);
+      }
+      urls[face] = await getNormalizedImageTextureSource(source, options, context, {
+        ...templateOptions,
+        face: name,
+        direction,
+        axis,
+        sign
+      });
+    }
+    return urls;
+  }
+  async function getNormalizedImageTextureSource(source, options, context, templateOptions) {
+    if (typeof source === "string") {
+      return source;
+    }
+    if (Array.isArray(source) && source.length > 0) {
+      return source;
+    }
+    if (isImageTextureTemplateSource(source)) {
+      return await expandImageTextureSource(source, options, context, templateOptions);
+    }
+    throw new Error("Composite image source entries must be strings or non-empty mip arrays");
+  }
+  async function expandImageTextureSource(source, options, context, templateOptions) {
+    const mipLevels = source.mipLevels === "auto" ? await getAutoMipLevels(source.template, options, context, templateOptions) : source.mipLevels;
+    if (!Number.isFinite(mipLevels) || mipLevels <= 0) {
+      throw new Error(`Invalid mipLevels value ${source.mipLevels}`);
+    }
+    const urls = [];
+    for (let lod = 0; lod < mipLevels; lod++) {
+      urls.push(expandTemplate(source.template, { ...templateOptions, lod }));
+    }
+    return urls;
+  }
+  async function getAutoMipLevels(template, options, context, templateOptions) {
+    if (!template.includes("{lod}")) {
+      throw new Error("Template sources with mipLevels: auto must include a {lod} placeholder");
+    }
+    const level0Url = expandTemplate(template, { ...templateOptions, lod: 0 });
+    const image = await loadCompositeImageMember(
+      level0Url,
+      normalizeCompositeImageOptions(options),
+      context
+    );
+    const { width, height } = getImageSize(image);
+    return 1 + Math.floor(Math.log2(Math.max(width, height)));
+  }
+  function expandTemplate(template, templateOptions) {
+    let expanded = "";
+    for (let index = 0; index < template.length; index++) {
+      const character = template[index];
+      if (character === "\\") {
+        const nextCharacter = template[index + 1];
+        if (nextCharacter === "{" || nextCharacter === "}" || nextCharacter === "\\") {
+          expanded += nextCharacter;
+          index++;
+          continue;
+        }
+        throw new Error(`Invalid escape sequence \\${nextCharacter || ""} in template ${template}`);
+      }
+      if (character === "}") {
+        throw new Error(`Unexpected } in template ${template}`);
+      }
+      if (character !== "{") {
+        expanded += character;
+        continue;
+      }
+      const closingBraceIndex = findClosingBraceIndex(template, index + 1);
+      if (closingBraceIndex < 0) {
+        throw new Error(`Unterminated placeholder in template ${template}`);
+      }
+      const placeholder = template.slice(index + 1, closingBraceIndex);
+      if (!/^[a-z][a-zA-Z0-9]*$/.test(placeholder)) {
+        throw new Error(`Invalid placeholder {${placeholder}} in template ${template}`);
+      }
+      const value = getTemplateValue(placeholder, templateOptions);
+      if (value === void 0) {
+        throw new Error(
+          `Template ${template} uses unsupported placeholder {${placeholder}} for this source`
+        );
+      }
+      expanded += String(value);
+      index = closingBraceIndex;
+    }
+    return expanded;
+  }
+  function findClosingBraceIndex(template, startIndex) {
+    for (let index = startIndex; index < template.length; index++) {
+      const character = template[index];
+      if (character === "\\") {
+        index++;
+        continue;
+      }
+      if (character === "{") {
+        throw new Error(`Nested placeholders are not supported in template ${template}`);
+      }
+      if (character === "}") {
+        return index;
+      }
+    }
+    return -1;
+  }
+  function getTemplateValue(placeholder, templateOptions) {
+    switch (placeholder) {
+      case "lod":
+        return templateOptions.lod;
+      case "index":
+        return templateOptions.index;
+      case "face":
+        return templateOptions.face;
+      case "direction":
+        return templateOptions.direction;
+      case "axis":
+        return templateOptions.axis;
+      case "sign":
+        return templateOptions.sign;
+      default:
+        return void 0;
+    }
+  }
+  function isImageTextureTemplateSource(source) {
+    return typeof source === "object" && source !== null && !Array.isArray(source);
+  }
+  function getCompositeImageBaseUrl(options, context) {
+    if (context?.baseUrl) {
+      return context.baseUrl;
+    }
+    if (options.baseUrl) {
+      return stripTrailingSlash(options.baseUrl);
+    }
+    if (options.core?.baseUrl) {
+      return getSourceUrlDirectory(options.core.baseUrl);
+    }
+    return null;
+  }
+  function stripTrailingSlash(baseUrl) {
+    if (baseUrl.endsWith("/")) {
+      return baseUrl.slice(0, -1);
+    }
+    return baseUrl;
+  }
+  function getSourceUrlDirectory(baseUrl) {
+    return stripTrailingSlash(path_exports.dirname(baseUrl));
+  }
+  function joinCompositeImageUrl(baseUrl, url) {
+    if (isRequestLikeUrl(baseUrl)) {
+      return new URL(url, `${stripTrailingSlash(baseUrl)}/`).toString();
+    }
+    const normalizedBaseUrl = baseUrl.startsWith("/") ? baseUrl : `/${baseUrl}`;
+    const normalizedUrl = path_exports.resolve(normalizedBaseUrl, url);
+    return baseUrl.startsWith("/") ? normalizedUrl : normalizedUrl.slice(1);
+  }
+  function isRequestLikeUrl(url) {
+    return url.startsWith("http:") || url.startsWith("https:") || url.startsWith("file:") || url.startsWith("blob:");
+  }
+  function getCompositeImageFetch(options, context) {
+    const fetchOption = options.fetch ?? options.core?.fetch;
+    if (context?.fetch) {
+      return context.fetch;
+    }
+    if (typeof fetchOption === "function") {
+      return fetchOption;
+    }
+    if (fetchOption && typeof fetchOption === "object") {
+      return (url) => fetch(url, fetchOption);
+    }
+    return fetch;
+  }
+  function getCompositeImageSubloaderOptions(options) {
+    const core = options.core;
+    const rest = { ...options };
+    delete rest.baseUrl;
+    if (!core?.baseUrl) {
+      return rest;
+    }
+    const restCore = { ...core };
+    delete restCore.baseUrl;
+    return {
+      ...rest,
+      core: restCore
+    };
+  }
+  function normalizeCompositeImageManifestOptions(options) {
+    if (options.image?.type || typeof ImageBitmap === "undefined") {
+      return options;
+    }
+    return {
+      ...options,
+      image: {
+        ...options.image,
+        type: "imagebitmap"
+      }
+    };
+  }
+  function getCompositeImageMemberContext(resolvedUrl, response, context) {
+    const url = response.url || resolvedUrl;
+    const [urlWithoutQueryString, queryString = ""] = url.split("?");
+    return {
+      ...context,
+      url,
+      response,
+      filename: path_exports.filename(urlWithoutQueryString),
+      baseUrl: path_exports.dirname(urlWithoutQueryString),
+      queryString
+    };
+  }
+  function convertCompositeImageToTexture(shape, imageData) {
+    switch (shape) {
+      case "image-texture": {
+        const data = normalizeCompositeImageMember(imageData);
+        return {
+          shape: "texture",
+          type: "2d",
+          format: getCompositeTextureFormat(data),
+          data
+        };
+      }
+      case "image-texture-array": {
+        const data = imageData.map((layer) => normalizeCompositeImageMember(layer));
+        return {
+          shape: "texture",
+          type: "2d-array",
+          format: getCompositeTextureFormat(data[0]),
+          data
+        };
+      }
+      case "image-texture-cube": {
+        const data = IMAGE_TEXTURE_CUBE_FACES.map(
+          ({ face }) => normalizeCompositeImageMember(imageData[face])
+        );
+        return {
+          shape: "texture",
+          type: "cube",
+          format: getCompositeTextureFormat(data[0]),
+          data
+        };
+      }
+      case "image-texture-cube-array": {
+        const data = imageData.map(
+          (layer) => IMAGE_TEXTURE_CUBE_FACES.map(({ face }) => normalizeCompositeImageMember(layer[face]))
+        );
+        return {
+          shape: "texture",
+          type: "cube-array",
+          format: getCompositeTextureFormat(data[0][0]),
+          data
+        };
+      }
+      default:
+        throw new Error(`Unsupported composite image shape ${shape}`);
+    }
+  }
+  function normalizeCompositeImageMember(imageData) {
+    if (Array.isArray(imageData)) {
+      if (imageData.length === 0) {
+        throw new Error("Composite image members must not be empty");
+      }
+      if (imageData.every(isTextureLevel)) {
+        return imageData;
+      }
+      if (imageData.every(isImage)) {
+        return imageData.map((image) => getTextureLevelFromImage(image));
+      }
+      if (imageData.every((entry) => Array.isArray(entry) && entry.every(isTextureLevel))) {
+        if (imageData.length !== 1) {
+          throw new Error("Composite image members must resolve to a single image or mip chain");
+        }
+        return imageData[0];
+      }
+    }
+    if (isTexture(imageData)) {
+      if (imageData.type !== "2d") {
+        throw new Error(`Composite image members must resolve to 2d textures, got ${imageData.type}`);
+      }
+      return imageData.data;
+    }
+    if (isTextureLevel(imageData)) {
+      return [imageData];
+    }
+    if (isImage(imageData)) {
+      return [getTextureLevelFromImage(imageData)];
+    }
+    throw new Error("Composite image members must resolve to an image, mip chain, or texture");
+  }
+  function getTextureLevelFromImage(image) {
+    const { width, height } = getImageSize(image);
+    return {
+      shape: "texture-level",
+      compressed: false,
+      width,
+      height,
+      imageBitmap: typeof ImageBitmap !== "undefined" && image instanceof ImageBitmap ? image : void 0,
+      data: new Uint8Array(0),
+      textureFormat: "rgba8unorm"
+    };
+  }
+  function getCompositeTextureFormat(textureLevels) {
+    return textureLevels[0]?.textureFormat || "rgba8unorm";
+  }
+  function isTextureLevel(textureLevel) {
+    return Boolean(
+      textureLevel && typeof textureLevel === "object" && "shape" in textureLevel && textureLevel.shape === "texture-level"
+    );
+  }
+  function isTexture(texture) {
+    return Boolean(
+      texture && typeof texture === "object" && "shape" in texture && texture.shape === "texture"
+    );
+  }
+  function isAbsoluteCompositeImageUrl(url) {
+    return url.startsWith("data:") || url.startsWith("blob:") || url.startsWith("file:") || url.startsWith("http:") || url.startsWith("https:") || url.startsWith("/");
+  }
+
+  // src/texture-loader.ts
+  var TextureLoader = {
+    dataType: null,
+    batchType: null,
+    id: "texture",
+    name: "Texture",
+    module: "textures",
+    version: VERSION,
+    extensions: [],
+    mimeTypes: [],
+    text: true,
+    worker: false,
+    testText: (text) => testCompositeImageManifestShape(text, "image-texture"),
+    options: {
+      image: {}
+    },
+    parse: async (arrayBuffer, options, context) => await parseCompositeImageManifest(
+      new TextDecoder().decode(arrayBuffer),
+      "image-texture",
+      options,
+      context
+    ),
+    parseText: async (text, options, context) => await parseCompositeImageManifest(text, "image-texture", options, context)
+  };
+
+  // src/texture-array-loader.ts
+  var TextureArrayLoader = {
+    dataType: null,
+    batchType: null,
+    id: "texture-array",
+    name: "Texture Array",
+    module: "textures",
+    version: VERSION,
+    extensions: [],
+    mimeTypes: [],
+    text: true,
+    worker: false,
+    testText: (text) => testCompositeImageManifestShape(text, "image-texture-array"),
+    options: {
+      image: {}
+    },
+    parse: async (arrayBuffer, options, context) => await parseCompositeImageManifest(
+      new TextDecoder().decode(arrayBuffer),
+      "image-texture-array",
+      options,
+      context
+    ),
+    parseText: async (text, options, context) => await parseCompositeImageManifest(text, "image-texture-array", options, context)
+  };
+
+  // src/texture-cube-loader.ts
+  var TextureCubeLoader = {
+    dataType: null,
+    batchType: null,
+    id: "texture-cube",
+    name: "Texture Cube",
+    module: "textures",
+    version: VERSION,
+    extensions: [],
+    mimeTypes: [],
+    text: true,
+    worker: false,
+    testText: (text) => testCompositeImageManifestShape(text, "image-texture-cube"),
+    options: {
+      image: {}
+    },
+    parse: async (arrayBuffer, options, context) => await parseCompositeImageManifest(
+      new TextDecoder().decode(arrayBuffer),
+      "image-texture-cube",
+      options,
+      context
+    ),
+    parseText: async (text, options, context) => await parseCompositeImageManifest(text, "image-texture-cube", options, context)
+  };
+
+  // src/texture-cube-array-loader.ts
+  var TextureCubeArrayLoader = {
+    dataType: null,
+    batchType: null,
+    id: "texture-cube-array",
+    name: "Texture Cube Array",
+    module: "textures",
+    version: VERSION,
+    extensions: [],
+    mimeTypes: [],
+    text: true,
+    worker: false,
+    testText: (text) => testCompositeImageManifestShape(text, "image-texture-cube-array"),
+    options: {
+      image: {}
+    },
+    parse: async (arrayBuffer, options, context) => await parseCompositeImageManifest(
+      new TextDecoder().decode(arrayBuffer),
+      "image-texture-cube-array",
+      options,
+      context
+    ),
+    parseText: async (text, options, context) => await parseCompositeImageManifest(text, "image-texture-cube-array", options, context)
+  };
+
+  // src/lib/parsers/crunch-module-loader.ts
+  var CRUNCH_EXTERNAL_LIBRARIES = {
+    /** Crunch decoder library. It is used as dynamically imported script */
+    DECODER: "crunch.js"
+  };
+
+  // src/lib/encoders/encode-texture.ts
+  async function encodeImageURLToCompressedTextureURL(inputUrl, outputUrl, options) {
+    const args = [
+      // Note: our actual executable is `npx`, so `texture-compressor` is an argument
+      "texture-compressor",
+      "--type",
+      "s3tc",
+      "--compression",
+      "DXT1",
+      "--quality",
+      "normal",
+      "--input",
+      inputUrl,
+      "--output",
+      outputUrl
+    ];
+    const childProcess = new ChildProcessProxy();
+    await childProcess.start({
+      command: "npx",
+      arguments: args,
+      spawn: options
+    });
+    return outputUrl;
+  }
+
+  // src/compressed-texture-writer.ts
+  var CompressedTextureWriter = {
+    name: "DDS Texture Container",
+    id: "dds",
+    module: "textures",
+    version: VERSION,
+    extensions: ["dds"],
+    mimeTypes: ["image/vnd-ms.dds", "image/x-dds", "application/octet-stream"],
+    options: {
+      texture: {
+        format: "auto",
+        compression: "auto",
+        quality: "auto",
+        mipmap: false,
+        flipY: false,
+        toolFlags: ""
+      }
+    },
+    encodeURLtoURL: encodeImageURLToCompressedTextureURL,
+    encode() {
+      throw new Error("Not implemented");
+    }
+  };
+
+  // src/lib/encoders/encode-ktx2-basis-texture.ts
+  async function encodeKTX2BasisTexture(image, options = {}) {
+    const {
+      useSRGB = false,
+      qualityLevel = 10,
+      encodeUASTC = false,
+      mipmaps = false
+    } = options?.["ktx2-basis-writer"] || {};
+    const { BasisEncoder } = await loadBasisEncoderModule(extractLoadLibraryOptions(options));
+    const basisEncoder = new BasisEncoder();
+    try {
+      const basisFileData = new Uint8Array(image.width * image.height * 4);
+      basisEncoder.setCreateKTX2File(true);
+      basisEncoder.setKTX2UASTCSupercompression(true);
+      basisEncoder.setKTX2SRGBTransferFunc(true);
+      basisEncoder.setSliceSourceImage(0, image.data, image.width, image.height, false);
+      basisEncoder.setPerceptual(useSRGB);
+      basisEncoder.setMipSRGB(useSRGB);
+      basisEncoder.setQualityLevel(qualityLevel);
+      basisEncoder.setUASTC(encodeUASTC);
+      basisEncoder.setMipGen(mipmaps);
+      const numOutputBytes = basisEncoder.encode(basisFileData);
+      const actualKTX2FileData = basisFileData.subarray(0, numOutputBytes).buffer;
+      return actualKTX2FileData;
+    } catch (error) {
+      console.error("Basis Universal Supercompressed GPU Texture encoder Error: ", error);
+      throw error;
+    } finally {
+      basisEncoder.delete();
+    }
+  }
+
+  // src/ktx2-basis-writer.ts
+  var KTX2BasisWriter = {
+    name: "Basis Universal Supercompressed GPU Texture",
+    id: "ktx2-basis-writer",
+    module: "textures",
+    version: VERSION,
+    extensions: ["ktx2"],
+    mimeTypes: ["image/ktx2"],
+    options: {
+      ["ktx2-basis-writer"]: {
+        useSRGB: false,
+        qualityLevel: 10,
+        encodeUASTC: false,
+        mipmaps: false
+      }
+    },
+    encode: encodeKTX2BasisTexture
+  };
+
+  // src/lib/texture-api/generate-url.ts
+  function generateUrl(getUrl, options, urlOptions) {
+    return typeof getUrl === "function" ? getUrl({ ...options, ...urlOptions }) : getUrl;
+  }
+
+  // src/lib/texture-api/load-image.ts
+  async function loadImageTexture(getUrl, options = {}) {
+    const imageUrls = await getImageUrls(getUrl, options);
+    return await loadCompositeImageUrlTree(imageUrls, normalizeCompositeImageOptions(options));
+  }
+  async function getImageUrls(getUrl, options, urlOptions = {}) {
     const mipLevels = options && options.image && options.image.mipLevels || 0;
     return mipLevels !== 0 ? await getMipmappedImageUrls(getUrl, mipLevels, options, urlOptions) : generateUrl(getUrl, options, urlOptions);
   }
   async function getMipmappedImageUrls(getUrl, mipLevels, options, urlOptions) {
     const urls = [];
+    const normalizedOptions = normalizeCompositeImageOptions(options);
     if (mipLevels === "auto") {
       const url = generateUrl(getUrl, options, { ...urlOptions, lod: 0 });
-      const image = await shallowLoad(url, ImageLoader.parse, options);
+      const image = await loadCompositeImageMember(url, normalizedOptions);
       const { width, height } = getImageSize(image);
       mipLevels = getMipLevels({ width, height });
       urls.push(url);
     }
-    assert(mipLevels > 0);
+    assert2(mipLevels > 0);
     for (let mipLevel = urls.length; mipLevel < mipLevels; ++mipLevel) {
       const url = generateUrl(getUrl, options, { ...urlOptions, lod: mipLevel });
       urls.push(url);
@@ -2175,7 +4196,7 @@ var __exports__ = (() => {
   // src/lib/texture-api/load-image-array.ts
   async function loadImageTextureArray(count, getUrl, options = {}) {
     const imageUrls = await getImageArrayUrls(count, getUrl, options);
-    return await deepLoad(imageUrls, ImageLoader.parse, options);
+    return await loadCompositeImageUrlTree(imageUrls, normalizeCompositeImageOptions(options));
   }
   async function getImageArrayUrls(count, getUrl, options = {}) {
     const promises = [];
@@ -2187,26 +4208,12 @@ var __exports__ = (() => {
   }
 
   // src/lib/texture-api/load-image-cube.ts
-  var GL_TEXTURE_CUBE_MAP_POSITIVE_X = 34069;
-  var GL_TEXTURE_CUBE_MAP_NEGATIVE_X = 34070;
-  var GL_TEXTURE_CUBE_MAP_POSITIVE_Y = 34071;
-  var GL_TEXTURE_CUBE_MAP_NEGATIVE_Y = 34072;
-  var GL_TEXTURE_CUBE_MAP_POSITIVE_Z = 34073;
-  var GL_TEXTURE_CUBE_MAP_NEGATIVE_Z = 34074;
-  var CUBE_FACES = [
-    { face: GL_TEXTURE_CUBE_MAP_POSITIVE_X, direction: "right", axis: "x", sign: "positive" },
-    { face: GL_TEXTURE_CUBE_MAP_NEGATIVE_X, direction: "left", axis: "x", sign: "negative" },
-    { face: GL_TEXTURE_CUBE_MAP_POSITIVE_Y, direction: "top", axis: "y", sign: "positive" },
-    { face: GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, direction: "bottom", axis: "y", sign: "negative" },
-    { face: GL_TEXTURE_CUBE_MAP_POSITIVE_Z, direction: "front", axis: "z", sign: "positive" },
-    { face: GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, direction: "back", axis: "z", sign: "negative" }
-  ];
   async function getImageCubeUrls(getUrl, options) {
     const urls = {};
     const promises = [];
     let index = 0;
-    for (let i = 0; i < CUBE_FACES.length; ++i) {
-      const face = CUBE_FACES[index];
+    for (let i = 0; i < IMAGE_TEXTURE_CUBE_FACES.length; ++i) {
+      const face = IMAGE_TEXTURE_CUBE_FACES[index];
       const promise = getImageUrls(getUrl, options, { ...face, index: index++ }).then((url) => {
         urls[face.face] = url;
       });
@@ -2217,7 +4224,10 @@ var __exports__ = (() => {
   }
   async function loadImageTextureCube(getUrl, options = {}) {
     const urls = await getImageCubeUrls(getUrl, options);
-    return await deepLoad(urls, ImageLoader.parse, options);
+    return await loadCompositeImageUrlTree(
+      urls,
+      normalizeCompositeImageOptions(options)
+    );
   }
 
   // src/index.ts