@loaders.gl/i3s 4.4.0-alpha.2 → 4.4.0-alpha.9

package/dist/i3s-content-worker.js

@@ -473,7 +473,7 @@
   var dist_default = new Log({ id: "@probe.gl/log" });
 
   // ../loader-utils/src/lib/log-utils/log.ts
-  var VERSION2 = true ? "4.4.0-alpha.1" : "latest";
+  var VERSION2 = true ? "4.4.0-alpha.9" : "latest";
   var version = VERSION2[0] >= "0" && VERSION2[0] <= "9" ? `v${VERSION2}` : "";
   function createLog() {
     const log2 = new Log({ id: "loaders.gl" });
@@ -486,6 +486,21 @@
   }
   var log = createLog();
 
+  // ../loader-utils/src/lib/javascript-utils/is-type.ts
+  var isBoolean = (value) => typeof value === "boolean";
+  var isFunction = (value) => typeof value === "function";
+  var isObject = (value) => value !== null && typeof value === "object";
+  var isPureObject = (value) => isObject(value) && value.constructor === {}.constructor;
+  var isSharedArrayBuffer = (value) => typeof SharedArrayBuffer !== "undefined" && value instanceof SharedArrayBuffer;
+  var isArrayBufferLike = (value) => isObject(value) && typeof value.byteLength === "number" && typeof value.slice === "function";
+  var isIterable = (value) => Boolean(value) && isFunction(value[Symbol.iterator]);
+  var isAsyncIterable = (value) => Boolean(value) && isFunction(value[Symbol.asyncIterator]);
+  var isResponse = (value) => typeof Response !== "undefined" && value instanceof Response || isObject(value) && isFunction(value.arrayBuffer) && isFunction(value.text) && isFunction(value.json);
+  var isBlob = (value) => typeof Blob !== "undefined" && value instanceof Blob;
+  var isReadableDOMStream = (value) => typeof ReadableStream !== "undefined" && value instanceof ReadableStream || isObject(value) && isFunction(value.tee) && isFunction(value.cancel) && isFunction(value.getReader);
+  var isReadableNodeStream = (value) => isObject(value) && isFunction(value.read) && isFunction(value.pipe) && isBoolean(value.readable);
+  var isReadableStream = (value) => isReadableDOMStream(value) || isReadableNodeStream(value);
+
   // ../loader-utils/src/lib/option-utils/merge-options.ts
   function mergeOptions(baseOptions, newOptions) {
     return mergeOptionsRecursively(baseOptions || {}, newOptions);
@@ -532,8 +547,9 @@
           "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 = "4.4.0-alpha.1";
+        globalThis._loadersgl_.version = "4.4.0-alpha.9";
       }
     }
     return globalThis._loadersgl_.version;
