@loaders.gl/i3s 4.0.0-alpha.9 → 4.0.0-beta.1

package/dist/i3s-content-worker.js

@@ -32,6 +32,17 @@
     }
   });
 
+  // (disabled):../core/src/lib/fetch/fetch-file.node
+  var require_fetch_file = __commonJS({
+    "(disabled):../core/src/lib/fetch/fetch-file.node"() {
+    }
+  });
+
+  // ../loader-utils/src/loader-types.ts
+  async function parseFromContext(data, loaders, options, context) {
+    return context._parse(data, loaders, options, context);
+  }
+
   // ../loader-utils/src/lib/env-utils/assert.ts
   function assert(condition, message) {
     if (!condition) {
@@ -54,11 +65,37 @@
   var matches = typeof process !== "undefined" && process.version && /v([0-9]*)/.exec(process.version);
   var nodeVersion = matches && parseFloat(matches[1]) || 0;
 
+  // ../loader-utils/src/lib/option-utils/merge-loader-options.ts
+  function mergeLoaderOptions(baseOptions, newOptions) {
+    return mergeOptionsRecursively(baseOptions || {}, newOptions);
+  }
+  function mergeOptionsRecursively(baseOptions, newOptions) {
+    const options = { ...baseOptions };
+    for (const [key, newValue] of Object.entries(newOptions)) {
+      if (newValue && typeof newValue === "object" && !Array.isArray(newValue)) {
+        options[key] = mergeOptionsRecursively(options[key] || {}, newOptions[key]);
+      } else {
+        options[key] = newOptions[key];
+      }
+    }
+    return options;
+  }
+
   // ../worker-utils/src/lib/env-utils/version.ts
-  var VERSION = true ? "4.0.0-alpha.9" : DEFAULT_VERSION;
-  if (false) {
-    console.error("loaders.gl: The __VERSION__ variable is not injected using babel plugin. Latest unstable workers would be fetched from the CDN.");
+  var NPM_TAG = "beta";
+  function getVersion() {
+    if (!globalThis._loadersgl_?.version) {
+      globalThis._loadersgl_ = globalThis._loadersgl_ || {};
+      if (false) {
+        console.error("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;
+      } else {
+        globalThis._loadersgl_.version = "4.0.0-beta.1";
+      }
+    }
+    return globalThis._loadersgl_.version;
   }
+  var VERSION = getVersion();
 
   // ../worker-utils/src/lib/env-utils/assert.ts
   function assert2(condition, message) {
@@ -520,7 +557,6 @@
   }
 
   // ../worker-utils/src/lib/worker-api/get-worker-url.ts
-  var NPM_TAG = "beta";
   function getWorkerURL(worker, options = {}) {
     const workerOptions = options[worker.id] || {};
     const workerFile = isBrowser2 ? `${worker.id}-worker.js` : `${worker.id}-worker-node.js`;
@@ -555,40 +591,38 @@
 
   // ../worker-utils/src/lib/library-utils/library-utils.ts
   var node = __toModule(require_require_utils());
-  var LATEST = "beta";
-  var VERSION2 = typeof VERSION !== "undefined" ? VERSION : LATEST;
   var loadLibraryPromises = {};
-  async function loadLibrary(libraryUrl, moduleName = null, options = {}) {
+  async function loadLibrary(libraryUrl, moduleName = null, options = {}, libraryName = null) {
     if (moduleName) {
-      libraryUrl = getLibraryUrl(libraryUrl, moduleName, options);
+      libraryUrl = getLibraryUrl(libraryUrl, moduleName, options, libraryName);
     }
     loadLibraryPromises[libraryUrl] = loadLibraryPromises[libraryUrl] || loadLibraryFromFile(libraryUrl);
     return await loadLibraryPromises[libraryUrl];
   }
-  function getLibraryUrl(library, moduleName, options) {
-    if (library.startsWith("http")) {
+  function getLibraryUrl(library, moduleName, options = {}, libraryName = null) {
+    if (!options.useLocalLibraries && library.startsWith("http")) {
       return library;
     }
+    libraryName = libraryName || library;
     const modules = options.modules || {};
-    if (modules[library]) {
-      return modules[library];
+    if (modules[libraryName]) {
+      return modules[libraryName];
     }
     if (!isBrowser2) {
-      return `modules/${moduleName}/dist/libs/${library}`;
+      return `modules/${moduleName}/dist/libs/${libraryName}`;
     }
     if (options.CDN) {
       assert2(options.CDN.startsWith("http"));
-      return `${options.CDN}/${moduleName}@${VERSION2}/dist/libs/${library}`;
+      return `${options.CDN}/${moduleName}@${VERSION}/dist/libs/${libraryName}`;
     }
     if (isWorker) {
-      return `../src/libs/${library}`;
+      return `../src/libs/${libraryName}`;
     }
-    return `modules/${moduleName}/src/libs/${library}`;
+    return `modules/${moduleName}/src/libs/${libraryName}`;
   }
   async function loadLibraryFromFile(libraryUrl) {
     if (libraryUrl.endsWith("wasm")) {
-      const response2 = await fetch(libraryUrl);
-      return await response2.arrayBuffer();
+      return await loadAsArrayBuffer(libraryUrl);
     }
     if (!isBrowser2) {
       try {
@@ -600,8 +634,7 @@
     if (isWorker) {
       return importScripts(libraryUrl);
     }
-    const response = await fetch(libraryUrl);
-    const scriptSource = await response.text();
+    const scriptSource = await loadAsText(libraryUrl);
     return loadLibraryFromString(scriptSource, libraryUrl);
   }
   function loadLibraryFromString(scriptSource, id) {
@@ -622,6 +655,20 @@
     document.body.appendChild(script);
     return null;
   }
+  async function loadAsArrayBuffer(url) {
+    if (!node.readFileAsArrayBuffer || url.startsWith("http")) {
+      const response = await fetch(url);
+      return await response.arrayBuffer();
+    }
+    return await node.readFileAsArrayBuffer(url);
+  }
+  async function loadAsText(url) {
+    if (!node.readFileAsText || url.startsWith("http")) {
+      const response = await fetch(url);
+      return await response.text();
+    }
+    return await node.readFileAsText(url);
+  }
 
   // ../loader-utils/src/lib/worker-loader-utils/create-loader-worker.ts
   var requestId = 0;
@@ -640,7 +687,7 @@
               options,
               context: {
                 ...context,
-                parse: parseOnMainThread
+                _parse: parseOnMainThread
               }
             });
             WorkerBody.postMessage("done", { result });
@@ -653,7 +700,7 @@
       }
     };
   }
-  function parseOnMainThread(arrayBuffer, options) {
+  function parseOnMainThread(arrayBuffer, loader, options, context) {
     return new Promise((resolve2, reject) => {
       const id = requestId++;
       const onMessage2 = (type, payload2) => {
@@ -677,7 +724,12 @@
       WorkerBody.postMessage("process", payload);
     });
   }
-  async function parseData({ loader, arrayBuffer, options, context }) {
+  async function parseData({
+    loader,
+    arrayBuffer,
+    options,
+    context
+  }) {
     let data;
     let parser;
     if (loader.parseSync || loader.parse) {
@@ -1026,7 +1078,7 @@
   var isFunction = (x) => typeof x === "function";
   var isObject = (x) => x !== null && typeof x === "object";
   var isPureObject = (x) => isObject(x) && x.constructor === {}.constructor;
-  var isIterable = (x) => x && typeof x[Symbol.iterator] === "function";
+  var isIterable = (x) => Boolean(x) && typeof x[Symbol.iterator] === "function";
   var isAsyncIterable = (x) => x && typeof x[Symbol.asyncIterator] === "function";
   var isResponse = (x) => typeof Response !== "undefined" && x instanceof Response || x && x.arrayBuffer && x.text && x.json;
   var isBlob = (x) => typeof Blob !== "undefined" && x instanceof Blob;
@@ -1191,16 +1243,25 @@
   }
 
   // ../core/src/lib/fetch/fetch-file.ts
-  async function fetchFile(url, options) {
-    if (typeof url === "string") {
-      url = resolvePath(url);
-      let fetchOptions = options;
-      if (options?.fetch && typeof options?.fetch !== "function") {
-        fetchOptions = options.fetch;
+  var node3 = __toModule(require_fetch_file());
+  function isNodePath(url) {
+    return !isRequestURL(url) && !isDataURL(url);
+  }
+  function isRequestURL(url) {
+    return url.startsWith("http:") || url.startsWith("https:");
+  }
+  function isDataURL(url) {
+    return url.startsWith("data:");
+  }
+  async function fetchFile(urlOrData, fetchOptions) {
+    if (typeof urlOrData === "string") {
+      const url = resolvePath(urlOrData);
+      if (isNodePath(url) && node3?.fetchFileNode) {
+        return node3.fetchFileNode(url, fetchOptions);
       }
       return await fetch(url, fetchOptions);
     }
-    return await makeResponse(url);
+    return await makeResponse(urlOrData);
   }
 
   // ../../node_modules/@probe.gl/log/node_modules/@probe.gl/env/dist/lib/is-electron.js
@@ -1234,7 +1295,7 @@
   var navigator_ = globalThis.navigator || {};
 
   // ../../node_modules/@probe.gl/log/node_modules/@probe.gl/env/dist/utils/globals.js
-  var VERSION3 = true ? "4.0.0-alpha.9" : "untranspiled source";
+  var VERSION2 = true ? "4.0.0-beta.1" : "untranspiled source";
   var isBrowser4 = isBrowser3();
 
   // ../../node_modules/@probe.gl/log/dist/utils/local-storage.js
@@ -1419,7 +1480,7 @@
         id: ""
       };
       _defineProperty(this, "id", void 0);
-      _defineProperty(this, "VERSION", VERSION3);
+      _defineProperty(this, "VERSION", VERSION2);
       _defineProperty(this, "_startTs", getHiResTimestamp());
       _defineProperty(this, "_deltaTs", getHiResTimestamp());
       _defineProperty(this, "_storage", void 0);
@@ -1622,7 +1683,7 @@
       return noop;
     }
   };
-  _defineProperty(Log, "VERSION", VERSION3);
+  _defineProperty(Log, "VERSION", VERSION2);
   function normalizeLogLevel(logLevel) {
     if (!logLevel) {
       return 0;
@@ -1775,6 +1836,7 @@
     mimeType: void 0,
     nothrow: false,
     log: new ConsoleLog(),
+    useLocalLibraries: false,
     CDN: "https://unpkg.com/@loaders.gl",
     worker: true,
     maxConcurrency: 3,
@@ -1814,11 +1876,11 @@
     loaders._state = loaders._state || {};
     return loaders._state;
   }
-  var getGlobalLoaderOptions = () => {
+  function getGlobalLoaderOptions() {
     const state = getGlobalLoaderState();
     state.globalOptions = state.globalOptions || { ...DEFAULT_LOADER_OPTIONS };
     return state.globalOptions;
-  };
+  }
   function normalizeOptions(options, loader, loaders, url) {
     loaders = loaders || [];
     loaders = Array.isArray(loaders) ? loaders : [loaders];
@@ -2001,8 +2063,10 @@
     reason = reason || (loader ? `matched MIME type ${type}` : "");
     loader = loader || findLoaderByInitialBytes(loaders, data);
     reason = reason || (loader ? `matched initial data ${getFirstCharacters(data)}` : "");
-    loader = loader || findLoaderByMIMEType(loaders, options?.fallbackMimeType);
-    reason = reason || (loader ? `matched fallback MIME type ${type}` : "");
+    if (options?.fallbackMimeType) {
+      loader = loader || findLoaderByMIMEType(loaders, options?.fallbackMimeType);
+      reason = reason || (loader ? `matched fallback MIME type ${type}` : "");
+    }
     if (reason) {
       log.log(1, `selectLoader selected ${loader?.name}: ${reason}.`);
     }
@@ -2098,7 +2162,7 @@
     }
     switch (typeof test) {
       case "function":
-        return test(data, loader);
+        return test(data);
       case "string":
         const magic = getMagicString(data, byteOffset, test.length);
         return test === magic;
@@ -2278,12 +2342,12 @@
   // ../core/src/lib/loader-utils/get-fetch-function.ts
   function getFetchFunction(options, context) {
     const globalOptions = getGlobalLoaderOptions();
-    const fetchOptions = options || globalOptions;
-    if (typeof fetchOptions.fetch === "function") {
-      return fetchOptions.fetch;
+    const loaderOptions = options || globalOptions;
+    if (typeof loaderOptions.fetch === "function") {
+      return loaderOptions.fetch;
     }
-    if (isObject(fetchOptions.fetch)) {
-      return (url) => fetchFile(url, fetchOptions);
+    if (isObject(loaderOptions.fetch)) {
+      return (url) => fetchFile(url, loaderOptions.fetch);
     }
     if (context?.fetch) {
       return context?.fetch;
@@ -2313,7 +2377,7 @@
     return newContext;
   }
   function getLoadersFromContext(loaders, context) {
-    if (!context && loaders && !Array.isArray(loaders)) {
+    if (loaders && !Array.isArray(loaders)) {
       return loaders;
     }
     let candidateLoaders;
@@ -2324,12 +2388,11 @@
       const contextLoaders = Array.isArray(context.loaders) ? context.loaders : [context.loaders];
       candidateLoaders = candidateLoaders ? [...candidateLoaders, ...contextLoaders] : contextLoaders;
     }
-    return candidateLoaders && candidateLoaders.length ? candidateLoaders : null;
+    return candidateLoaders && candidateLoaders.length ? candidateLoaders : void 0;
   }
 
   // ../core/src/lib/api/parse.ts
   async function parse(data, loaders, options, context) {
-    assert2(!context || typeof context === "object");
     if (loaders && !Array.isArray(loaders) && !isLoaderObject(loaders)) {
       context = void 0;
       options = loaders;
@@ -2345,11 +2408,12 @@
       return null;
     }
     options = normalizeOptions(options, loader, candidateLoaders, url);
-    context = getLoaderContext({ url, parse, loaders: candidateLoaders }, options, context || null);
+    context = getLoaderContext({ url, _parse: parse, loaders: candidateLoaders }, options, context || null);
     return await parseWithLoader(loader, data, options, context);
   }
   async function parseWithLoader(loader, data, options, context) {
     validateWorkerVersion(loader);
+    options = mergeLoaderOptions(loader.options, options);
     if (isResponse(data)) {
       const response = data;
       const { ok, redirected, status, statusText, type, url } = response;
@@ -2357,20 +2421,20 @@
       context.response = { headers, ok, redirected, status, statusText, type, url };
     }
     data = await getArrayBufferOrStringFromData(data, loader, options);
-    if (loader.parseTextSync && typeof data === "string") {
-      options.dataType = "text";
-      return loader.parseTextSync(data, options, context, loader);
+    const loaderWithParser = loader;
+    if (loaderWithParser.parseTextSync && typeof data === "string") {
+      return loaderWithParser.parseTextSync(data, options, context);
     }
     if (canParseWithWorker(loader, options)) {
       return await parseWithWorker(loader, data, options, context, parse);
     }
-    if (loader.parseText && typeof data === "string") {
-      return await loader.parseText(data, options, context, loader);
+    if (loaderWithParser.parseText && typeof data === "string") {
+      return await loaderWithParser.parseText(data, options, context);
     }
-    if (loader.parse) {
-      return await loader.parse(data, options, context, loader);
+    if (loaderWithParser.parse) {
+      return await loaderWithParser.parse(data, options, context);
     }
-    assert2(!loader.parseSync);
+    assert2(!loaderWithParser.parseSync);
     throw new Error(`${loader.id} loader - no parser found and worker is disabled`);
   }
 
@@ -4582,7 +4646,7 @@
   _defineProperty(Ellipsoid, "WGS84", new Ellipsoid(WGS84_RADIUS_X, WGS84_RADIUS_Y, WGS84_RADIUS_Z));
 
   // ../images/src/lib/utils/version.ts
-  var VERSION4 = true ? "4.0.0-alpha.9" : "latest";
+  var VERSION3 = true ? "4.0.0-beta.1" : "latest";
 
   // ../images/src/lib/category-api/image-type.ts
   var { _parseImageNode } = globalThis;
@@ -4970,7 +5034,7 @@
     id: "image",
     module: "images",
     name: "Images",
-    version: VERSION4,
+    version: VERSION3,
     mimeTypes: MIME_TYPES,
     extensions: EXTENSIONS,
     parse: parseImage,
@@ -4979,7 +5043,7 @@
   };
 
   // ../draco/src/lib/utils/version.ts
-  var VERSION5 = true ? "4.0.0-alpha.9" : "latest";
+  var VERSION4 = true ? "4.0.0-beta.1" : "latest";
 
   // ../draco/src/draco-loader.ts
   var DEFAULT_DRACO_OPTIONS = {
@@ -4994,7 +5058,7 @@
     name: "Draco",
     id: "draco",
     module: "draco",
-    version: VERSION5,
+    version: VERSION4,
     worker: true,
     extensions: ["drc"],
     mimeTypes: ["application/octet-stream"],
@@ -5459,13 +5523,21 @@
   }
 
   // ../draco/src/lib/draco-module-loader.ts
-  var DRACO_DECODER_VERSION = "1.5.5";
+  var DRACO_DECODER_VERSION = "1.5.6";
   var DRACO_ENCODER_VERSION = "1.4.1";
   var STATIC_DECODER_URL = `https://www.gstatic.com/draco/versioned/decoders/${DRACO_DECODER_VERSION}`;
-  var DRACO_JS_DECODER_URL = `${STATIC_DECODER_URL}/draco_decoder.js`;
-  var DRACO_WASM_WRAPPER_URL = `${STATIC_DECODER_URL}/draco_wasm_wrapper.js`;
-  var DRACO_WASM_DECODER_URL = `${STATIC_DECODER_URL}/draco_decoder.wasm`;
-  var DRACO_ENCODER_URL = `https://raw.githubusercontent.com/google/draco/${DRACO_ENCODER_VERSION}/javascript/draco_encoder.js`;
+  var DRACO_EXTERNAL_LIBRARIES = {
+    DECODER: "draco_wasm_wrapper.js",
+    DECODER_WASM: "draco_decoder.wasm",
+    FALLBACK_DECODER: "draco_decoder.js",
+    ENCODER: "draco_encoder.js"
+  };
+  var DRACO_EXTERNAL_LIBRARY_URLS = {
+    [DRACO_EXTERNAL_LIBRARIES.DECODER]: `${STATIC_DECODER_URL}/${DRACO_EXTERNAL_LIBRARIES.DECODER}`,
+    [DRACO_EXTERNAL_LIBRARIES.DECODER_WASM]: `${STATIC_DECODER_URL}/${DRACO_EXTERNAL_LIBRARIES.DECODER_WASM}`,
+    [DRACO_EXTERNAL_LIBRARIES.FALLBACK_DECODER]: `${STATIC_DECODER_URL}/${DRACO_EXTERNAL_LIBRARIES.FALLBACK_DECODER}`,
+    [DRACO_EXTERNAL_LIBRARIES.ENCODER]: `https://raw.githubusercontent.com/google/draco/${DRACO_ENCODER_VERSION}/javascript/${DRACO_EXTERNAL_LIBRARIES.ENCODER}`
+  };
   var loadDecoderPromise;
   async function loadDracoDecoderModule(options) {
     const modules = options.modules || {};
@@ -5483,13 +5555,13 @@
     let wasmBinary;
     switch (options.draco && options.draco.decoderType) {
       case "js":
-        DracoDecoderModule = await loadLibrary(DRACO_JS_DECODER_URL, "draco", options);
+        DracoDecoderModule = await loadLibrary(DRACO_EXTERNAL_LIBRARY_URLS[DRACO_EXTERNAL_LIBRARIES.FALLBACK_DECODER], "draco", options, DRACO_EXTERNAL_LIBRARIES.FALLBACK_DECODER);
         break;
       case "wasm":
       default:
         [DracoDecoderModule, wasmBinary] = await Promise.all([
-          await loadLibrary(DRACO_WASM_WRAPPER_URL, "draco", options),
-          await loadLibrary(DRACO_WASM_DECODER_URL, "draco", options)
+          await loadLibrary(DRACO_EXTERNAL_LIBRARY_URLS[DRACO_EXTERNAL_LIBRARIES.DECODER], "draco", options, DRACO_EXTERNAL_LIBRARIES.DECODER),
+          await loadLibrary(DRACO_EXTERNAL_LIBRARY_URLS[DRACO_EXTERNAL_LIBRARIES.DECODER_WASM], "draco", options, DRACO_EXTERNAL_LIBRARIES.DECODER_WASM)
         ]);
     }
     DracoDecoderModule = DracoDecoderModule || globalThis.DracoDecoderModule;
@@ -5524,32 +5596,35 @@
   }
 
   // ../textures/src/lib/utils/version.ts
-  var VERSION6 = true ? "4.0.0-alpha.9" : "beta";
+  var VERSION5 = true ? "4.0.0-beta.1" : "beta";
 
   // ../textures/src/lib/parsers/basis-module-loader.ts
-  var VERSION7 = true ? "4.0.0-alpha.9" : "beta";
-  var BASIS_CDN_ENCODER_WASM = `https://unpkg.com/@loaders.gl/textures@${VERSION7}/dist/libs/basis_encoder.wasm`;
-  var BASIS_CDN_ENCODER_JS = `https://unpkg.com/@loaders.gl/textures@${VERSION7}/dist/libs/basis_encoder.js`;
+  var BASIS_EXTERNAL_LIBRARIES = {
+    TRANSCODER: "basis_transcoder.js",
+    TRANSCODER_WASM: "basis_transcoder.wasm",
+    ENCODER: "basis_encoder.js",
+    ENCODER_WASM: "basis_encoder.wasm"
+  };
   var loadBasisTranscoderPromise;
-  async function loadBasisTrascoderModule(options) {
+  async function loadBasisTranscoderModule(options) {
     const modules = options.modules || {};
     if (modules.basis) {
       return modules.basis;
     }
-    loadBasisTranscoderPromise = loadBasisTranscoderPromise || loadBasisTrascoder(options);
+    loadBasisTranscoderPromise = loadBasisTranscoderPromise || loadBasisTranscoder(options);
     return await loadBasisTranscoderPromise;
   }
-  async function loadBasisTrascoder(options) {
+  async function loadBasisTranscoder(options) {
     let BASIS = null;
     let wasmBinary = null;
     [BASIS, wasmBinary] = await Promise.all([
-      await loadLibrary("basis_transcoder.js", "textures", options),
-      await loadLibrary("basis_transcoder.wasm", "textures", options)
+      await loadLibrary(BASIS_EXTERNAL_LIBRARIES.TRANSCODER, "textures", options),
+      await loadLibrary(BASIS_EXTERNAL_LIBRARIES.TRANSCODER_WASM, "textures", options)
     ]);
     BASIS = BASIS || globalThis.BASIS;
-    return await initializeBasisTrascoderModule(BASIS, wasmBinary);
+    return await initializeBasisTranscoderModule(BASIS, wasmBinary);
   }
-  function initializeBasisTrascoderModule(BasisModule, wasmBinary) {
+  function initializeBasisTranscoderModule(BasisModule, wasmBinary) {
     const options = {};
     if (wasmBinary) {
       options.wasmBinary = wasmBinary;
@@ -5575,8 +5650,8 @@
     let BASIS_ENCODER = null;
     let wasmBinary = null;
     [BASIS_ENCODER, wasmBinary] = await Promise.all([
-      await loadLibrary(BASIS_CDN_ENCODER_JS, "textures", options),
-      await loadLibrary(BASIS_CDN_ENCODER_WASM, "textures", options)
+      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);
@@ -5985,7 +6060,7 @@
         const fileConstructors = await loadBasisEncoderModule(options);
         return parseKTX2File(fileConstructors.KTX2File, data, options);
       }
-      const { BasisFile } = await loadBasisTrascoderModule(options);
+      const { BasisFile } = await loadBasisTranscoderModule(options);
       return parseBasisFile(BasisFile, data, options);
     }
     switch (options.basis.module) {
@@ -6000,7 +6075,7 @@
         }
       case "transcoder":
       default:
-        const { BasisFile } = await loadBasisTrascoderModule(options);
+        const { BasisFile } = await loadBasisTranscoderModule(options);
         return parseBasisFile(BasisFile, data, options);
     }
   }
@@ -6119,7 +6194,7 @@
     name: "Basis",
     id: "basis",
     module: "textures",
-    version: VERSION6,
+    version: VERSION5,
     worker: true,
     extensions: ["basis", "ktx2"],
     mimeTypes: ["application/octet-stream", "image/ktx2"],
@@ -6422,17 +6497,11 @@
   }
 
   // ../textures/src/compressed-texture-loader.ts
-  var DEFAULT_TEXTURE_LOADER_OPTIONS = {
-    "compressed-texture": {
-      libraryPath: "libs/",
-      useBasis: false
-    }
-  };
   var CompressedTextureWorkerLoader = {
     name: "Texture Containers",
     id: "compressed-texture",
     module: "textures",
-    version: VERSION6,
+    version: VERSION5,
     worker: true,
     extensions: [
       "ktx",
@@ -6448,12 +6517,17 @@
       "application/octet-stream"
     ],
     binary: true,
-    options: DEFAULT_TEXTURE_LOADER_OPTIONS
+    options: {
+      "compressed-texture": {
+        libraryPath: "libs/",
+        useBasis: false
+      }
+    }
   };
   var CompressedTextureLoader = {
     ...CompressedTextureWorkerLoader,
     parse: async (arrayBuffer, options) => {
-      if (options["compressed-texture"].useBasis) {
+      if (options?.["compressed-texture"]?.useBasis) {
         options.basis = {
           format: {
             alpha: "BC3",
@@ -6463,25 +6537,14 @@
           containerFormat: "ktx2",
           module: "encoder"
         };
-        return (await parseBasis(arrayBuffer, options))[0];
+        const result = await parseBasis(arrayBuffer, options);
+        return result[0];
       }
       return parseCompressedTexture(arrayBuffer);
     }
   };
 
   // src/types.ts
-  var DATA_TYPE;
-  (function(DATA_TYPE2) {
-    DATA_TYPE2["UInt8"] = "UInt8";
-    DATA_TYPE2["UInt16"] = "UInt16";
-    DATA_TYPE2["UInt32"] = "UInt32";
-    DATA_TYPE2["UInt64"] = "UInt64";
-    DATA_TYPE2["Int16"] = "Int16";
-    DATA_TYPE2["Int32"] = "Int32";
-    DATA_TYPE2["Int64"] = "Int64";
-    DATA_TYPE2["Float32"] = "Float32";
-    DATA_TYPE2["Float64"] = "Float64";
-  })(DATA_TYPE || (DATA_TYPE = {}));
   var HeaderAttributeProperty;
   (function(HeaderAttributeProperty2) {
     HeaderAttributeProperty2["vertexCount"] = "vertexCount";
@@ -7114,15 +7177,15 @@
   // src/lib/parsers/constants.ts
   function getConstructorForDataFormat(dataType) {
     switch (dataType) {
-      case DATA_TYPE.UInt8:
+      case "UInt8":
         return Uint8Array;
-      case DATA_TYPE.UInt16:
+      case "UInt16":
         return Uint16Array;
-      case DATA_TYPE.UInt32:
+      case "UInt32":
         return Uint32Array;
-      case DATA_TYPE.Float32:
+      case "Float32":
         return Float32Array;
-      case DATA_TYPE.UInt64:
+      case "UInt64":
         return Float64Array;
       default:
         throw new Error(`parse i3s tile content: unknown type of data: ${dataType}`);
@@ -7137,18 +7200,18 @@
   };
   function sizeOf(dataType) {
     switch (dataType) {
-      case DATA_TYPE.UInt8:
+      case "UInt8":
         return 1;
-      case DATA_TYPE.UInt16:
-      case DATA_TYPE.Int16:
+      case "UInt16":
+      case "Int16":
         return 2;
-      case DATA_TYPE.UInt32:
-      case DATA_TYPE.Int32:
-      case DATA_TYPE.Float32:
+      case "UInt32":
+      case "Int32":
+      case "Float32":
         return 4;
-      case DATA_TYPE.UInt64:
-      case DATA_TYPE.Int64:
-      case DATA_TYPE.Float64:
+      case "UInt64":
+      case "Int64":
+      case "Float64":
         return 8;
       default:
         throw new Error(`parse i3s tile content: unknown size of data: ${dataType}`);
@@ -7225,12 +7288,12 @@
   }
 
   // src/i3s-attribute-loader.ts
-  var VERSION8 = true ? "4.0.0-alpha.9" : "latest";
+  var VERSION6 = true ? "4.0.0-beta.1" : "latest";
   var I3SAttributeLoader = {
     name: "I3S Attribute",
     id: "i3s-attribute",
     module: "i3s",
-    version: VERSION8,
+    version: VERSION6,
     mimeTypes: ["application/binary"],
     parse: async (arrayBuffer, options) => parseI3STileAttribute(arrayBuffer, options),
     extensions: ["bin"],
@@ -7348,9 +7411,11 @@
         if (loader === ImageLoader) {
           const options2 = { ...tileOptions.textureLoaderOptions, image: { type: "data" } };
           try {
-            content.texture = await context.parse(arrayBuffer2, options2);
+            const texture = await parseFromContext(arrayBuffer2, [], options2, context);
+            content.texture = texture;
           } catch (e2) {
-            content.texture = await parse(arrayBuffer2, loader, options2);
+            const texture = await parse(arrayBuffer2, loader, options2, context);
+            content.texture = texture;
           }
         } else if (loader === CompressedTextureLoader || loader === BasisLoader) {
           let texture = await load(arrayBuffer2, loader, tileOptions.textureLoaderOptions);
@@ -7688,13 +7753,13 @@
   }
 
   // src/i3s-content-loader.ts
-  var VERSION9 = true ? "4.0.0-alpha.9" : "beta";
+  var VERSION7 = true ? "4.0.0-beta.1" : "beta";
   var I3SContentLoader = {
     name: "I3S Content (Indexed Scene Layers)",
     id: "i3s-content",
     module: "i3s",
     worker: true,
-    version: VERSION9,
+    version: VERSION7,
     mimeTypes: ["application/octet-stream"],
     parse: parse3,
     extensions: ["bin"],