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

package/dist/index.cjs

@@ -21,18 +21,18 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var dist_exports = {};
 __export(dist_exports, {
   FetchError: () => FetchError,
-  JSONLoader: () => import_loader_utils16.JSONLoader,
+  JSONLoader: () => import_loader_utils22.JSONLoader,
   NullLoader: () => NullLoader,
   NullWorkerLoader: () => NullWorkerLoader,
-  RequestScheduler: () => import_loader_utils15.RequestScheduler,
+  RequestScheduler: () => import_loader_utils21.RequestScheduler,
   _BrowserFileSystem: () => BrowserFileSystem,
   _fetchProgress: () => fetchProgress,
   _selectSource: () => selectSource2,
   _unregisterLoaders: () => _unregisterLoaders,
-  assert: () => import_loader_utils18.assert,
-  concatenateArrayBuffersAsync: () => import_loader_utils19.concatenateArrayBuffersAsync,
+  assert: () => import_loader_utils24.assert,
+  concatenateArrayBuffersAsync: () => import_loader_utils25.concatenateArrayBuffersAsync,
   createDataSource: () => createDataSource,
-  document: () => import_loader_utils17.document,
+  document: () => import_loader_utils23.document,
   encode: () => encode,
   encodeInBatches: () => encodeInBatches,
   encodeSync: () => encodeSync,
@@ -43,64 +43,48 @@ __export(dist_exports, {
   encodeTextSync: () => encodeTextSync,
   encodeURLtoURL: () => encodeURLtoURL,
   fetchFile: () => fetchFile,
-  forEach: () => import_loader_utils19.forEach,
+  forEach: () => import_loader_utils25.forEach,
   getLoaderOptions: () => getGlobalLoaderOptions,
-  getPathPrefix: () => import_loader_utils14.getPathPrefix,
-  global: () => import_loader_utils17.global,
-  isAsyncIterable: () => isAsyncIterable,
-  isBrowser: () => import_loader_utils17.isBrowser,
-  isIterable: () => isIterable,
-  isIterator: () => isIterator,
-  isPromise: () => isPromise,
-  isPureObject: () => isPureObject,
-  isReadableStream: () => isReadableStream,
-  isResponse: () => isResponse,
-  isWorker: () => import_loader_utils17.isWorker,
-  isWritableStream: () => isWritableStream,
+  getPathPrefix: () => import_loader_utils20.getPathPrefix,
+  global: () => import_loader_utils23.global,
+  isAsyncIterable: () => import_loader_utils27.isAsyncIterable,
+  isBrowser: () => import_loader_utils23.isBrowser,
+  isIterable: () => import_loader_utils27.isIterable,
+  isIterator: () => import_loader_utils27.isIterator,
+  isPromise: () => import_loader_utils27.isPromise,
+  isPureObject: () => import_loader_utils27.isPureObject,
+  isReadableStream: () => import_loader_utils27.isReadableStream,
+  isResponse: () => import_loader_utils27.isResponse,
+  isWorker: () => import_loader_utils23.isWorker,
+  isWritableStream: () => import_loader_utils27.isWritableStream,
   load: () => load,
   loadInBatches: () => loadInBatches,
   makeIterator: () => makeIterator,
-  makeLineIterator: () => import_loader_utils20.makeLineIterator,
-  makeNumberedLineIterator: () => import_loader_utils20.makeNumberedLineIterator,
+  makeLineIterator: () => import_loader_utils26.makeLineIterator,
+  makeNumberedLineIterator: () => import_loader_utils26.makeNumberedLineIterator,
   makeStream: () => makeStream,
-  makeTextDecoderIterator: () => import_loader_utils20.makeTextDecoderIterator,
-  makeTextEncoderIterator: () => import_loader_utils20.makeTextEncoderIterator,
+  makeTextDecoderIterator: () => import_loader_utils26.makeTextDecoderIterator,
+  makeTextEncoderIterator: () => import_loader_utils26.makeTextEncoderIterator,
   parse: () => parse,
   parseInBatches: () => parseInBatches,
   parseSync: () => parseSync,
   readArrayBuffer: () => readArrayBuffer,
   registerLoaders: () => registerLoaders,
-  resolvePath: () => import_loader_utils14.resolvePath,
+  resolvePath: () => import_loader_utils20.resolvePath,
   selectLoader: () => selectLoader,
   selectLoaderSync: () => selectLoaderSync,
-  self: () => import_loader_utils17.self,
+  self: () => import_loader_utils23.self,
   setLoaderOptions: () => setGlobalOptions,
-  setPathPrefix: () => import_loader_utils14.setPathPrefix,
-  window: () => import_loader_utils17.window
+  setPathPrefix: () => import_loader_utils20.setPathPrefix,
+  window: () => import_loader_utils23.window
 });
 module.exports = __toCommonJS(dist_exports);
 
 // dist/lib/fetch/fetch-file.js
-var import_loader_utils = require("@loaders.gl/loader-utils");
+var import_loader_utils3 = require("@loaders.gl/loader-utils");
 
-// dist/javascript-utils/is-type.js
-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 isBuffer = (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);
+// dist/lib/utils/response-utils.js
+var import_loader_utils2 = require("@loaders.gl/loader-utils");
 
 // dist/lib/fetch/fetch-error.js
 var FetchError = class extends Error {
@@ -118,6 +102,9 @@ var FetchError = class extends Error {
   response;
 };
 
+// dist/lib/utils/resource-utils.js
+var import_loader_utils = require("@loaders.gl/loader-utils");
+
 // dist/lib/utils/mime-type-utils.js
 var DATA_URL_PATTERN = /^data:([-\w.]+\/[-\w.+]+)(;|,)/;
 var MIME_TYPE_PATTERN = /^([-\w.]+\/[-\w.+]+)/;
@@ -162,13 +149,12 @@ function shortenUrlForDisplay(url) {
 
 // dist/lib/utils/resource-utils.js
 function getResourceUrl(resource) {
-  if (isResponse(resource)) {
-    const response = resource;
-    return response.url;
+  if ((0, import_loader_utils.isResponse)(resource)) {
+    return resource.url;
   }
-  if (isBlob(resource)) {
-    const blob = resource;
-    return blob.name || "";
+  if ((0, import_loader_utils.isBlob)(resource)) {
+    const fileName = "name" in resource ? resource.name : "";
+    return fileName || "";
   }
   if (typeof resource === "string") {
     return resource;
@@ -176,15 +162,13 @@ function getResourceUrl(resource) {
   return "";
 }
 function getResourceMIMEType(resource) {
-  if (isResponse(resource)) {
-    const response = resource;
-    const contentTypeHeader = response.headers.get("content-type") || "";
-    const noQueryUrl = stripQueryString(response.url);
+  if ((0, import_loader_utils.isResponse)(resource)) {
+    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 || "";
+  if ((0, import_loader_utils.isBlob)(resource)) {
+    return resource.type || "";
   }
   if (typeof resource === "string") {
     return parseMIMETypeFromURL(resource);
@@ -192,11 +176,11 @@ function getResourceMIMEType(resource) {
   return "";
 }
 function getResourceContentLength(resource) {
-  if (isResponse(resource)) {
+  if ((0, import_loader_utils.isResponse)(resource)) {
     const response = resource;
     return response.headers["content-length"] || -1;
   }
-  if (isBlob(resource)) {
+  if ((0, import_loader_utils.isBlob)(resource)) {
     const blob = resource;
     return blob.size;
   }
@@ -214,7 +198,7 @@ function getResourceContentLength(resource) {
 
 // dist/lib/utils/response-utils.js
 async function makeResponse(resource) {
-  if (isResponse(resource)) {
+  if ((0, import_loader_utils2.isResponse)(resource)) {
     return resource;
   }
   const headers = {};
@@ -305,7 +289,7 @@ function isDataURL(url) {
 async function fetchFile(urlOrData, fetchOptions) {
   var _a, _b;
   if (typeof urlOrData === "string") {
-    const url = (0, import_loader_utils.resolvePath)(urlOrData);
+    const url = (0, import_loader_utils3.resolvePath)(urlOrData);
     if (isNodePath(url)) {
       if ((_a = globalThis.loaders) == null ? void 0 : _a.fetchNode) {
         return (_b = globalThis.loaders) == null ? void 0 : _b.fetchNode(url, fetchOptions);
@@ -337,7 +321,7 @@ async function readBlob(blob) {
 }
 
 // dist/lib/loader-utils/option-utils.js
-var import_loader_utils3 = require("@loaders.gl/loader-utils");
+var import_loader_utils5 = require("@loaders.gl/loader-utils");
 
 // dist/lib/loader-utils/loggers.js
 var import_log = require("@probe.gl/log");
@@ -380,41 +364,70 @@ var ConsoleLog = class {
 };
 
 // dist/lib/loader-utils/option-defaults.js
-var import_loader_utils2 = require("@loaders.gl/loader-utils");
+var import_loader_utils4 = require("@loaders.gl/loader-utils");
 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: import_loader_utils2.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: import_loader_utils4.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",
@@ -430,6 +443,29 @@ var REMOVED_LOADER_OPTIONS = {
 };
 
 // dist/lib/loader-utils/option-utils.js
+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;
@@ -440,20 +476,36 @@ function getGlobalLoaderState() {
 }
 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();
   const globalOptions = getGlobalLoaderOptions();
   state.globalOptions = normalizeOptionsInternal(globalOptions, options);
-  (0, import_loader_utils3.registerJSModules)(options.modules);
+  (0, import_loader_utils5.registerJSModules)(options.modules);
 }
 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);
@@ -468,7 +520,7 @@ function validateOptionsObject(options, id, defaultOptions, deprecatedOptions, l
   const loaderName = id || "Top level";
   const prefix = id ? `${id}.` : "";
   for (const key in options) {
-    const isSubOptions = !id && isObject(options[key]);
+    const isSubOptions = !id && (0, import_loader_utils5.isObject)(options[key]);
     const isBaseUriOption = key === "baseUri" && !id;
     const isWorkerUrlOption = key === "workerUrl" && id;
     if (!(key in defaultOptions) && !isBaseUriOption && !isWorkerUrlOption) {
@@ -499,21 +551,28 @@ function findSimilarOption(optionKey, loaders) {
   return bestSuggestion;
 }
 function normalizeOptionsInternal(loader, options, url) {
+  var _a;
   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 };
+  }
+  moveDeprecatedTopLevelOptionsToCore(mergedOptions);
+  if (((_a = mergedOptions.core) == null ? void 0 : _a.log) === null) {
+    mergedOptions.core = { ...mergedOptions.core, log: new NullLog() };
   }
-  mergeNestedFields(mergedOptions, getGlobalLoaderOptions());
-  mergeNestedFields(mergedOptions, options);
+  mergeNestedFields(mergedOptions, normalizeLoaderOptions(getGlobalLoaderOptions()));
+  const userOptions = normalizeLoaderOptions(options);
+  mergeNestedFields(mergedOptions, userOptions);
+  addUrlOptions(mergedOptions, url);
+  addDeprecatedTopLevelOptions(mergedOptions);
   return mergedOptions;
 }
 function mergeNestedFields(mergedOptions, options) {
   for (const key in options) {
     if (key in options) {
       const value = options[key];
-      if (isPureObject(value) && isPureObject(mergedOptions[key])) {
+      if ((0, import_loader_utils5.isPureObject)(value) && (0, import_loader_utils5.isPureObject)(mergedOptions[key])) {
         mergedOptions[key] = {
           ...mergedOptions[key],
           ...options[key]
@@ -525,13 +584,56 @@ function mergeNestedFields(mergedOptions, options) {
   }
 }
 function addUrlOptions(options, url) {
-  if (url && !("baseUri" in options)) {
-    options.baseUri = url;
+  var _a;
+  if (!url) {
+    return;
+  }
+  const hasTopLevelBaseUri = options.baseUri !== void 0;
+  const hasCoreBaseUri = ((_a = options.core) == null ? void 0 : _a.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];
+    }
   }
 }
 
 // dist/lib/loader-utils/normalize-loader.js
-var import_loader_utils4 = require("@loaders.gl/loader-utils");
+var import_loader_utils6 = require("@loaders.gl/loader-utils");
 function isLoaderObject(loader) {
   if (!loader) {
     return false;
@@ -543,8 +645,8 @@ function isLoaderObject(loader) {
   return hasExtensions;
 }
 function normalizeLoader(loader) {
-  (0, import_loader_utils4.assert)(loader, "null loader");
-  (0, import_loader_utils4.assert)(isLoaderObject(loader), "invalid loader");
+  (0, import_loader_utils6.assert)(loader, "null loader");
+  (0, import_loader_utils6.assert)(isLoaderObject(loader), "invalid loader");
   let options;
   if (Array.isArray(loader)) {
     options = loader[1];
@@ -588,21 +690,23 @@ function _unregisterLoaders() {
 }
 
 // dist/lib/api/select-loader.js
-var import_loader_utils5 = require("@loaders.gl/loader-utils");
+var import_loader_utils7 = require("@loaders.gl/loader-utils");
 var EXT_PATTERN = /\.([^.]+)$/;
 async function selectLoader(data, loaders = [], options, context) {
   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)) {
+  if ((0, import_loader_utils7.isBlob)(data)) {
     data = await data.slice(0, 10).arrayBuffer();
-    loader = selectLoaderSync(data, loaders, options, context);
+    loader = selectLoaderSync(data, loaders, normalizedOptions, context);
   }
-  if (!loader && !(options == null ? void 0 : options.nothrow)) {
+  if (!loader && !normalizedOptions.core.nothrow) {
     throw new Error(getNoValidLoaderMessage(data));
   }
   return loader;
@@ -611,6 +715,8 @@ function selectLoaderSync(data, loaders = [], options, context) {
   if (!validHTTPResponse(data)) {
     return null;
   }
+  const normalizedOptions = normalizeLoaderOptions(options || {});
+  normalizedOptions.core ||= {};
   if (loaders && !Array.isArray(loaders)) {
     return normalizeLoader(loaders);
   }
@@ -618,25 +724,26 @@ function selectLoaderSync(data, loaders = [], options, context) {
   if (loaders) {
     candidateLoaders = candidateLoaders.concat(loaders);
   }
-  if (!(options == null ? void 0 : options.ignoreRegisteredLoaders)) {
+  if (!normalizedOptions.core.ignoreRegisteredLoaders) {
     candidateLoaders.push(...getRegisteredLoaders());
   }
   normalizeLoaders(candidateLoaders);
-  const loader = selectLoaderInternal(data, candidateLoaders, options, context);
-  if (!loader && !(options == null ? void 0 : options.nothrow)) {
+  const loader = selectLoaderInternal(data, candidateLoaders, normalizedOptions, context);
+  if (!loader && !normalizedOptions.core.nothrow) {
     throw new Error(getNoValidLoaderMessage(data));
   }
   return loader;
 }
 function selectLoaderInternal(data, loaders, options, context) {
+  var _a, _b, _c, _d, _e;
   const url = getResourceUrl(data);
   const type = getResourceMIMEType(data);
   const testUrl = stripQueryString(url) || (context == null ? void 0 : context.url);
   let loader = null;
   let reason = "";
-  if (options == null ? void 0 : options.mimeType) {
-    loader = findLoaderByMIMEType(loaders, options == null ? void 0 : options.mimeType);
-    reason = `match forced by supplied MIME type ${options == null ? void 0 : options.mimeType}`;
+  if ((_a = options == null ? void 0 : options.core) == null ? void 0 : _a.mimeType) {
+    loader = findLoaderByMIMEType(loaders, (_b = options == null ? void 0 : options.core) == null ? void 0 : _b.mimeType);
+    reason = `match forced by supplied MIME type ${(_c = options == null ? void 0 : options.core) == null ? void 0 : _c.mimeType}`;
   }
   loader = loader || findLoaderByUrl(loaders, testUrl);
   reason = reason || (loader ? `matched url ${testUrl}` : "");
@@ -644,12 +751,12 @@ function selectLoaderInternal(data, loaders, options, context) {
   reason = reason || (loader ? `matched MIME type ${type}` : "");
   loader = loader || findLoaderByInitialBytes(loaders, data);
   reason = reason || (loader ? `matched initial data ${getFirstCharacters(data)}` : "");
-  if (options == null ? void 0 : options.fallbackMimeType) {
-    loader = loader || findLoaderByMIMEType(loaders, options == null ? void 0 : options.fallbackMimeType);
+  if ((_d = options == null ? void 0 : options.core) == null ? void 0 : _d.fallbackMimeType) {
+    loader = loader || findLoaderByMIMEType(loaders, (_e = options == null ? void 0 : options.core) == null ? void 0 : _e.fallbackMimeType);
     reason = reason || (loader ? `matched fallback MIME type ${type}` : "");
   }
   if (reason) {
-    import_loader_utils5.log.log(1, `selectLoader selected ${loader == null ? void 0 : loader.name}: ${reason}.`);
+    import_loader_utils7.log.log(1, `selectLoader selected ${loader == null ? void 0 : loader.name}: ${reason}.`);
   }
   return loader;
 }
@@ -665,7 +772,7 @@ function getNoValidLoaderMessage(data) {
   const url = getResourceUrl(data);
   const type = getResourceMIMEType(data);
   let message = "No valid loader found (";
-  message += url ? `${import_loader_utils5.path.filename(url)}, ` : "no url provided, ";
+  message += url ? `${import_loader_utils7.path.filename(url)}, ` : "no url provided, ";
   message += `MIME type: ${type ? `"${type}"` : "not provided"}, `;
   const firstCharacters = data ? getFirstCharacters(data) : "";
   message += firstCharacters ? ` first bytes: "${firstCharacters}"` : "first bytes: not available";
@@ -739,12 +846,12 @@ function testDataAgainstBinary(data, byteOffset, loader) {
   return tests.some((test) => testBinary(data, byteOffset, loader, test));
 }
 function testBinary(data, byteOffset, loader, test) {
-  if (test instanceof ArrayBuffer) {
-    return (0, import_loader_utils5.compareArrayBuffers)(test, data, test.byteLength);
+  if ((0, import_loader_utils7.isArrayBufferLike)(test)) {
+    return (0, import_loader_utils7.compareArrayBuffers)(test, data, test.byteLength);
   }
   switch (typeof test) {
     case "function":
-      return test(data);
+      return test((0, import_loader_utils7.ensureArrayBuffer)(data));
     case "string":
       const magic = getMagicString(data, byteOffset, test.length);
       return test === magic;
@@ -776,13 +883,14 @@ function getMagicString(arrayBuffer, byteOffset, length) {
 }
 
 // dist/lib/api/parse.js
-var import_loader_utils9 = require("@loaders.gl/loader-utils");
+var import_loader_utils14 = require("@loaders.gl/loader-utils");
 var import_worker_utils = require("@loaders.gl/worker-utils");
 
 // dist/lib/loader-utils/get-data.js
-var import_loader_utils7 = require("@loaders.gl/loader-utils");
+var import_loader_utils11 = require("@loaders.gl/loader-utils");
 
 // dist/iterators/make-iterator/make-string-iterator.js
+var import_loader_utils8 = require("@loaders.gl/loader-utils");
 var DEFAULT_CHUNK_SIZE = 256 * 1024;
 function* makeStringIterator(string, options) {
   const chunkSize = (options == null ? void 0 : options.chunkSize) || DEFAULT_CHUNK_SIZE;
@@ -792,7 +900,7 @@ function* makeStringIterator(string, options) {
     const chunkLength = Math.min(string.length - offset, chunkSize);
     const chunk = string.slice(offset, offset + chunkLength);
     offset += chunkLength;
-    yield textEncoder.encode(chunk);
+    yield (0, import_loader_utils8.ensureArrayBuffer)(textEncoder.encode(chunk));
   }
 }
 
@@ -826,9 +934,9 @@ async function* makeBlobIterator(blob, options) {
 }
 
 // dist/iterators/make-iterator/make-stream-iterator.js
-var import_loader_utils6 = require("@loaders.gl/loader-utils");
+var import_loader_utils9 = require("@loaders.gl/loader-utils");
 function makeStreamIterator(stream, options) {
-  return import_loader_utils6.isBrowser ? makeBrowserStreamIterator(stream, options) : makeNodeStreamIterator(stream, options);
+  return import_loader_utils9.isBrowser ? makeBrowserStreamIterator(stream, options) : makeNodeStreamIterator(stream, options);
 }
 async function* makeBrowserStreamIterator(stream, options) {
   const reader = stream.getReader();
@@ -843,7 +951,7 @@ async function* makeBrowserStreamIterator(stream, options) {
       if (done) {
         return;
       }
-      yield (0, import_loader_utils6.toArrayBuffer)(value);
+      yield (0, import_loader_utils9.toArrayBuffer)(value);
     }
   } catch (error) {
     reader.releaseLock();
@@ -851,11 +959,12 @@ async function* makeBrowserStreamIterator(stream, options) {
 }
 async function* makeNodeStreamIterator(stream, options) {
   for await (const chunk of stream) {
-    yield (0, import_loader_utils6.toArrayBuffer)(chunk);
+    yield (0, import_loader_utils9.toArrayBuffer)(chunk);
   }
 }
 
 // dist/iterators/make-iterator/make-iterator.js
+var import_loader_utils10 = require("@loaders.gl/loader-utils");
 function makeIterator(data, options) {
   if (typeof data === "string") {
     return makeStringIterator(data, options);
@@ -863,15 +972,18 @@ function makeIterator(data, options) {
   if (data instanceof ArrayBuffer) {
     return makeArrayBufferIterator(data, options);
   }
-  if (isBlob(data)) {
+  if ((0, import_loader_utils10.isBlob)(data)) {
     return makeBlobIterator(data, options);
   }
-  if (isReadableStream(data)) {
+  if ((0, import_loader_utils10.isReadableStream)(data)) {
     return makeStreamIterator(data, options);
   }
-  if (isResponse(data)) {
-    const response = data;
-    return makeStreamIterator(response.body, options);
+  if ((0, import_loader_utils10.isResponse)(data)) {
+    const responseBody = data.body;
+    if (!responseBody) {
+      throw new Error("Readable stream not available on Response");
+    }
+    return makeStreamIterator(responseBody, options);
   }
   throw new Error("makeIterator");
 }
@@ -882,66 +994,60 @@ function getArrayBufferOrStringFromDataSync(data, loader, options) {
   if (loader.text && typeof data === "string") {
     return data;
   }
-  if (isBuffer(data)) {
+  if ((0, import_loader_utils11.isBuffer)(data)) {
     data = data.buffer;
   }
-  if (data instanceof ArrayBuffer) {
-    const arrayBuffer = data;
+  if ((0, import_loader_utils11.isArrayBufferLike)(data)) {
+    const bufferSource = (0, import_loader_utils11.toArrayBufferView)(data);
     if (loader.text && !loader.binary) {
       const textDecoder = new TextDecoder("utf8");
-      return textDecoder.decode(arrayBuffer);
+      return textDecoder.decode(bufferSource);
     }
-    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 arrayBuffer;
+    return (0, import_loader_utils11.toArrayBuffer)(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" || (0, import_loader_utils11.isArrayBufferLike)(data)) {
     return getArrayBufferOrStringFromDataSync(data, loader, options);
   }
-  if (isBlob(data)) {
+  if ((0, import_loader_utils11.isBlob)(data)) {
     data = await makeResponse(data);
   }
-  if (isResponse(data)) {
-    const response = data;
-    await checkResponse(response);
-    return loader.binary ? await response.arrayBuffer() : await response.text();
+  if ((0, import_loader_utils11.isResponse)(data)) {
+    await checkResponse(data);
+    return loader.binary ? await data.arrayBuffer() : await data.text();
   }
-  if (isReadableStream(data)) {
+  if ((0, import_loader_utils11.isReadableStream)(data)) {
     data = makeIterator(data, options);
   }
-  if (isIterable(data) || isAsyncIterable(data)) {
-    return (0, import_loader_utils7.concatenateArrayBuffersAsync)(data);
+  if ((0, import_loader_utils11.isIterable)(data) || (0, import_loader_utils11.isAsyncIterable)(data)) {
+    return (0, import_loader_utils11.concatenateArrayBuffersAsync)(data);
   }
   throw new Error(ERR_DATA);
 }
 async function getAsyncIterableFromData(data, options) {
-  if (isIterator(data)) {
+  if ((0, import_loader_utils11.isPromise)(data)) {
+    data = await data;
+  }
+  if ((0, import_loader_utils11.isIterator)(data)) {
     return data;
   }
-  if (isResponse(data)) {
-    const response = data;
-    await checkResponse(response);
-    const body = await response.body;
+  if ((0, import_loader_utils11.isResponse)(data)) {
+    await checkResponse(data);
+    const body = await data.body;
+    if (!body) {
+      throw new Error(ERR_DATA);
+    }
     return makeIterator(body, options);
   }
-  if (isBlob(data) || isReadableStream(data)) {
+  if ((0, import_loader_utils11.isBlob)(data) || (0, import_loader_utils11.isReadableStream)(data)) {
     return makeIterator(data, options);
   }
-  if (isAsyncIterable(data)) {
+  if ((0, import_loader_utils11.isAsyncIterable)(data)) {
+    return data;
+  }
+  if ((0, import_loader_utils11.isIterable)(data)) {
     return data;
   }
   return getIterableFromData(data);
@@ -949,32 +1055,35 @@ async function getAsyncIterableFromData(data, options) {
 function getIterableFromData(data) {
   if (ArrayBuffer.isView(data)) {
     return function* oneChunk() {
-      yield data.buffer;
+      yield (0, import_loader_utils11.toArrayBuffer)(data);
     }();
   }
-  if (data instanceof ArrayBuffer) {
+  if ((0, import_loader_utils11.isArrayBufferLike)(data)) {
     return function* oneChunk() {
-      yield data;
+      yield (0, import_loader_utils11.toArrayBuffer)(data);
     }();
   }
-  if (isIterator(data)) {
+  if ((0, import_loader_utils11.isIterator)(data)) {
     return data;
   }
-  if (isIterable(data)) {
+  if ((0, import_loader_utils11.isIterable)(data)) {
     return data[Symbol.iterator]();
   }
   throw new Error(ERR_DATA);
 }
 
 // dist/lib/loader-utils/get-fetch-function.js
+var import_loader_utils12 = require("@loaders.gl/loader-utils");
 function getFetchFunction(options, context) {
+  var _a;
   const globalOptions = getGlobalLoaderOptions();
   const loaderOptions = options || globalOptions;
-  if (typeof loaderOptions.fetch === "function") {
-    return loaderOptions.fetch;
+  const fetchOption = loaderOptions.fetch ?? ((_a = loaderOptions.core) == null ? void 0 : _a.fetch);
+  if (typeof fetchOption === "function") {
+    return fetchOption;
   }
-  if (isObject(loaderOptions.fetch)) {
-    return (url) => fetchFile(url, loaderOptions.fetch);
+  if ((0, import_loader_utils12.isObject)(fetchOption)) {
+    return (url) => fetchFile(url, fetchOption);
   }
   if (context == null ? void 0 : context.fetch) {
     return context == null ? void 0 : context.fetch;
@@ -983,7 +1092,7 @@ function getFetchFunction(options, context) {
 }
 
 // dist/lib/loader-utils/loader-context.js
-var import_loader_utils8 = require("@loaders.gl/loader-utils");
+var import_loader_utils13 = require("@loaders.gl/loader-utils");
 function getLoaderContext(context, options, parentContext) {
   if (parentContext) {
     return parentContext;
@@ -996,8 +1105,8 @@ function getLoaderContext(context, options, parentContext) {
     const baseUrl = stripQueryString(newContext.url);
     newContext.baseUrl = baseUrl;
     newContext.queryString = extractQueryString(newContext.url);
-    newContext.filename = import_loader_utils8.path.filename(baseUrl);
-    newContext.baseUrl = import_loader_utils8.path.dirname(baseUrl);
+    newContext.filename = import_loader_utils13.path.filename(baseUrl);
+    newContext.baseUrl = import_loader_utils13.path.dirname(baseUrl);
   }
   if (!Array.isArray(newContext.loaders)) {
     newContext.loaders = null;
@@ -1035,22 +1144,21 @@ async function parse(data, loaders, options, context) {
   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) {
   (0, import_worker_utils.validateWorkerVersion)(loader);
-  options = (0, import_loader_utils9.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());
+  options = (0, import_loader_utils14.mergeOptions)(loader.options, options);
+  if ((0, import_loader_utils14.isResponse)(data)) {
+    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);
@@ -1058,8 +1166,8 @@ async function parseWithLoader(loader, data, options, context) {
   if (loaderWithParser.parseTextSync && typeof data === "string") {
     return loaderWithParser.parseTextSync(data, options, context);
   }
-  if ((0, import_loader_utils9.canParseWithWorker)(loader, options)) {
-    return await (0, import_loader_utils9.parseWithWorker)(loader, data, options, context, parse);
+  if ((0, import_loader_utils14.canParseWithWorker)(loader, options)) {
+    return await (0, import_loader_utils14.parseWithWorker)(loader, data, options, context, parse);
   }
   if (loaderWithParser.parseText && typeof data === "string") {
     return await loaderWithParser.parseText(data, options, context);
@@ -1085,13 +1193,13 @@ function parseSync(data, loaders, options, context) {
   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, context || null);
-  return parseWithLoaderSync(loader, data, options, context);
+  context = getLoaderContext({ url, _parseSync: parse2, _parse: parse2, loaders }, strictOptions, context || null);
+  return parseWithLoaderSync(loader, data, strictOptions, context);
 }
 function parseWithLoaderSync(loader, data, options, context) {
   data = getArrayBufferOrStringFromDataSync(data, loader, options);
@@ -1106,7 +1214,7 @@ function parseWithLoaderSync(loader, data, options, context) {
 
 // dist/lib/api/parse-in-batches.js
 var import_schema_utils = require("@loaders.gl/schema-utils");
-var import_loader_utils10 = require("@loaders.gl/loader-utils");
+var import_loader_utils15 = require("@loaders.gl/loader-utils");
 async function parseInBatches(data, loaders, options, context) {
   const loaderArray = Array.isArray(loaders) ? loaders : void 0;
   if (!Array.isArray(loaders) && !isLoaderObject(loaders)) {
@@ -1121,13 +1229,14 @@ async function parseInBatches(data, loaders, options, context) {
   if (!loader) {
     return [];
   }
-  options = normalizeOptions(options, loader, loaderArray, url);
-  context = getLoaderContext({ url, _parseInBatches: parseInBatches, _parse: parse, loaders: loaderArray }, options, context || null);
-  return await parseWithLoaderInBatches(loader, data, options, context);
+  const strictOptions = normalizeOptions(options, loader, loaderArray, url);
+  context = getLoaderContext({ url, _parseInBatches: parseInBatches, _parse: parse, loaders: loaderArray }, strictOptions, context || null);
+  return await parseWithLoaderInBatches(loader, data, strictOptions, context);
 }
 async function parseWithLoaderInBatches(loader, data, options, context) {
+  var _a;
   const outputIterator = await parseToOutputIterator(loader, data, options, context);
-  if (!options.metadata) {
+  if (!((_a = options == null ? void 0 : options.core) == null ? void 0 : _a.metadata)) {
     return outputIterator;
   }
   const metadataBatch = {
@@ -1148,20 +1257,21 @@ async function parseWithLoaderInBatches(loader, data, options, context) {
   return makeMetadataBatchIterator(outputIterator);
 }
 async function parseToOutputIterator(loader, data, options, context) {
+  var _a;
   const inputIterator = await getAsyncIterableFromData(data, options);
-  const transformedIterator = await applyInputTransforms(inputIterator, (options == null ? void 0 : options.transforms) || []);
+  const transformedIterator = await applyInputTransforms(inputIterator, ((_a = options == null ? void 0 : options.core) == null ? void 0 : _a.transforms) || []);
   if (loader.parseInBatches) {
     return loader.parseInBatches(transformedIterator, options, context);
   }
   return parseChunkInBatches(transformedIterator, loader, options, context);
 }
 async function* parseChunkInBatches(transformedIterator, loader, options, context) {
-  const arrayBuffer = await (0, import_loader_utils10.concatenateArrayBuffersAsync)(transformedIterator);
+  const arrayBuffer = await (0, import_loader_utils15.concatenateArrayBuffersAsync)(transformedIterator);
   const parsedData = await parse(
     arrayBuffer,
     loader,
     // TODO - Hack: supply loaders MIME type to ensure we match it
-    { ...options, mimeType: loader.mimeTypes[0] },
+    { ...options, core: { ...options == null ? void 0 : options.core, mimeType: loader.mimeTypes[0] } },
     context
   );
   const batch = convertDataToBatch(parsedData, loader);
@@ -1186,6 +1296,7 @@ async function applyInputTransforms(inputIterator, transforms = []) {
 }
 
 // dist/lib/api/load.js
+var import_loader_utils16 = require("@loaders.gl/loader-utils");
 async function load(url, loaders, options, context) {
   let resolvedLoaders;
   let resolvedOptions;
@@ -1202,7 +1313,7 @@ async function load(url, loaders, options, context) {
   if (typeof url === "string") {
     data = await fetch2(url);
   }
-  if (isBlob(url)) {
+  if ((0, import_loader_utils16.isBlob)(url)) {
     data = await fetch2(url);
   }
   return Array.isArray(resolvedLoaders) ? await parse(data, resolvedLoaders, resolvedOptions) : await parse(data, resolvedLoaders, resolvedOptions);
@@ -1235,14 +1346,14 @@ async function loadOneFileInBatches(file, loaders, options, fetch2) {
 }
 
 // dist/lib/api/encode-table.js
-var import_loader_utils11 = require("@loaders.gl/loader-utils");
+var import_loader_utils17 = require("@loaders.gl/loader-utils");
 async function encodeTable(data, writer, options) {
   if (writer.encode) {
     return await writer.encode(data, options);
   }
   if (writer.encodeText) {
     const text = await writer.encodeText(data, options);
-    return new TextEncoder().encode(text);
+    return (0, import_loader_utils17.ensureArrayBuffer)(new TextEncoder().encode(text));
   }
   if (writer.encodeInBatches) {
     const batches = encodeTableInBatches(data, writer, options);
@@ -1250,7 +1361,7 @@ async function encodeTable(data, writer, options) {
     for await (const batch of batches) {
       chunks.push(batch);
     }
-    return (0, import_loader_utils11.concatenateArrayBuffers)(...chunks);
+    return (0, import_loader_utils17.concatenateArrayBuffers)(...chunks);
   }
   throw new Error("Writer could not encode data");
 }
@@ -1277,7 +1388,7 @@ function getIterator(data) {
 }
 
 // dist/lib/api/encode.js
-var import_loader_utils12 = require("@loaders.gl/loader-utils");
+var import_loader_utils18 = require("@loaders.gl/loader-utils");
 var import_worker_utils2 = require("@loaders.gl/worker-utils");
 async function encode(data, writer, options_) {
   const globalOptions = getGlobalLoaderOptions();
@@ -1285,7 +1396,7 @@ async function encode(data, writer, options_) {
   if (writer.encodeURLtoURL) {
     return encodeWithCommandLineTool(writer, data, options);
   }
-  if ((0, import_loader_utils12.canEncodeWithWorker)(writer, options)) {
+  if ((0, import_loader_utils18.canEncodeWithWorker)(writer, options)) {
     return await (0, import_worker_utils2.processOnWorker)(writer, data, options);
   }
   return await writer.encode(data, options);
@@ -1295,7 +1406,7 @@ function encodeSync(data, writer, options) {
     return writer.encodeSync(data, options);
   }
   if (writer.encodeTextSync) {
-    return new TextEncoder().encode(writer.encodeTextSync(data, options));
+    return (0, import_loader_utils18.ensureArrayBuffer)(new TextEncoder().encode(writer.encodeTextSync(data, options)));
   }
   throw new Error(`Writer ${writer.name} could not synchronously encode data`);
 }
@@ -1330,20 +1441,20 @@ function encodeInBatches(data, writer, options) {
   throw new Error(`Writer ${writer.name} could not encode in batches`);
 }
 async function encodeURLtoURL(inputUrl, outputUrl, writer, options) {
-  inputUrl = (0, import_loader_utils12.resolvePath)(inputUrl);
-  outputUrl = (0, import_loader_utils12.resolvePath)(outputUrl);
-  if (import_loader_utils12.isBrowser || !writer.encodeURLtoURL) {
+  inputUrl = (0, import_loader_utils18.resolvePath)(inputUrl);
+  outputUrl = (0, import_loader_utils18.resolvePath)(outputUrl);
+  if (import_loader_utils18.isBrowser || !writer.encodeURLtoURL) {
     throw new Error();
   }
   const outputFilename = await writer.encodeURLtoURL(inputUrl, outputUrl, options);
   return outputFilename;
 }
 async function encodeWithCommandLineTool(writer, data, options) {
-  if (import_loader_utils12.isBrowser) {
+  if (import_loader_utils18.isBrowser) {
     throw new Error(`Writer ${writer.name} not supported in browser`);
   }
   const tmpInputFilename = getTemporaryFilename("input");
-  const file = new import_loader_utils12.NodeFile(tmpInputFilename, "w");
+  const file = new import_loader_utils18.NodeFile(tmpInputFilename, "w");
   await file.write(data);
   const tmpOutputFilename = getTemporaryFilename("output");
   const outputFilename = await encodeURLtoURL(tmpInputFilename, tmpOutputFilename, writer, options);
@@ -1413,8 +1524,8 @@ function getSourceOfType2(type, sources) {
 }
 
 // dist/index.js
-var import_loader_utils14 = require("@loaders.gl/loader-utils");
-var import_loader_utils15 = require("@loaders.gl/loader-utils");
+var import_loader_utils20 = require("@loaders.gl/loader-utils");
+var import_loader_utils21 = require("@loaders.gl/loader-utils");
 
 // dist/iterators/make-stream/make-stream.js
 function makeStream(source, options) {
@@ -1456,7 +1567,7 @@ function makeStream(source, options) {
 }
 
 // dist/null-loader.js
-var VERSION = true ? "4.4.0-alpha.1" : "latest";
+var VERSION = true ? "4.4.0-alpha.9" : "latest";
 var NullWorkerLoader = {
   dataType: null,
   batchType: null,
@@ -1498,7 +1609,7 @@ function parseSync2(arrayBuffer, options, context) {
 }
 
 // dist/index.js
-var import_loader_utils16 = require("@loaders.gl/loader-utils");
+var import_loader_utils22 = require("@loaders.gl/loader-utils");
 
 // dist/lib/progress/fetch-progress.js
 async function fetchProgress(response, onProgress, onDone = () => {
@@ -1548,7 +1659,7 @@ async function read(controller, reader, loadedBytes, totalBytes, onProgress, onD
 }
 
 // dist/lib/filesystems/browser-filesystem.js
-var import_loader_utils13 = require("@loaders.gl/loader-utils");
+var import_loader_utils19 = require("@loaders.gl/loader-utils");
 var BrowserFileSystem = class {
   _fetch;
   files = {};
@@ -1630,7 +1741,7 @@ var BrowserFileSystem = class {
   // implements IRandomAccessFileSystem
   // RANDOM ACCESS
   async openReadableFile(pathname, flags) {
-    return new import_loader_utils13.BlobFile(this.files[pathname]);
+    return new import_loader_utils19.BlobFile(this.files[pathname]);
   }
   // PRIVATE
   // Supports case independent paths, and file usage tracking
@@ -1644,8 +1755,9 @@ var BrowserFileSystem = class {
 };
 
 // dist/index.js
-var import_loader_utils17 = require("@loaders.gl/loader-utils");
-var import_loader_utils18 = require("@loaders.gl/loader-utils");
-var import_loader_utils19 = require("@loaders.gl/loader-utils");
-var import_loader_utils20 = require("@loaders.gl/loader-utils");
+var import_loader_utils23 = require("@loaders.gl/loader-utils");
+var import_loader_utils24 = require("@loaders.gl/loader-utils");
+var import_loader_utils25 = require("@loaders.gl/loader-utils");
+var import_loader_utils26 = require("@loaders.gl/loader-utils");
+var import_loader_utils27 = require("@loaders.gl/loader-utils");
 //# sourceMappingURL=index.cjs.map