@@ -789,7 +805,8 @@
       if (this.url) {
         const absolute = this.url.includes(":/") || this.url.startsWith("/");
         const url = absolute ? this.url : `./${this.url}`;
-        worker = new NodeWorker(url, { eval: false });
+        const type = this.url.endsWith(".ts") || this.url.endsWith(".mjs") ? "module" : "commonjs";
+        worker = new NodeWorker(url, { eval: false, type });
       } else if (this.source) {
         worker = new NodeWorker(this.source, { eval: true });
       } else {
@@ -1121,7 +1138,8 @@
     if (!url && worker.id === "compression") {
       url = options.workerUrl;
     }
-    if (options._workerType === "test") {
+    const workerType = options._workerType || options?.core?._workerType;
+    if (workerType === "test") {
       if (isBrowser3) {
         url = `modules/${worker.module}/dist/${workerFile}`;
       } else {
@@ -1161,6 +1179,9 @@
     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;
     }
@@ -1186,10 +1207,20 @@
       return await loadAsArrayBuffer(libraryUrl);
     }
     if (!isBrowser3) {
+      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;
       }
@@ -1225,7 +1256,14 @@
       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 || {};
@@ -1233,7 +1271,14 @@
       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}`);
+    }
   }
 
   // ../loader-utils/src/lib/worker-loader-utils/create-loader-worker.ts
@@ -1312,7 +1357,10 @@
     options = {
       ...options,
       modules: loader && loader.options && loader.options.modules || {},
-      worker: false
+      core: {
+        ...options.core,
+        worker: false
+      }
     };
     return await parser(data, { ...options }, context, loader);
   }
@@ -1322,15 +1370,17 @@
     if (!WorkerFarm.isSupported()) {
       return false;
     }
-    if (!isBrowser3 && !options?._nodeWorkers) {
+    const nodeWorkers = options?._nodeWorkers ?? options?.core?._nodeWorkers;
+    if (!isBrowser3 && !nodeWorkers) {
       return false;
     }
-    return loader.worker && options?.worker;
+    const useWorkers = options?.worker ?? options?.core?.worker;
+    return Boolean(loader.worker && useWorkers);
   }
   async function parseWithWorker(loader, data, options, context, parseOnMainThread2) {
     const name = loader.id;
     const url = getWorkerURL(loader, options);
-    const workerFarm = WorkerFarm.getWorkerFarm(options);
+    const workerFarm = WorkerFarm.getWorkerFarm(options?.core);
     const workerPool = workerFarm.getWorkerPool({ name, url });
     options = JSON.parse(JSON.stringify(options));
     context = JSON.parse(JSON.stringify(context || {}));
@@ -1408,10 +1458,26 @@
   async function concatenateArrayBuffersAsync(asyncIterator) {
     const arrayBuffers = [];
     for await (const chunk of asyncIterator) {
-      arrayBuffers.push(chunk);
+      arrayBuffers.push(copyToArrayBuffer(chunk));
     }
     return concatenateArrayBuffers(...arrayBuffers);
   }
+  function copyToArrayBuffer(chunk) {
+    if (chunk instanceof ArrayBuffer) {
+      return chunk;
+    }
+    if (ArrayBuffer.isView(chunk)) {
+      const { buffer, byteOffset, byteLength } = chunk;
+      return copyFromBuffer(buffer, byteOffset, byteLength);
+    }
+    return copyFromBuffer(chunk);
+  }
+  function copyFromBuffer(buffer, byteOffset = 0, byteLength = buffer.byteLength - byteOffset) {
+    const view = new Uint8Array(buffer, byteOffset, byteLength);
+    const copy2 = new Uint8Array(view.length);
+    copy2.set(view);
+    return copy2.buffer;
+  }
 
   // ../loader-utils/src/lib/path-utils/file-aliases.ts
   var pathPrefix = "";
@@ -1445,11 +1511,15 @@
     if (data instanceof ArrayBuffer) {
       return data;
     }
+    if (isSharedArrayBuffer(data)) {
+      return copyToArrayBuffer2(data);
+    }
     if (ArrayBuffer.isView(data)) {
+      const buffer = data.buffer;
       if (data.byteOffset === 0 && data.byteLength === data.buffer.byteLength) {
-        return data.buffer;
+        return buffer;
       }
-      return data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
+      return buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
     }
     if (typeof data === "string") {
       const text = data;
@@ -1461,6 +1531,31 @@
     }
     throw new Error("toArrayBuffer");
   }
+  function ensureArrayBuffer(bufferSource) {
+    if (bufferSource instanceof ArrayBuffer) {
+      return bufferSource;
+    }
+    if (isSharedArrayBuffer(bufferSource)) {
+      return copyToArrayBuffer2(bufferSource);
+    }
+    const { buffer, byteOffset, byteLength } = bufferSource;
+    if (buffer instanceof ArrayBuffer && byteOffset === 0 && byteLength === buffer.byteLength) {
+      return buffer;
+    }
+    return copyToArrayBuffer2(buffer, byteOffset, byteLength);
+  }
+  function copyToArrayBuffer2(buffer, byteOffset = 0, byteLength = buffer.byteLength - byteOffset) {
+    const view = new Uint8Array(buffer, byteOffset, byteLength);
+    const copy2 = new Uint8Array(view.length);
+    copy2.set(view);
+    return copy2.buffer;
+  }
+  function toArrayBufferView(data) {
+    if (ArrayBuffer.isView(data)) {
+      return data;
+    }
+    return new Uint8Array(data);
+  }
 
   // ../loader-utils/src/lib/path-utils/path.ts
   var path_exports = {};
@@ -1483,7 +1578,7 @@
   // ../loader-utils/src/lib/path-utils/path.ts
   function filename(url) {
     const slashIndex = url ? url.lastIndexOf("/") : -1;
-    return slashIndex >= 0 ? url.substr(slashIndex + 1) : "";
+    return slashIndex >= 0 ? url.substr(slashIndex + 1) : url;
   }
   function dirname(url) {
     const slashIndex = url ? url.lastIndexOf("/") : -1;
@@ -1605,20 +1700,6 @@
     return res;
   }
 
-  // ../core/src/javascript-utils/is-type.ts
-  var isBoolean = (x) => typeof x === "boolean";
-  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) => 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;
-  var isBuffer2 = (x) => x && typeof x === "object" && x.isBuffer;
-  var isReadableDOMStream = (x) => typeof ReadableStream !== "undefined" && x instanceof ReadableStream || isObject(x) && isFunction(x.tee) && isFunction(x.cancel) && isFunction(x.getReader);
-  var isReadableNodeStream = (x) => isObject(x) && isFunction(x.read) && isFunction(x.pipe) && isBoolean(x.readable);
-  var isReadableStream = (x) => isReadableDOMStream(x) || isReadableNodeStream(x);
-
   // ../core/src/lib/fetch/fetch-error.ts
   var FetchError = class extends Error {
     constructor(message, info) {
@@ -1680,12 +1761,11 @@
   // ../core/src/lib/utils/resource-utils.ts
   function getResourceUrl(resource) {
     if (isResponse(resource)) {
-      const response = resource;
-      return response.url;
+      return resource.url;
     }
     if (isBlob(resource)) {
-      const blob = resource;
-      return blob.name || "";
+      const fileName = "name" in resource ? resource.name : "";
+      return fileName || "";
     }
     if (typeof resource === "string") {
       return resource;
@@ -1694,14 +1774,12 @@
   }
   function getResourceMIMEType(resource) {
     if (isResponse(resource)) {
-      const response = resource;
-      const contentTypeHeader = response.headers.get("content-type") || "";
-      const noQueryUrl = stripQueryString(response.url);
+      const contentTypeHeader = resource.headers.get("content-type") || "";
+      const noQueryUrl = stripQueryString(resource.url);
       return parseMIMEType(contentTypeHeader) || parseMIMETypeFromURL(noQueryUrl);
     }
     if (isBlob(resource)) {
-      const blob = resource;
-      return blob.type || "";
+      return resource.type || "";
     }
     if (typeof resource === "string") {
       return parseMIMETypeFromURL(resource);
@@ -1870,39 +1948,68 @@
 
   // ../core/src/lib/loader-utils/option-defaults.ts
   var DEFAULT_LOADER_OPTIONS = {
-    // baseUri
-    fetch: null,
-    mimeType: void 0,
-    nothrow: false,
-    log: new ConsoleLog(),
-    // A probe.gl compatible (`log.log()()` syntax) that just logs to console
-    useLocalLibraries: false,
-    CDN: "https://unpkg.com/@loaders.gl",
-    worker: true,
-    // By default, use worker if provided by loader.
-    maxConcurrency: 3,
-    // How many worker instances should be created for each loader.
-    maxMobileConcurrency: 1,
-    // How many worker instances should be created for each loader on mobile devices.
-    reuseWorkers: isBrowser,
-    // By default reuse workers in browser (Node.js refuses to terminate if browsers are running)
-    _nodeWorkers: false,
-    // By default do not support node workers
-    _workerType: "",
-    // 'test' to use locally generated workers
-    limit: 0,
-    _limitMB: 0,
-    batchSize: "auto",
-    batchDebounceMs: 0,
-    metadata: false,
-    // TODO - currently only implemented for parseInBatches, adds initial metadata batch,
-    transforms: []
+    core: {
+      baseUri: void 0,
+      // baseUri
+      fetch: null,
+      mimeType: void 0,
+      fallbackMimeType: void 0,
+      ignoreRegisteredLoaders: void 0,
+      nothrow: false,
+      log: new ConsoleLog(),
+      // A probe.gl compatible (`log.log()()` syntax) that just logs to console
+      useLocalLibraries: false,
+      CDN: "https://unpkg.com/@loaders.gl",
+      worker: true,
+      // By default, use worker if provided by loader.
+      maxConcurrency: 3,
+      // How many worker instances should be created for each loader.
+      maxMobileConcurrency: 1,
+      // How many worker instances should be created for each loader on mobile devices.
+      reuseWorkers: isBrowser,
+      // By default reuse workers in browser (Node.js refuses to terminate if browsers are running)
+      _nodeWorkers: false,
+      // By default do not support node workers
+      _workerType: "",
+      // 'test' to use locally generated workers
+      limit: 0,
+      _limitMB: 0,
+      batchSize: "auto",
+      batchDebounceMs: 0,
+      metadata: false,
+      // TODO - currently only implemented for parseInBatches, adds initial metadata batch,
+      transforms: []
+    }
   };
   var REMOVED_LOADER_OPTIONS = {
+    // baseUri
+    baseUri: "core.baseUri",
+    fetch: "core.fetch",
+    mimeType: "core.mimeType",
+    fallbackMimeType: "core.fallbackMimeType",
+    ignoreRegisteredLoaders: "core.ignoreRegisteredLoaders",
+    nothrow: "core.nothrow",
+    log: "core.log",
+    useLocalLibraries: "core.useLocalLibraries",
+    CDN: "core.CDN",
+    worker: "core.worker",
+    maxConcurrency: "core.maxConcurrency",
+    maxMobileConcurrency: "core.maxMobileConcurrency",
+    reuseWorkers: "core.reuseWorkers",
+    _nodeWorkers: "core.nodeWorkers",
+    _workerType: "core._workerType",
+    _worker: "core._workerType",
+    limit: "core.limit",
+    _limitMB: "core._limitMB",
+    batchSize: "core.batchSize",
+    batchDebounceMs: "core.batchDebounceMs",
+    metadata: "core.metadata",
+    transforms: "core.transforms",
+    // Older deprecations
     throws: "nothrow",
     dataType: "(no longer used)",
     uri: "baseUri",
-    // Warn if fetch options are used on top-level
+    // Warn if fetch options are used on toplevel
     method: "fetch.method",
     headers: "fetch.headers",
     body: "fetch.body",
@@ -1918,6 +2025,29 @@
   };
 
   // ../core/src/lib/loader-utils/option-utils.ts
+  var CORE_LOADER_OPTION_KEYS = [
+    "baseUri",
+    "fetch",
+    "mimeType",
+    "fallbackMimeType",
+    "ignoreRegisteredLoaders",
+    "nothrow",
+    "log",
+    "useLocalLibraries",
+    "CDN",
+    "worker",
+    "maxConcurrency",
+    "maxMobileConcurrency",
+    "reuseWorkers",
+    "_nodeWorkers",
+    "_workerType",
+    "limit",
+    "_limitMB",
+    "batchSize",
+    "batchDebounceMs",
+    "metadata",
+    "transforms"
+  ];
   function getGlobalLoaderState() {
     globalThis.loaders = globalThis.loaders || {};
     const { loaders } = globalThis;
@@ -1928,14 +2058,30 @@
   }
   function getGlobalLoaderOptions() {
     const state = getGlobalLoaderState();
-    state.globalOptions = state.globalOptions || { ...DEFAULT_LOADER_OPTIONS };
-    return state.globalOptions;
+    state.globalOptions = state.globalOptions || {
+      ...DEFAULT_LOADER_OPTIONS,
+      core: { ...DEFAULT_LOADER_OPTIONS.core }
+    };
+    return normalizeLoaderOptions(state.globalOptions);
   }
   function normalizeOptions(options, loader, loaders, url) {
     loaders = loaders || [];
     loaders = Array.isArray(loaders) ? loaders : [loaders];
     validateOptions(options, loaders);
-    return normalizeOptionsInternal(loader, options, url);
+    return normalizeLoaderOptions(normalizeOptionsInternal(loader, options, url));
+  }
+  function normalizeLoaderOptions(options) {
+    const normalized = cloneLoaderOptions(options);
+    moveDeprecatedTopLevelOptionsToCore(normalized);
+    for (const key of CORE_LOADER_OPTION_KEYS) {
+      if (normalized.core && normalized.core[key] !== void 0) {
+        delete normalized[key];
+      }
+    }
+    if (normalized.core && normalized.core._workerType !== void 0) {
+      delete normalized._worker;
+    }
+    return normalized;
   }
   function validateOptions(options, loaders) {
     validateOptionsObject(options, null, DEFAULT_LOADER_OPTIONS, REMOVED_LOADER_OPTIONS, loaders);
@@ -1987,12 +2133,18 @@
   function normalizeOptionsInternal(loader, options, url) {
     const loaderDefaultOptions = loader.options || {};
     const mergedOptions = { ...loaderDefaultOptions };
-    addUrlOptions(mergedOptions, url);
-    if (mergedOptions.log === null) {
-      mergedOptions.log = new NullLog();
+    if (loaderDefaultOptions.core) {
+      mergedOptions.core = { ...loaderDefaultOptions.core };
     }
-    mergeNestedFields(mergedOptions, getGlobalLoaderOptions());
-    mergeNestedFields(mergedOptions, options);
+    moveDeprecatedTopLevelOptionsToCore(mergedOptions);
+    if (mergedOptions.core?.log === null) {
+      mergedOptions.core = { ...mergedOptions.core, log: new NullLog() };
+    }
+    mergeNestedFields(mergedOptions, normalizeLoaderOptions(getGlobalLoaderOptions()));
+    const userOptions = normalizeLoaderOptions(options);
+    mergeNestedFields(mergedOptions, userOptions);
+    addUrlOptions(mergedOptions, url);
+    addDeprecatedTopLevelOptions(mergedOptions);
     return mergedOptions;
   }
   function mergeNestedFields(mergedOptions, options) {
@@ -2011,8 +2163,50 @@
     }
   }
   function addUrlOptions(options, url) {
-    if (url && !("baseUri" in options)) {
-      options.baseUri = url;
+    if (!url) {
+      return;
+    }
+    const hasTopLevelBaseUri = options.baseUri !== void 0;
+    const hasCoreBaseUri = options.core?.baseUri !== void 0;
+    if (!hasTopLevelBaseUri && !hasCoreBaseUri) {
+      options.core ||= {};
+      options.core.baseUri = url;
+    }
+  }
+  function cloneLoaderOptions(options) {
+    const clonedOptions = { ...options };
+    if (options.core) {
+      clonedOptions.core = { ...options.core };
+    }
+    return clonedOptions;
+  }
+  function moveDeprecatedTopLevelOptionsToCore(options) {
+    for (const key of CORE_LOADER_OPTION_KEYS) {
+      if (options[key] !== void 0) {
+        const coreOptions = options.core = options.core || {};
+        const coreRecord = coreOptions;
+        if (coreRecord[key] === void 0) {
+          coreRecord[key] = options[key];
+        }
+      }
+    }
+    const workerTypeAlias = options._worker;
+    if (workerTypeAlias !== void 0) {
+      options.core ||= {};
+      if (options.core._workerType === void 0) {
+        options.core._workerType = workerTypeAlias;
+      }
+    }
+  }
+  function addDeprecatedTopLevelOptions(options) {
+    const coreOptions = options.core;
+    if (!coreOptions) {
+      return;
+    }
+    for (const key of CORE_LOADER_OPTION_KEYS) {
+      if (coreOptions[key] !== void 0) {
+        options[key] = coreOptions[key];
+      }
     }
   }
 
@@ -2064,15 +2258,22 @@
     if (!validHTTPResponse(data)) {
       return null;
     }
-    let loader = selectLoaderSync(data, loaders, { ...options, nothrow: true }, context);
+    const normalizedOptions = normalizeLoaderOptions(options || {});
+    normalizedOptions.core ||= {};
+    let loader = selectLoaderSync(
+      data,
+      loaders,
+      { ...normalizedOptions, core: { ...normalizedOptions.core, nothrow: true } },
+      context
+    );
     if (loader) {
       return loader;
     }
     if (isBlob(data)) {
       data = await data.slice(0, 10).arrayBuffer();
-      loader = selectLoaderSync(data, loaders, options, context);
+      loader = selectLoaderSync(data, loaders, normalizedOptions, context);
     }
-    if (!loader && !options?.nothrow) {
+    if (!loader && !normalizedOptions.core.nothrow) {
       throw new Error(getNoValidLoaderMessage(data));
     }
     return loader;
@@ -2081,6 +2282,8 @@
     if (!validHTTPResponse(data)) {
       return null;
     }
+    const normalizedOptions = normalizeLoaderOptions(options || {});
+    normalizedOptions.core ||= {};
     if (loaders && !Array.isArray(loaders)) {
       return normalizeLoader(loaders);
     }
@@ -2088,12 +2291,12 @@
     if (loaders) {
       candidateLoaders = candidateLoaders.concat(loaders);
     }
-    if (!options?.ignoreRegisteredLoaders) {
+    if (!normalizedOptions.core.ignoreRegisteredLoaders) {
       candidateLoaders.push(...getRegisteredLoaders());
     }
     normalizeLoaders(candidateLoaders);
-    const loader = selectLoaderInternal(data, candidateLoaders, options, context);
-    if (!loader && !options?.nothrow) {
+    const loader = selectLoaderInternal(data, candidateLoaders, normalizedOptions, context);
+    if (!loader && !normalizedOptions.core.nothrow) {
       throw new Error(getNoValidLoaderMessage(data));
     }
     return loader;
@@ -2104,9 +2307,9 @@
     const testUrl = stripQueryString(url) || context?.url;
     let loader = null;
     let reason = "";
-    if (options?.mimeType) {
-      loader = findLoaderByMIMEType(loaders, options?.mimeType);
-      reason = `match forced by supplied MIME type ${options?.mimeType}`;
+    if (options?.core?.mimeType) {
+      loader = findLoaderByMIMEType(loaders, options?.core?.mimeType);
+      reason = `match forced by supplied MIME type ${options?.core?.mimeType}`;
     }
     loader = loader || findLoaderByUrl(loaders, testUrl);
     reason = reason || (loader ? `matched url ${testUrl}` : "");
@@ -2114,8 +2317,8 @@
     reason = reason || (loader ? `matched MIME type ${type}` : "");
     loader = loader || findLoaderByInitialBytes(loaders, data);
     reason = reason || (loader ? `matched initial data ${getFirstCharacters(data)}` : "");
-    if (options?.fallbackMimeType) {
-      loader = loader || findLoaderByMIMEType(loaders, options?.fallbackMimeType);
+    if (options?.core?.fallbackMimeType) {
+      loader = loader || findLoaderByMIMEType(loaders, options?.core?.fallbackMimeType);
       reason = reason || (loader ? `matched fallback MIME type ${type}` : "");
     }
     if (reason) {
@@ -2208,12 +2411,12 @@
     return tests.some((test) => testBinary(data, byteOffset, loader, test));
   }
   function testBinary(data, byteOffset, loader, test) {
-    if (test instanceof ArrayBuffer) {
+    if (isArrayBufferLike(test)) {
       return compareArrayBuffers(test, data, test.byteLength);
     }
     switch (typeof test) {
       case "function":
-        return test(data);
+        return test(ensureArrayBuffer(data));
       case "string":
         const magic = getMagicString(data, byteOffset, test.length);
         return test === magic;
@@ -2254,7 +2457,7 @@
       const chunkLength = Math.min(string.length - offset, chunkSize);
       const chunk = string.slice(offset, offset + chunkLength);
       offset += chunkLength;
-      yield textEncoder.encode(chunk);
+      yield ensureArrayBuffer(textEncoder.encode(chunk));
     }
   }
 
@@ -2331,8 +2534,11 @@
       return makeStreamIterator(data, options);
     }
     if (isResponse(data)) {
-      const response = data;
-      return makeStreamIterator(response.body, options);
+      const responseBody = data.body;
+      if (!responseBody) {
+        throw new Error("Readable stream not available on Response");
+      }
+      return makeStreamIterator(responseBody, options);
     }
     throw new Error("makeIterator");
   }
@@ -2343,43 +2549,29 @@
     if (loader.text && typeof data === "string") {
       return data;
     }
-    if (isBuffer2(data)) {
+    if (isBuffer(data)) {
       data = data.buffer;
     }
-    if (data instanceof ArrayBuffer) {
-      const arrayBuffer = data;
-      if (loader.text && !loader.binary) {
-        const textDecoder = new TextDecoder("utf8");
-        return textDecoder.decode(arrayBuffer);
-      }
-      return arrayBuffer;
-    }
-    if (ArrayBuffer.isView(data)) {
+    if (isArrayBufferLike(data)) {
+      const bufferSource = toArrayBufferView(data);
       if (loader.text && !loader.binary) {
         const textDecoder = new TextDecoder("utf8");
-        return textDecoder.decode(data);
-      }
-      let arrayBuffer = data.buffer;
-      const byteLength = data.byteLength || data.length;
-      if (data.byteOffset !== 0 || byteLength !== arrayBuffer.byteLength) {
-        arrayBuffer = arrayBuffer.slice(data.byteOffset, data.byteOffset + byteLength);
+        return textDecoder.decode(bufferSource);
       }
-      return arrayBuffer;
+      return toArrayBuffer2(bufferSource);
     }
     throw new Error(ERR_DATA);
   }
   async function getArrayBufferOrStringFromData(data, loader, options) {
-    const isArrayBuffer = data instanceof ArrayBuffer || ArrayBuffer.isView(data);
-    if (typeof data === "string" || isArrayBuffer) {
+    if (typeof data === "string" || isArrayBufferLike(data)) {
       return getArrayBufferOrStringFromDataSync(data, loader, options);
     }
     if (isBlob(data)) {
       data = await makeResponse(data);
     }
     if (isResponse(data)) {
-      const response = data;
-      await checkResponse(response);
-      return loader.binary ? await response.arrayBuffer() : await response.text();
+      await checkResponse(data);
+      return loader.binary ? await data.arrayBuffer() : await data.text();
     }
     if (isReadableStream(data)) {
       data = makeIterator(data, options);
@@ -2394,11 +2586,12 @@
   function getFetchFunction(options, context) {
     const globalOptions = getGlobalLoaderOptions();
     const loaderOptions = options || globalOptions;
-    if (typeof loaderOptions.fetch === "function") {
-      return loaderOptions.fetch;
+    const fetchOption = loaderOptions.fetch ?? loaderOptions.core?.fetch;
+    if (typeof fetchOption === "function") {
+      return fetchOption;
     }
-    if (isObject(loaderOptions.fetch)) {
-      return (url) => fetchFile(url, loaderOptions.fetch);
+    if (isObject(fetchOption)) {
+      return (url) => fetchFile(url, fetchOption);
     }
     if (context?.fetch) {
       return context?.fetch;
@@ -2458,22 +2651,21 @@
     if (!loader) {
       return null;
     }
-    options = normalizeOptions(options, loader, candidateLoaders, url);
+    const strictOptions = normalizeOptions(options, loader, candidateLoaders, url);
     context = getLoaderContext(
       // @ts-expect-error
       { url, _parse: parse, loaders: candidateLoaders },
-      options,
+      strictOptions,
       context || null
     );
-    return await parseWithLoader(loader, data, options, context);
+    return await parseWithLoader(loader, data, strictOptions, context);
   }
   async function parseWithLoader(loader, data, options, context) {
     validateWorkerVersion(loader);
     options = mergeOptions(loader.options, options);
     if (isResponse(data)) {
-      const response = data;
-      const { ok, redirected, status, statusText, type, url } = response;
-      const headers = Object.fromEntries(response.headers.entries());
+      const { ok, redirected, status, statusText, type, url } = data;
+      const headers = Object.fromEntries(data.headers.entries());
       context.response = { headers, ok, redirected, status, statusText, type, url };
     }
     data = await getArrayBufferOrStringFromData(data, loader, options);
@@ -5348,7 +5540,7 @@
   Ellipsoid.WGS84 = new Ellipsoid(WGS84_RADIUS_X, WGS84_RADIUS_Y, WGS84_RADIUS_Z);
 
   // ../images/src/lib/utils/version.ts
-  var VERSION4 = true ? "4.4.0-alpha.1" : "latest";
+  var VERSION4 = true ? "4.4.0-alpha.9" : "latest";
 
   // ../images/src/lib/category-api/image-type.ts
   var parseImageNode = globalThis.loaders?.parseImageNode;
@@ -5486,7 +5678,6 @@
   }
 
   // ../images/src/lib/parsers/parse-to-image-bitmap.ts
-  var EMPTY_OBJECT = {};
   var imagebitmapOptionsSupported = true;
   async function parseToImageBitmap(arrayBuffer, options, url) {
     let blob;
@@ -5514,8 +5705,13 @@
     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;
   }
@@ -5776,21 +5972,32 @@
     [DRACO_EXTERNAL_LIBRARIES.ENCODER]: `https://raw.githubusercontent.com/google/draco/${DRACO_ENCODER_VERSION}/javascript/${DRACO_EXTERNAL_LIBRARIES.ENCODER}`
   };
   var loadDecoderPromise;
