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

package/dist/dist.dev.js

@@ -562,6 +562,26 @@ var __exports__ = (() => {
   }
   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 isPromise = (value) => isObject(value) && "then" in value && isFunction(value.then);
+  var isIterable = (value) => Boolean(value) && isFunction(value[Symbol.iterator]);
+  var isAsyncIterable = (value) => Boolean(value) && isFunction(value[Symbol.asyncIterator]);
+  var isIterator = (value) => Boolean(value) && isFunction(value.next);
+  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 isWritableDOMStream = (value) => isObject(value) && isFunction(value.abort) && isFunction(value.getWriter);
+  var isReadableDOMStream = (value) => typeof ReadableStream !== "undefined" && value instanceof ReadableStream || isObject(value) && isFunction(value.tee) && isFunction(value.cancel) && isFunction(value.getReader);
+  var isWritableNodeStream = (value) => isObject(value) && isFunction(value.end) && isFunction(value.write) && isBoolean(value.writable);
+  var isReadableNodeStream = (value) => isObject(value) && isFunction(value.read) && isFunction(value.pipe) && isBoolean(value.readable);
+  var isReadableStream = (value) => isReadableDOMStream(value) || isReadableNodeStream(value);
+  var isWritableStream = (value) => isWritableDOMStream(value) || isWritableNodeStream(value);
+
   // ../loader-utils/src/lib/option-utils/merge-options.ts
   function mergeOptions(baseOptions, newOptions) {
     return mergeOptionsRecursively(baseOptions || {}, newOptions);
@@ -596,14 +616,16 @@ var __exports__ = (() => {
   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__;
       }
@@ -875,7 +897,8 @@ var __exports__ = (() => {
       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 {
@@ -1131,7 +1154,8 @@ var __exports__ = (() => {
     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 {
@@ -1213,15 +1237,17 @@ var __exports__ = (() => {
     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, parseOnMainThread) {
     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 || {}));
@@ -1268,10 +1294,12 @@ var __exports__ = (() => {
     if (!WorkerFarm.isSupported()) {
       return false;
     }
-    if (!isBrowser && !options?._nodeWorkers) {
+    const nodeWorkers = options?._nodeWorkers ?? options?.core?._nodeWorkers;
+    const useWorkers = options?.worker ?? options?.core?.worker;
+    if (!isBrowser && !nodeWorkers) {
       return false;
     }
-    return writer.worker && options?.worker;
+    return Boolean(writer.worker && useWorkers);
   }
 
   // ../loader-utils/src/lib/binary-utils/array-buffer-utils.ts
@@ -1316,7 +1344,7 @@ var __exports__ = (() => {
   async function* makeTextEncoderIterator(textIterator) {
     const textEncoder = new TextEncoder();
     for await (const text of textIterator) {
-      yield typeof text === "string" ? textEncoder.encode(text) : text;
+      yield typeof text === "string" ? textEncoder.encode(text).buffer : text;
     }
   }
   async function* makeLineIterator(textIterator) {
@@ -1343,11 +1371,14 @@ var __exports__ = (() => {
   }
 
   // ../loader-utils/src/lib/iterators/async-iteration.ts
-  async function forEach(iterator, visitor) {
+  async function forEach(iterable, visitor) {
+    const iterator = toAsyncIterator(iterable);
     while (true) {
       const { done, value } = await iterator.next();
       if (done) {
-        iterator.return();
+        if (iterator.return) {
+          iterator.return();
+        }
         return;
       }
       const cancel = visitor(value);
@@ -1359,10 +1390,55 @@ var __exports__ = (() => {
   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 copy = new Uint8Array(view.length);
+    copy.set(view);
+    return copy.buffer;
+  }
+  function toAsyncIterator(iterable) {
+    if (typeof iterable[Symbol.asyncIterator] === "function") {
+      return iterable[Symbol.asyncIterator]();
+    }
+    if (typeof iterable[Symbol.iterator] === "function") {
+      const iterator = iterable[Symbol.iterator]();
+      return iteratorToAsyncIterator(iterator);
+    }
+    return iterable;
+  }
+  function iteratorToAsyncIterator(iterator) {
+    return {
+      next(value) {
+        return Promise.resolve(iterator.next(value));
+      },
+      return(value) {
+        if (typeof iterator.return === "function") {
+          return Promise.resolve(iterator.return(value));
+        }
+        return Promise.resolve({ done: true, value });
+      },
+      throw(error) {
+        if (typeof iterator.throw === "function") {
+          return Promise.resolve(iterator.throw(error));
+        }
+        return Promise.reject(error);
+      }
+    };
+  }
 
   // ../../node_modules/@probe.gl/stats/dist/utils/hi-res-timestamp.js
   function getHiResTimestamp2() {
@@ -1592,6 +1668,20 @@ var __exports__ = (() => {
       this.stats.get(STAT_QUEUED_REQUESTS_EVER);
       this.stats.get(STAT_ACTIVE_REQUESTS_EVER);
     }
+    /**
+     * Update scheduler props. Preserves active and queued requests.
+     */
+    setProps(props) {
+      if (props.throttleRequests !== void 0) {
+        this.props.throttleRequests = props.throttleRequests;
+      }
+      if (props.maxRequests !== void 0) {
+        this.props.maxRequests = props.maxRequests;
+      }
+      if (props.debounceTime !== void 0) {
+        this.props.debounceTime = props.debounceTime;
+      }
+    }
     /**
      * Called by an application that wants to issue a request, without having it deeply queued by the browser
      *
@@ -1749,11 +1839,15 @@ var __exports__ = (() => {
     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;
@@ -1765,6 +1859,31 @@ var __exports__ = (() => {
     }
     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 copy = new Uint8Array(view.length);
+    copy.set(view);
+    return copy.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 = {};
@@ -1787,7 +1906,7 @@ var __exports__ = (() => {
   // ../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;
@@ -1977,25 +2096,6 @@ var __exports__ = (() => {
     }
   };
 
-  // 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 isPromise = (x) => isObject(x) && isFunction(x.then);
-  var isIterable = (x) => Boolean(x) && typeof x[Symbol.iterator] === "function";
-  var isAsyncIterable = (x) => x && typeof x[Symbol.asyncIterator] === "function";
-  var isIterator = (x) => x && isFunction(x.next);
-  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 isWritableDOMStream = (x) => isObject(x) && isFunction(x.abort) && isFunction(x.getWriter);
-  var isReadableDOMStream = (x) => typeof ReadableStream !== "undefined" && x instanceof ReadableStream || isObject(x) && isFunction(x.tee) && isFunction(x.cancel) && isFunction(x.getReader);
-  var isWritableNodeStream = (x) => isObject(x) && isFunction(x.end) && isFunction(x.write) && isBoolean(x.writable);
-  var isReadableNodeStream = (x) => isObject(x) && isFunction(x.read) && isFunction(x.pipe) && isBoolean(x.readable);
-  var isReadableStream = (x) => isReadableDOMStream(x) || isReadableNodeStream(x);
-  var isWritableStream = (x) => isWritableDOMStream(x) || isWritableNodeStream(x);
-
   // src/lib/fetch/fetch-error.ts
   var FetchError = class extends Error {
     constructor(message, info) {
@@ -2057,12 +2157,11 @@ var __exports__ = (() => {
   // 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;
@@ -2071,14 +2170,12 @@ var __exports__ = (() => {
   }
   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);
@@ -2264,39 +2361,68 @@ var __exports__ = (() => {
 
   // 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",
@@ -2312,6 +2438,29 @@ var __exports__ = (() => {
   };
 
   // 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;
@@ -2322,8 +2471,11 @@ var __exports__ = (() => {
   }
   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 setGlobalOptions(options) {
     const state = getGlobalLoaderState();
@@ -2335,7 +2487,20 @@ var __exports__ = (() => {
     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);
@@ -2387,12 +2552,18 @@ var __exports__ = (() => {
   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) {
@@ -2411,8 +2582,50 @@ var __exports__ = (() => {
     }
   }
   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];
+      }
     }
   }
 
@@ -2478,15 +2691,22 @@ var __exports__ = (() => {
     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;
@@ -2495,6 +2715,8 @@ var __exports__ = (() => {
     if (!validHTTPResponse(data)) {
       return null;
     }
+    const normalizedOptions = normalizeLoaderOptions(options || {});
+    normalizedOptions.core ||= {};
     if (loaders && !Array.isArray(loaders)) {
       return normalizeLoader(loaders);
     }
@@ -2502,12 +2724,12 @@ var __exports__ = (() => {
     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;
@@ -2518,9 +2740,9 @@ var __exports__ = (() => {
     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}` : "");
@@ -2528,8 +2750,8 @@ var __exports__ = (() => {
     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) {
@@ -2622,12 +2844,12 @@ var __exports__ = (() => {
     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;
@@ -2668,7 +2890,7 @@ var __exports__ = (() => {
       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));
     }
   }
 
@@ -2745,8 +2967,11 @@ var __exports__ = (() => {
       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");
   }
@@ -2757,43 +2982,29 @@ var __exports__ = (() => {
     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 (isArrayBufferLike(data)) {
+      const bufferSource = toArrayBufferView(data);
       if (loader.text && !loader.binary) {
         const textDecoder = new TextDecoder("utf8");
-        return textDecoder.decode(arrayBuffer);
-      }
-      return arrayBuffer;
-    }
-    if (ArrayBuffer.isView(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);
@@ -2804,13 +3015,18 @@ var __exports__ = (() => {
     throw new Error(ERR_DATA);
   }
   async function getAsyncIterableFromData(data, options) {
+    if (isPromise(data)) {
+      data = await data;
+    }
     if (isIterator(data)) {
       return data;
     }
     if (isResponse(data)) {
-      const response = data;
-      await checkResponse(response);
-      const body = await response.body;
+      await checkResponse(data);
+      const body = await data.body;
+      if (!body) {
+        throw new Error(ERR_DATA);
+      }
       return makeIterator(body, options);
     }
     if (isBlob(data) || isReadableStream(data)) {
@@ -2819,17 +3035,20 @@ var __exports__ = (() => {
     if (isAsyncIterable(data)) {
       return data;
     }
+    if (isIterable(data)) {
+      return data;
+    }
     return getIterableFromData(data);
   }
   function getIterableFromData(data) {
     if (ArrayBuffer.isView(data)) {
       return function* oneChunk() {
-        yield data.buffer;
+        yield toArrayBuffer2(data);
       }();
     }
-    if (data instanceof ArrayBuffer) {
+    if (isArrayBufferLike(data)) {
       return function* oneChunk() {
-        yield data;
+        yield toArrayBuffer2(data);
       }();
     }
     if (isIterator(data)) {
@@ -2845,11 +3064,12 @@ var __exports__ = (() => {
   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;
@@ -2909,22 +3129,21 @@ var __exports__ = (() => {
     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);
@@ -2959,17 +3178,17 @@ var __exports__ = (() => {
     if (!loader) {
       return null;
     }
-    options = normalizeOptions(options, loader, candidateLoaders);
+    const strictOptions = normalizeOptions(options, loader, candidateLoaders);
     const url = getResourceUrl(data);
     const parse2 = () => {
       throw new Error("parseSync called parse (which is async");
     };
     context = getLoaderContext(
       { url, _parseSync: parse2, _parse: parse2, loaders },
-      options,
+      strictOptions,
       context || null
     );
-    return parseWithLoaderSync(loader, data, options, context);
+    return parseWithLoaderSync(loader, data, strictOptions, context);
   }
   function parseWithLoaderSync(loader, data, options, context) {
     data = getArrayBufferOrStringFromDataSync(data, loader, options);
@@ -3041,17 +3260,17 @@ var __exports__ = (() => {
     if (!loader) {
       return [];
     }
-    options = normalizeOptions(options, loader, loaderArray, url);
+    const strictOptions = normalizeOptions(options, loader, loaderArray, url);
     context = getLoaderContext(
       { url, _parseInBatches: parseInBatches, _parse: parse, loaders: loaderArray },
-      options,
+      strictOptions,
       context || null
     );
-    return await parseWithLoaderInBatches(loader, data, options, context);
+    return await parseWithLoaderInBatches(loader, data, strictOptions, context);
   }
   async function parseWithLoaderInBatches(loader, data, options, context) {
     const outputIterator = await parseToOutputIterator(loader, data, options, context);
-    if (!options.metadata) {
+    if (!options?.core?.metadata) {
       return outputIterator;
     }
     const metadataBatch = {
@@ -3073,7 +3292,10 @@ var __exports__ = (() => {
   }
   async function parseToOutputIterator(loader, data, options, context) {
     const inputIterator = await getAsyncIterableFromData(data, options);
-    const transformedIterator = await applyInputTransforms(inputIterator, options?.transforms || []);
+    const transformedIterator = await applyInputTransforms(
+      inputIterator,
+      options?.core?.transforms || []
+    );
     if (loader.parseInBatches) {
       return loader.parseInBatches(transformedIterator, options, context);
     }
@@ -3085,7 +3307,7 @@ var __exports__ = (() => {
       arrayBuffer,
       loader,
       // TODO - Hack: supply loaders MIME type to ensure we match it
-      { ...options, mimeType: loader.mimeTypes[0] },
+      { ...options, core: { ...options?.core, mimeType: loader.mimeTypes[0] } },
       context
     );
     const batch = convertDataToBatch(parsedData, loader);
@@ -3167,7 +3389,7 @@ var __exports__ = (() => {
     }
     if (writer.encodeText) {
       const text = await writer.encodeText(data, options);
-      return new TextEncoder().encode(text);
+      return ensureArrayBuffer(new TextEncoder().encode(text));
     }
     if (writer.encodeInBatches) {
       const batches = encodeTableInBatches(data, writer, options);
@@ -3218,7 +3440,7 @@ var __exports__ = (() => {
       return writer.encodeSync(data, options);
     }
     if (writer.encodeTextSync) {
-      return new TextEncoder().encode(writer.encodeTextSync(data, options));
+      return ensureArrayBuffer(new TextEncoder().encode(writer.encodeTextSync(data, options)));
     }
     throw new Error(`Writer ${writer.name} could not synchronously encode data`);
   }