-  async function loadDracoDecoderModule(options) {
+  async function loadDracoDecoderModule(options = {}, type) {
     const modules = options.modules || {};
     if (modules.draco3d) {
       loadDecoderPromise ||= modules.draco3d.createDecoderModule({}).then((draco) => {
         return { draco };
       });
     } else {
-      loadDecoderPromise ||= loadDracoDecoder(options);
+      loadDecoderPromise ||= loadDracoDecoder(options, type);
     }
     return await loadDecoderPromise;
   }
-  async function loadDracoDecoder(options) {
+  function getLibraryExport(library, exportName) {
+    if (library && typeof library === "object") {
+      if (library.default) {
+        return library.default;
+      }
+      if (library[exportName]) {
+        return library[exportName];
+      }
+    }
+    return library;
+  }
+  async function loadDracoDecoder(options, type) {
     let DracoDecoderModule;
     let wasmBinary;
-    switch (options.draco && options.draco.decoderType) {
+    switch (type) {
       case "js":
         DracoDecoderModule = await loadLibrary(
           DRACO_EXTERNAL_LIBRARY_URLS[DRACO_EXTERNAL_LIBRARIES.FALLBACK_DECODER],
@@ -5801,25 +6008,52 @@
         break;
       case "wasm":
       default:
-        [DracoDecoderModule, wasmBinary] = await Promise.all([
-          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
-          )
-        ]);
+        try {
+          [DracoDecoderModule, wasmBinary] = await Promise.all([
+            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
+            )
+          ]);
+        } catch {
+          DracoDecoderModule = null;
+          wasmBinary = null;
+        }
     }
+    DracoDecoderModule = getLibraryExport(DracoDecoderModule, "DracoDecoderModule");
     DracoDecoderModule = DracoDecoderModule || globalThis.DracoDecoderModule;
+    if (!DracoDecoderModule && !isBrowser3) {
+      [DracoDecoderModule, wasmBinary] = await Promise.all([
+        await loadLibrary(
+          DRACO_EXTERNAL_LIBRARY_URLS[DRACO_EXTERNAL_LIBRARIES.DECODER],
+          "draco",
+          { ...options, useLocalLibraries: true },
+          DRACO_EXTERNAL_LIBRARIES.DECODER
+        ),
+        await loadLibrary(
+          DRACO_EXTERNAL_LIBRARY_URLS[DRACO_EXTERNAL_LIBRARIES.DECODER_WASM],
+          "draco",
+          { ...options, useLocalLibraries: true },
+          DRACO_EXTERNAL_LIBRARIES.DECODER_WASM
+        )
+      ]);
+      DracoDecoderModule = getLibraryExport(DracoDecoderModule, "DracoDecoderModule");
+      DracoDecoderModule = DracoDecoderModule || globalThis.DracoDecoderModule;
+    }
     return await initializeDracoDecoder(DracoDecoderModule, wasmBinary);
   }
   function initializeDracoDecoder(DracoDecoderModule, wasmBinary) {
+    if (typeof DracoDecoderModule !== "function") {
+      throw new Error("DracoDecoderModule could not be loaded");
+    }
     const options = {};
     if (wasmBinary) {
       options.wasmBinary = wasmBinary;
@@ -5834,7 +6068,7 @@
   }
 
   // ../draco/src/lib/utils/version.ts
-  var VERSION5 = true ? "4.4.0-alpha.1" : "latest";
+  var VERSION5 = true ? "4.4.0-alpha.9" : "latest";
 
   // ../draco/src/lib/utils/get-draco-schema.ts
   function getDracoSchema(attributes, loaderData, indices) {
@@ -6362,7 +6596,10 @@
     parse: parse2
   };
   async function parse2(arrayBuffer, options) {
-    const { draco } = await loadDracoDecoderModule(options);
+    const { draco } = await loadDracoDecoderModule(
+      options?.core,
+      options?.draco?.decoderType || "wasm"
+    );
     const dracoParser = new DracoParser(draco);
     try {
       return dracoParser.parseSync(arrayBuffer, options?.draco);
@@ -6372,7 +6609,7 @@
   }
 
   // ../textures/src/lib/utils/version.ts
-  var VERSION6 = true ? "4.4.0-alpha.1" : "latest";
+  var VERSION6 = true ? "4.4.0-alpha.9" : "latest";
 
   // ../textures/src/lib/parsers/basis-module-loader.ts
   var BASIS_EXTERNAL_LIBRARIES = {
@@ -7052,18 +7289,18 @@
     bgr565: { basisFormat: 15, compressed: false },
     rgba4444: { basisFormat: 16, compressed: false }
   };
-  async function parseBasis(data, options) {
-    if (options.basis.containerFormat === "auto") {
+  async function parseBasis(data, options = {}) {
+    if (!options.basis?.containerFormat || options.basis.containerFormat === "auto") {
       if (isKTX(data)) {
-        const fileConstructors = await loadBasisEncoderModule(options);
+        const fileConstructors = await loadBasisEncoderModule(options?.core || {});
         return parseKTX2File(fileConstructors.KTX2File, data, options);
       }
-      const { BasisFile } = await loadBasisTranscoderModule(options);
+      const { BasisFile } = await loadBasisTranscoderModule(options?.core || {});
       return parseBasisFile(BasisFile, data, options);
     }
     switch (options.basis.module) {
       case "encoder":
-        const fileConstructors = await loadBasisEncoderModule(options);
+        const fileConstructors = await loadBasisEncoderModule(options?.core || {});
         switch (options.basis.containerFormat) {
           case "ktx2":
             return parseKTX2File(fileConstructors.KTX2File, data, options);
@@ -7073,7 +7310,7 @@
         }
       case "transcoder":
       default:
-        const { BasisFile } = await loadBasisTranscoderModule(options);
+        const { BasisFile } = await loadBasisTranscoderModule(options.core || {});
         return parseBasisFile(BasisFile, data, options);
     }
   }
@@ -7176,7 +7413,7 @@
     };
   }
   function getBasisOptions(options, hasAlpha) {
-    let format = options && options.basis && options.basis.format;
+    let format = options.basis?.format;
     if (format === "auto") {
       format = selectSupportedBasisFormat();
     }
@@ -7560,13 +7797,13 @@
   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"
@@ -8055,7 +8292,7 @@
   }
 
   // src/i3s-content-loader.ts
-  var VERSION7 = true ? "4.4.0-alpha.1" : "latest";
+  var VERSION7 = true ? "4.4.0-alpha.9" : "latest";
   var I3SContentLoader = {
     dataType: null,
     batchType: null,