@loaders.gl/core 5.0.0-alpha.1 → 5.0.0-alpha.3

package/dist/index.cjs

@@ -18,22 +18,22 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // dist/index.js
-var dist_exports = {};
-__export(dist_exports, {
+var index_exports = {};
+__export(index_exports, {
   FetchError: () => FetchError,
-  JSONLoader: () => import_loader_utils24.JSONLoader,
+  JSONLoader: () => JSONLoader,
   NullLoader: () => NullLoader,
   NullWorkerLoader: () => NullWorkerLoader,
-  RequestScheduler: () => import_loader_utils23.RequestScheduler,
+  RequestScheduler: () => RequestScheduler,
   _BrowserFileSystem: () => BrowserFileSystem,
   _fetchProgress: () => fetchProgress,
   _selectSource: () => selectSource,
   _unregisterLoaders: () => _unregisterLoaders,
-  assert: () => import_loader_utils26.assert,
-  concatenateArrayBuffersAsync: () => import_loader_utils27.concatenateArrayBuffersAsync,
+  assert: () => assert,
+  concatenateArrayBuffersAsync: () => concatenateArrayBuffersAsync,
   coreApi: () => coreApi,
   createDataSource: () => createDataSource,
-  document: () => import_loader_utils25.document,
+  document: () => document_,
   encode: () => encode,
   encodeInBatches: () => encodeInBatches,
   encodeSync: () => encodeSync,
@@ -44,28 +44,28 @@ __export(dist_exports, {
   encodeTextSync: () => encodeTextSync,
   encodeURLtoURL: () => encodeURLtoURL,
   fetchFile: () => fetchFile,
-  forEach: () => import_loader_utils27.forEach,
+  forEach: () => forEach,
   getLoaderOptions: () => getGlobalLoaderOptions,
-  getPathPrefix: () => import_loader_utils22.getPathPrefix,
-  global: () => import_loader_utils25.global,
-  isAsyncIterable: () => import_loader_utils29.isAsyncIterable,
-  isBrowser: () => import_loader_utils25.isBrowser,
-  isIterable: () => import_loader_utils29.isIterable,
-  isIterator: () => import_loader_utils29.isIterator,
-  isPromise: () => import_loader_utils29.isPromise,
-  isPureObject: () => import_loader_utils29.isPureObject,
-  isReadableStream: () => import_loader_utils29.isReadableStream,
-  isResponse: () => import_loader_utils29.isResponse,
-  isWorker: () => import_loader_utils25.isWorker,
-  isWritableStream: () => import_loader_utils29.isWritableStream,
+  getPathPrefix: () => getPathPrefix,
+  global: () => global_,
+  isAsyncIterable: () => isAsyncIterable,
+  isBrowser: () => isBrowser,
+  isIterable: () => isIterable,
+  isIterator: () => isIterator,
+  isPromise: () => isPromise,
+  isPureObject: () => isPureObject,
+  isReadableStream: () => isReadableStream,
+  isResponse: () => isResponse,
+  isWorker: () => isWorker,
+  isWritableStream: () => isWritableStream,
   load: () => load,
   loadInBatches: () => loadInBatches,
   makeIterator: () => makeIterator,
-  makeLineIterator: () => import_loader_utils28.makeLineIterator,
-  makeNumberedLineIterator: () => import_loader_utils28.makeNumberedLineIterator,
+  makeLineIterator: () => makeLineIterator,
+  makeNumberedLineIterator: () => makeNumberedLineIterator,
   makeStream: () => makeStream,
-  makeTextDecoderIterator: () => import_loader_utils28.makeTextDecoderIterator,
-  makeTextEncoderIterator: () => import_loader_utils28.makeTextEncoderIterator,
+  makeTextDecoderIterator: () => makeTextDecoderIterator,
+  makeTextEncoderIterator: () => makeTextEncoderIterator,
   parse: () => parse,
   parseFile: () => parseFile,
   parseInBatches: () => parseInBatches,
@@ -74,21 +74,1645 @@ __export(dist_exports, {
   preloadSync: () => preloadSync,
   readArrayBuffer: () => readArrayBuffer,
   registerLoaders: () => registerLoaders,
-  resolvePath: () => import_loader_utils22.resolvePath,
+  resolvePath: () => resolvePath,
   selectLoader: () => selectLoader,
   selectLoaderSync: () => selectLoaderSync,
-  self: () => import_loader_utils25.self,
+  self: () => self_,
   setLoaderOptions: () => setGlobalOptions,
-  setPathPrefix: () => import_loader_utils22.setPathPrefix,
-  window: () => import_loader_utils25.window
+  setPathPrefix: () => setPathPrefix,
+  window: () => window_
 });
-module.exports = __toCommonJS(dist_exports);
+module.exports = __toCommonJS(index_exports);
 
-// dist/lib/fetch/fetch-file.js
-var import_loader_utils3 = require("@loaders.gl/loader-utils");
+// ../loader-utils/src/lib/env-utils/assert.ts
+function assert(condition, message) {
+  if (!condition) {
+    throw new Error(message || "loader assertion failed.");
+  }
+}
 
-// dist/lib/utils/response-utils.js
-var import_loader_utils2 = require("@loaders.gl/loader-utils");
+// ../loader-utils/src/lib/env-utils/globals.ts
+var globals = {
+  self: typeof self !== "undefined" && self,
+  window: typeof window !== "undefined" && window,
+  global: typeof global !== "undefined" && global,
+  document: typeof document !== "undefined" && document
+};
+var self_ = globals.self || globals.window || globals.global || {};
+var window_ = globals.window || globals.self || globals.global || {};
+var global_ = globals.global || globals.self || globals.window || {};
+var document_ = globals.document || {};
+var isBrowser = (
+  // @ts-ignore process does not exist on browser
+  Boolean(typeof process !== "object" || String(process) !== "[object process]" || process.browser)
+);
+var isWorker = typeof importScripts === "function";
+var matches = typeof process !== "undefined" && process.version && /v([0-9]*)/.exec(process.version);
+var nodeVersion = matches && parseFloat(matches[1]) || 0;
+
+// ../loader-utils/src/lib/log-utils/log.ts
+var import_log = require("@probe.gl/log");
+var VERSION = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+var version = VERSION[0] >= "0" && VERSION[0] <= "9" ? `v${VERSION}` : "";
+function createLog() {
+  const log2 = new import_log.Log({ id: "loaders.gl" });
+  globalThis.loaders ||= {};
+  globalThis.loaders.log = log2;
+  globalThis.loaders.version = version;
+  globalThis.probe ||= {};
+  globalThis.probe.loaders = log2;
+  return log2;
+}
+var log = createLog();
+
+// ../loader-utils/src/lib/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);
+}
+function mergeOptionsRecursively(baseOptions, newOptions, level = 0) {
+  if (level > 3) {
+    return newOptions;
+  }
+  const options = { ...baseOptions };
+  for (const [key, newValue] of Object.entries(newOptions)) {
+    if (isPureObject(newValue)) {
+      options[key] = mergeOptionsRecursively(
+        options[key] || {},
+        newOptions[key],
+        level + 1
+      );
+    } else {
+      options[key] = newOptions[key];
+    }
+  }
+  return options;
+}
+
+// ../loader-utils/src/lib/module-utils/js-module-utils.ts
+function registerJSModules(modules) {
+  globalThis.loaders ||= {};
+  globalThis.loaders.modules ||= {};
+  Object.assign(globalThis.loaders.modules, modules);
+}
+
+// ../worker-utils/src/lib/npm-tag.ts
+var NPM_TAG = "latest";
+
+// ../worker-utils/src/lib/env-utils/version.ts
+function getVersion() {
+  var _a;
+  if (!((_a = globalThis._loadersgl_) == null ? void 0 : _a.version)) {
+    globalThis._loadersgl_ = globalThis._loadersgl_ || {};
+    if (typeof __VERSION__ === "undefined") {
+      globalThis._loadersgl_.version = NPM_TAG;
+    } else {
+      globalThis._loadersgl_.version = __VERSION__;
+    }
+  }
+  return globalThis._loadersgl_.version;
+}
+var VERSION2 = getVersion();
+
+// ../worker-utils/src/lib/env-utils/assert.ts
+function assert2(condition, message) {
+  if (!condition) {
+    throw new Error(message || "loaders.gl assertion failed.");
+  }
+}
+
+// ../worker-utils/src/lib/env-utils/globals.ts
+var globals2 = {
+  self: typeof self !== "undefined" && self,
+  window: typeof window !== "undefined" && window,
+  global: typeof global !== "undefined" && global,
+  document: typeof document !== "undefined" && document
+};
+var self_2 = globals2.self || globals2.window || globals2.global || {};
+var window_2 = globals2.window || globals2.self || globals2.global || {};
+var global_2 = globals2.global || globals2.self || globals2.window || {};
+var document_2 = globals2.document || {};
+var isBrowser2 = (
+  // @ts-ignore process.browser
+  typeof process !== "object" || String(process) !== "[object process]" || process.browser
+);
+var isMobile = typeof window !== "undefined" && typeof window.orientation !== "undefined";
+var matches2 = typeof process !== "undefined" && process.version && /v([0-9]*)/.exec(process.version);
+var nodeVersion2 = matches2 && parseFloat(matches2[1]) || 0;
+
+// ../worker-utils/src/lib/worker-farm/worker-job.ts
+var WorkerJob = class {
+  name;
+  workerThread;
+  isRunning = true;
+  /** Promise that resolves when Job is done */
+  result;
+  _resolve = () => {
+  };
+  _reject = () => {
+  };
+  constructor(jobName, workerThread) {
+    this.name = jobName;
+    this.workerThread = workerThread;
+    this.result = new Promise((resolve2, reject) => {
+      this._resolve = resolve2;
+      this._reject = reject;
+    });
+  }
+  /**
+   * Send a message to the job's worker thread
+   * @param data any data structure, ideally consisting mostly of transferrable objects
+   */
+  postMessage(type, payload) {
+    this.workerThread.postMessage({
+      source: "loaders.gl",
+      // Lets worker ignore unrelated messages
+      type,
+      payload
+    });
+  }
+  /**
+   * Call to resolve the `result` Promise with the supplied value
+   */
+  done(value) {
+    if (!this.isRunning) {
+      return;
+    }
+    this.isRunning = false;
+    this._resolve(value);
+  }
+  /**
+   * Call to reject the `result` Promise with the supplied error
+   */
+  error(error) {
+    if (!this.isRunning) {
+      return;
+    }
+    this.isRunning = false;
+    this._reject(error);
+  }
+  /**
+   * Terminates the worker executing this job and rejects its result.
+   * @param reason Abort reason supplied by the caller, or a cross-runtime `AbortError`.
+   */
+  abort(reason) {
+    if (!this.isRunning) {
+      return;
+    }
+    const error = reason ?? createAbortError(`Worker job "${this.name}" was aborted`);
+    this.workerThread.destroy();
+    this.error(error);
+  }
+};
+function createAbortError(message) {
+  const error = new Error(message);
+  error.name = "AbortError";
+  return error;
+}
+
+// ../worker-utils/src/lib/node/worker_threads-browser.ts
+var NodeWorker = class {
+  /** Restores the native worker constructor when this browser shim is embedded in a Node bundle. */
+  constructor(...arguments_) {
+    var _a;
+    const runtimeProcess = globalThis.process;
+    const WorkerConstructor = (_a = runtimeProcess == null ? void 0 : runtimeProcess.getBuiltinModule) == null ? void 0 : _a.call(runtimeProcess, "node:worker_threads").Worker;
+    if (WorkerConstructor) {
+      return new WorkerConstructor(...arguments_);
+    }
+  }
+  /** No-op browser fallback matching the native Worker API. */
+  terminate() {
+  }
+};
+
+// ../worker-utils/src/lib/worker-utils/get-loadable-worker-url.ts
+var workerURLCache = /* @__PURE__ */ new Map();
+function getLoadableWorkerURL(props) {
+  assert2(props.source && !props.url || !props.source && props.url);
+  let workerURL = workerURLCache.get(props.source || props.url);
+  if (!workerURL) {
+    if (props.url) {
+      workerURL = getLoadableWorkerURLFromURL(props.url);
+      workerURLCache.set(props.url, workerURL);
+    }
+    if (props.source) {
+      workerURL = getLoadableWorkerURLFromSource(props.source);
+      workerURLCache.set(props.source, workerURL);
+    }
+  }
+  assert2(workerURL);
+  return workerURL;
+}
+function getLoadableWorkerURLFromURL(url) {
+  if (!url.startsWith("http")) {
+    return url;
+  }
+  const workerSource = buildScriptSource(url);
+  return getLoadableWorkerURLFromSource(workerSource);
+}
+function getLoadableWorkerURLFromSource(workerSource) {
+  const blob = new Blob([workerSource], { type: "application/javascript" });
+  return URL.createObjectURL(blob);
+}
+function buildScriptSource(workerUrl) {
+  return `try {
+  importScripts('${workerUrl}');
+} catch (error) {
+  console.error(error);
+  throw error;
+}`;
+}
+
+// ../worker-utils/src/lib/worker-utils/get-transfer-list.ts
+function getTransferList(object, recursive = true, transfers) {
+  const transfersSet = transfers || /* @__PURE__ */ new Set();
+  if (!object) {
+  } else if (isTransferable(object)) {
+    transfersSet.add(object);
+  } else if (isTransferable(object.buffer)) {
+    transfersSet.add(object.buffer);
+  } else if (ArrayBuffer.isView(object)) {
+  } else if (recursive && typeof object === "object") {
+    for (const key in object) {
+      getTransferList(object[key], recursive, transfersSet);
+    }
+  }
+  return transfers === void 0 ? Array.from(transfersSet) : [];
+}
+function isTransferable(object) {
+  if (!object) {
+    return false;
+  }
+  if (object instanceof ArrayBuffer) {
+    return true;
+  }
+  if (typeof MessagePort !== "undefined" && object instanceof MessagePort) {
+    return true;
+  }
+  if (typeof ImageBitmap !== "undefined" && object instanceof ImageBitmap) {
+    return true;
+  }
+  if (typeof OffscreenCanvas !== "undefined" && object instanceof OffscreenCanvas) {
+    return true;
+  }
+  return false;
+}
+function getTransferListForWriter(object) {
+  if (object === null) {
+    return {};
+  }
+  const clone = Object.assign({}, object);
+  Object.keys(clone).forEach((key) => {
+    if (typeof object[key] === "object" && !ArrayBuffer.isView(object[key]) && !(object[key] instanceof Array)) {
+      clone[key] = getTransferListForWriter(object[key]);
+    } else if (typeof clone[key] === "function" || clone[key] instanceof RegExp) {
+      clone[key] = {};
+    } else {
+      clone[key] = object[key];
+    }
+  });
+  return clone;
+}
+
+// ../worker-utils/src/lib/worker-farm/worker-thread.ts
+var NOOP = () => {
+};
+var WorkerThread = class {
+  name;
+  source;
+  url;
+  terminated = false;
+  worker;
+  onMessage;
+  onError;
+  _loadableURL = "";
+  /** Checks if workers are supported on this platform */
+  static isSupported() {
+    return typeof Worker !== "undefined" && isBrowser2 || typeof NodeWorker !== "undefined" && !isBrowser2;
+  }
+  constructor(props) {
+    const { name, source, url } = props;
+    assert2(source || url);
+    this.name = name;
+    this.source = source;
+    this.url = url;
+    this.onMessage = NOOP;
+    this.onError = (error) => console.log(error);
+    this.worker = isBrowser2 ? this._createBrowserWorker() : this._createNodeWorker();
+  }
+  /**
+   * Terminate this worker thread
+   * @note Can free up significant memory
+   */
+  destroy() {
+    this.onMessage = NOOP;
+    this.onError = NOOP;
+    this.worker.terminate();
+    this.terminated = true;
+  }
+  /** Keeps this worker from preventing Node.js process exit while idle. */
+  unref() {
+    if (!isBrowser2 && typeof this.worker.unref === "function") {
+      this.worker.unref();
+    }
+  }
+  /** Keeps this worker alive while it is actively processing a job. */
+  ref() {
+    if (!isBrowser2 && typeof this.worker.ref === "function") {
+      this.worker.ref();
+    }
+  }
+  get isRunning() {
+    return Boolean(this.onMessage);
+  }
+  /**
+   * Send a message to this worker thread
+   * @param data any data structure, ideally consisting mostly of transferrable objects
+   * @param transferList If not supplied, calculated automatically by traversing data
+   */
+  postMessage(data, transferList) {
+    transferList = transferList || getTransferList(data);
+    this.worker.postMessage(data, transferList);
+  }
+  // PRIVATE
+  /**
+   * Generate a standard Error from an ErrorEvent
+   * @param event
+   */
+  _getErrorFromErrorEvent(event) {
+    let message = "Failed to load ";
+    message += `worker ${this.name} from ${this.url}. `;
+    if (event.message) {
+      message += `${event.message} in `;
+    }
+    if (event.lineno) {
+      message += `:${event.lineno}:${event.colno}`;
+    }
+    return new Error(message);
+  }
+  /**
+   * Creates a worker thread on the browser
+   */
+  _createBrowserWorker() {
+    this._loadableURL = getLoadableWorkerURL({ source: this.source, url: this.url });
+    const worker = new Worker(this._loadableURL, { name: this.name });
+    worker.onmessage = (event) => {
+      if (!event.data) {
+        this.onError(new Error("No data received"));
+      } else {
+        this.onMessage(event.data);
+      }
+    };
+    worker.onerror = (error) => {
+      this.onError(this._getErrorFromErrorEvent(error));
+      this.terminated = true;
+    };
+    worker.onmessageerror = (event) => console.error(event);
+    return worker;
+  }
+  /**
+   * Creates a worker thread in node.js
+   * @todo https://nodejs.org/api/async_hooks.html#async-resource-worker-pool
+   */
+  _createNodeWorker() {
+    let worker;
+    if (this.url) {
+      const absolute = this.url.includes(":/") || this.url.startsWith("/");
+      const url = absolute ? this.url : `./${this.url}`;
+      const workerUrl = url.startsWith("file:") ? new URL(url) : url;
+      const type = this.url.endsWith(".ts") || this.url.endsWith(".mjs") ? "module" : "commonjs";
+      worker = new NodeWorker(workerUrl, { eval: false, type });
+    } else if (this.source) {
+      worker = new NodeWorker(this.source, { eval: true });
+    } else {
+      throw new Error("no worker");
+    }
+    worker.on("message", (data) => {
+      this.onMessage(data);
+    });
+    worker.on("error", (error) => {
+      this.onError(error);
+    });
+    worker.on("exit", (_code) => {
+    });
+    return worker;
+  }
+};
+
+// ../worker-utils/src/lib/worker-farm/worker-pool.ts
+var WorkerPool = class {
+  name = "unnamed";
+  source;
+  // | Function;
+  url;
+  maxConcurrency = 1;
+  maxMobileConcurrency = 1;
+  onDebug = () => {
+  };
+  reuseWorkers = true;
+  props = {};
+  jobQueue = [];
+  idleQueue = [];
+  count = 0;
+  isDestroyed = false;
+  /** Checks if workers are supported on this platform */
+  static isSupported() {
+    return WorkerThread.isSupported();
+  }
+  /**
+   * @param processor - worker function
+   * @param maxConcurrency - max count of workers
+   */
+  constructor(props) {
+    this.source = props.source;
+    this.url = props.url;
+    this.setProps(props);
+  }
+  /**
+   * Terminates all workers in the pool
+   * @note Can free up significant memory
+   */
+  destroy() {
+    this.idleQueue.forEach((worker) => worker.destroy());
+    this.isDestroyed = true;
+  }
+  setProps(props) {
+    this.props = { ...this.props, ...props };
+    if (props.name !== void 0) {
+      this.name = props.name;
+    }
+    if (props.maxConcurrency !== void 0) {
+      this.maxConcurrency = props.maxConcurrency;
+    }
+    if (props.maxMobileConcurrency !== void 0) {
+      this.maxMobileConcurrency = props.maxMobileConcurrency;
+    }
+    if (props.reuseWorkers !== void 0) {
+      this.reuseWorkers = props.reuseWorkers;
+    }
+    if (props.onDebug !== void 0) {
+      this.onDebug = props.onDebug;
+    }
+  }
+  async startJob(name, onMessage2 = (job, type, data) => job.done(data), onError = (job, error) => job.error(error)) {
+    const startPromise = new Promise((onStart) => {
+      this.jobQueue.push({ name, onMessage: onMessage2, onError, onStart });
+      return this;
+    });
+    this._startQueuedJob();
+    return await startPromise;
+  }
+  // PRIVATE
+  /**
+   * Starts first queued job if worker is available or can be created
+   * Called when job is started and whenever a worker returns to the idleQueue
+   */
+  async _startQueuedJob() {
+    if (!this.jobQueue.length) {
+      return;
+    }
+    const workerThread = this._getAvailableWorker();
+    if (!workerThread) {
+      return;
+    }
+    const queuedJob = this.jobQueue.shift();
+    if (queuedJob) {
+      this.onDebug({
+        message: "Starting job",
+        name: queuedJob.name,
+        workerThread,
+        backlog: this.jobQueue.length
+      });
+      const job = new WorkerJob(queuedJob.name, workerThread);
+      workerThread.ref();
+      workerThread.onMessage = (data) => queuedJob.onMessage(job, data.type, data.payload);
+      workerThread.onError = (error) => queuedJob.onError(job, error);
+      queuedJob.onStart(job);
+      try {
+        await job.result;
+      } catch {
+      } finally {
+        this.returnWorkerToQueue(workerThread);
+      }
+    }
+  }
+  /**
+   * Returns a worker to the idle queue
+   * Destroys the worker if
+   *  - pool is destroyed
+   *  - if this pool doesn't reuse workers
+   *  - if maxConcurrency has been lowered
+   * @param worker
+   */
+  returnWorkerToQueue(worker) {
+    const shouldDestroyWorker = (
+      // Aborted jobs terminate their worker immediately.
+      worker.terminated || // If the pool is destroyed, there is no reason to keep the worker around
+      this.isDestroyed || // If the app has disabled worker reuse, any completed workers should be destroyed
+      !this.reuseWorkers || // If concurrency has been lowered, this worker might be surplus to requirements
+      this.count > this._getMaxConcurrency()
+    );
+    if (shouldDestroyWorker) {
+      if (!worker.terminated) {
+        worker.destroy();
+      }
+      this.count--;
+    } else {
+      worker.unref();
+      this.idleQueue.push(worker);
+    }
+    if (!this.isDestroyed) {
+      this._startQueuedJob();
+    }
+  }
+  /**
+   * Returns idle worker or creates new worker if maxConcurrency has not been reached
+   */
+  _getAvailableWorker() {
+    if (this.idleQueue.length > 0) {
+      return this.idleQueue.shift() || null;
+    }
+    if (this.count < this._getMaxConcurrency()) {
+      this.count++;
+      const name = `${this.name.toLowerCase()} (#${this.count} of ${this.maxConcurrency})`;
+      return new WorkerThread({ name, source: this.source, url: this.url });
+    }
+    return null;
+  }
+  _getMaxConcurrency() {
+    return isMobile ? this.maxMobileConcurrency : this.maxConcurrency;
+  }
+};
+
+// ../worker-utils/src/lib/worker-farm/worker-farm.ts
+var DEFAULT_PROPS = {
+  maxConcurrency: 3,
+  maxMobileConcurrency: 1,
+  reuseWorkers: true,
+  onDebug: () => {
+  }
+};
+var WorkerFarm = class _WorkerFarm {
+  props;
+  workerPools = /* @__PURE__ */ new Map();
+  // singleton
+  static _workerFarm;
+  /** Checks if workers are supported on this platform */
+  static isSupported() {
+    return WorkerThread.isSupported();
+  }
+  /** Get the singleton instance of the global worker farm */
+  static getWorkerFarm(props = {}) {
+    _WorkerFarm._workerFarm = _WorkerFarm._workerFarm || new _WorkerFarm({});
+    _WorkerFarm._workerFarm.setProps(props);
+    return _WorkerFarm._workerFarm;
+  }
+  /** get global instance with WorkerFarm.getWorkerFarm() */
+  constructor(props) {
+    this.props = { ...DEFAULT_PROPS };
+    this.setProps(props);
+    this.workerPools = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Terminate all workers in the farm
+   * @note Can free up significant memory
+   */
+  destroy() {
+    for (const workerPool of this.workerPools.values()) {
+      workerPool.destroy();
+    }
+    this.workerPools = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Set props used when initializing worker pools
+   * @param props
+   */
+  setProps(props) {
+    this.props = { ...this.props, ...props };
+    for (const workerPool of this.workerPools.values()) {
+      workerPool.setProps(this._getWorkerPoolProps());
+    }
+  }
+  /**
+   * Returns a worker pool for the specified worker
+   * @param options - only used first time for a specific worker name
+   * @param options.name - the name of the worker - used to identify worker pool
+   * @param options.url -
+   * @param options.source -
+   * @example
+   *   const job = WorkerFarm.getWorkerFarm().getWorkerPool({name, url}).startJob(...);
+   */
+  getWorkerPool(options) {
+    const { name, source, url } = options;
+    let workerPool = this.workerPools.get(name);
+    if (!workerPool) {
+      workerPool = new WorkerPool({
+        name,
+        source,
+        url
+      });
+      workerPool.setProps(this._getWorkerPoolProps());
+      this.workerPools.set(name, workerPool);
+    }
+    return workerPool;
+  }
+  _getWorkerPoolProps() {
+    return {
+      maxConcurrency: this.props.maxConcurrency,
+      maxMobileConcurrency: this.props.maxMobileConcurrency,
+      reuseWorkers: this.props.reuseWorkers,
+      onDebug: this.props.onDebug
+    };
+  }
+};
+
+// ../worker-utils/src/lib/worker-api/get-worker-url.ts
+var warnedWorkerVersionFallbacks = /* @__PURE__ */ new Set();
+function getWorkerName(worker) {
+  const warning = worker.version !== VERSION2 ? ` (worker-utils@${VERSION2})` : "";
+  return `${worker.name}@${worker.version}${warning}`;
+}
+function getWorkerURL(worker, options = {}) {
+  var _a;
+  const workerOptions = options[worker.id] || {};
+  const workerFile = isBrowser2 ? `${worker.id}-worker.js` : worker.workerNode || `${worker.id}-worker-node.js`;
+  let url = workerOptions.workerUrl;
+  if (!url && typeof worker.worker === "string") {
+    url = worker.worker;
+  }
+  if (!url && worker.id === "compression") {
+    url = options.workerUrl;
+  }
+  const workerType = options._workerType || ((_a = options == null ? void 0 : options.core) == null ? void 0 : _a._workerType);
+  if (workerType === "test") {
+    if (isBrowser2) {
+      url = `modules/${worker.module}/dist/${workerFile}`;
+    } else {
+      url = `modules/${worker.module}/src/workers/${worker.id}-worker-node.ts`;
+    }
+  }
+  if (!url) {
+    let version2 = worker.version;
+    if (version2 === "latest") {
+      version2 = NPM_TAG;
+    }
+    const versionTag = version2 ? `@${version2}` : "";
+    url = `https://unpkg.com/@loaders.gl/${worker.module}${versionTag}/dist/${workerFile}`;
+    warnIfUsingNpmTagFallback(worker, url);
+  }
+  assert2(url);
+  return url;
+}
+function warnIfUsingNpmTagFallback(worker, url) {
+  if (worker.version !== "latest") {
+    return;
+  }
+  const workerId = `${worker.module}:${worker.id}`;
+  if (warnedWorkerVersionFallbacks.has(workerId)) {
+    return;
+  }
+  warnedWorkerVersionFallbacks.add(workerId);
+  console.warn(
+    `loaders.gl: ${worker.name} loader worker version is "latest" because __VERSION__ was not injected. Fetching ${url} from CDN.`
+  );
+}
+
+// ../worker-utils/src/lib/worker-api/process-on-worker.ts
+function canProcessOnWorker(worker, options) {
+  if (!WorkerFarm.isSupported()) {
+    return false;
+  }
+  const workerOptions = options == null ? void 0 : options[worker.id];
+  return Boolean((worker.worker || (workerOptions == null ? void 0 : workerOptions.workerUrl)) && (options == null ? void 0 : options.worker));
+}
+async function processOnWorker(worker, data, options = {}, context = {}, jobContext = {}) {
+  var _a, _b, _c;
+  throwIfAborted(options.signal);
+  const name = getWorkerName(worker);
+  const workerFarm = WorkerFarm.getWorkerFarm(options);
+  const { source } = options;
+  const workerPoolProps = { name, source };
+  if (!source) {
+    workerPoolProps.url = getWorkerURL(worker, options);
+  }
+  const workerPool = workerFarm.getWorkerPool(workerPoolProps);
+  const jobName = options.jobName || worker.name;
+  const job = await workerPool.startJob(
+    jobName,
+    // eslint-disable-next-line
+    onMessage.bind(null, context)
+  );
+  const abortJob = () => job.abort(getAbortReason(options.signal));
+  (_a = options.signal) == null ? void 0 : _a.addEventListener("abort", abortJob, { once: true });
+  if ((_b = options.signal) == null ? void 0 : _b.aborted) {
+    abortJob();
+  }
+  try {
+    const { signal: _signal, ...workerOptions } = options;
+    const transferableOptions = getTransferListForWriter(workerOptions);
+    const transferableContext = getTransferListForWriter(jobContext);
+    if (job.isRunning) {
+      job.postMessage("process", {
+        input: data,
+        options: transferableOptions,
+        context: transferableContext
+      });
+    }
+    const result = await job.result;
+    return result.result;
+  } finally {
+    (_c = options.signal) == null ? void 0 : _c.removeEventListener("abort", abortJob);
+  }
+}
+function throwIfAborted(signal) {
+  if (!(signal == null ? void 0 : signal.aborted)) {
+    return;
+  }
+  throw getAbortReason(signal);
+}
+function getAbortReason(signal) {
+  return (signal == null ? void 0 : signal.reason) ?? createAbortError2("Worker job was aborted");
+}
+function createAbortError2(message) {
+  const error = new Error(message);
+  error.name = "AbortError";
+  return error;
+}
+async function onMessage(context, job, type, payload) {
+  switch (type) {
+    case "done":
+      job.done(payload);
+      break;
+    case "error":
+      job.error(new Error(payload.error));
+      break;
+    case "process":
+      const { id, input, options } = payload;
+      try {
+        if (!context.process) {
+          job.postMessage("error", { id, error: "Worker not set up to process on main thread" });
+          return;
+        }
+        const result = await context.process(input, options, void 0, payload.context || {});
+        job.postMessage("done", { id, result });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "unknown error";
+        job.postMessage("error", { id, error: message });
+      }
+      break;
+    default:
+      console.warn(`process-on-worker: unknown message ${type}`);
+  }
+}
+
+// ../worker-utils/src/lib/worker-api/validate-worker-version.ts
+function validateWorkerVersion(worker, coreVersion = VERSION2) {
+  assert2(worker, "no worker provided");
+  const workerVersion = worker.version;
+  if (!coreVersion || !workerVersion) {
+    return false;
+  }
+  return true;
+}
+
+// ../loader-utils/src/lib/worker-loader-utils/parse-with-worker.ts
+function canParseWithWorker(loader, options) {
+  var _a, _b;
+  const workerOptions = getWorkerOptions(options);
+  const nodeWorkers = workerOptions._nodeWorkers;
+  if (!isBrowser2 && !nodeWorkers) {
+    return false;
+  }
+  if (loader.id === "excel" && ((_a = options == null ? void 0 : options.excel) == null ? void 0 : _a.shape) === "arrow-table" || loader.id === "ply" && ((_b = options == null ? void 0 : options.ply) == null ? void 0 : _b.shape) === "arrow-table") {
+    return false;
+  }
+  if (loader.id === "csv" && !shouldParseCSVWithWorker(options)) {
+    return false;
+  }
+  return Boolean(canProcessOnWorker(loader, workerOptions));
+}
+async function parseWithWorker(loader, data, options, context, parseOnMainThread, signal) {
+  const workerSignal = signal || getWorkerAbortSignal(options);
+  const result = await processOnWorker(
+    loader,
+    data,
+    { ...getWorkerOptions(options), signal: workerSignal },
+    {
+      process: async (input, processOptions, _workerContext, parseContext) => {
+        if (!parseOnMainThread) {
+          throw new Error("Worker not set up to parse on main thread");
+        }
+        const mainThreadContext = context ? { ...context, ...parseContext || {} } : void 0;
+        return await callParseOnMainThread(
+          parseOnMainThread,
+          input,
+          processOptions,
+          mainThreadContext
+        );
+      }
+    },
+    getSerializableLoaderContext(context)
+  );
+  return isLoaderWithWorkerResultDeserializer(loader) ? loader.deserializeWorkerResult(result, options, context) : result;
+}
+function getWorkerAbortSignal(options) {
+  var _a;
+  const parquetSignal = (_a = options == null ? void 0 : options.parquet) == null ? void 0 : _a.signal;
+  if (typeof AbortSignal !== "undefined" && parquetSignal instanceof AbortSignal) {
+    return parquetSignal;
+  }
+  return void 0;
+}
+function callParseOnMainThread(parseOnMainThread, input, options, context) {
+  if (parseOnMainThread.length <= 2) {
+    return parseOnMainThread(input, options);
+  }
+  return parseOnMainThread(input, void 0, options, context);
+}
+function getWorkerOptions(options = {}) {
+  const serializedOptions = JSON.parse(JSON.stringify(options));
+  return {
+    ...serializedOptions.core,
+    ...serializedOptions
+  };
+}
+function getSerializableLoaderContext(context) {
+  if (!context) {
+    return {};
+  }
+  const { fetch: fetch2, loaders, coreApi: coreApi2, _parse, _parseSync, _parseInBatches, ...serializableContext } = context;
+  return JSON.parse(JSON.stringify(serializableContext));
+}
+function shouldParseCSVWithWorker(options) {
+  var _a, _b;
+  const csvOptions = options;
+  return (((_a = csvOptions == null ? void 0 : csvOptions.csv) == null ? void 0 : _a.shape) ?? ((_b = csvOptions == null ? void 0 : csvOptions.core) == null ? void 0 : _b.shape)) === "arrow-table";
+}
+function isLoaderWithWorkerResultDeserializer(loader) {
+  return typeof loader.deserializeWorkerResult === "function";
+}
+
+// ../loader-utils/src/lib/worker-loader-utils/encode-with-worker.ts
+function canEncodeWithWorker(writer, options) {
+  var _a, _b;
+  if (!WorkerFarm.isSupported()) {
+    return false;
+  }
+  const nodeWorkers = (options == null ? void 0 : options._nodeWorkers) ?? ((_a = options == null ? void 0 : options.core) == null ? void 0 : _a._nodeWorkers);
+  const useWorkers = (options == null ? void 0 : options.worker) ?? ((_b = options == null ? void 0 : options.core) == null ? void 0 : _b.worker);
+  if (!isBrowser && !nodeWorkers) {
+    return false;
+  }
+  return Boolean(writer.worker && useWorkers);
+}
+
+// ../loader-utils/src/lib/binary-utils/array-buffer-utils.ts
+function compareArrayBuffers(arrayBuffer1, arrayBuffer2, byteLength) {
+  byteLength = byteLength || arrayBuffer1.byteLength;
+  if (arrayBuffer1.byteLength < byteLength || arrayBuffer2.byteLength < byteLength) {
+    return false;
+  }
+  const array1 = new Uint8Array(arrayBuffer1);
+  const array2 = new Uint8Array(arrayBuffer2);
+  for (let i = 0; i < array1.length; ++i) {
+    if (array1[i] !== array2[i]) {
+      return false;
+    }
+  }
+  return true;
+}
+function concatenateArrayBuffers(...sources) {
+  return concatenateArrayBuffersFromArray(sources);
+}
+function concatenateArrayBuffersFromArray(sources) {
+  const sourceArrays = sources.map(
+    (source2) => source2 instanceof ArrayBuffer ? new Uint8Array(source2) : source2
+  );
+  const byteLength = sourceArrays.reduce((length, typedArray) => length + typedArray.byteLength, 0);
+  const result = new Uint8Array(byteLength);
+  let offset = 0;
+  for (const sourceArray of sourceArrays) {
+    result.set(sourceArray, offset);
+    offset += sourceArray.byteLength;
+  }
+  return result.buffer;
+}
+
+// ../loader-utils/src/lib/iterators/text-iterators.ts
+async function* makeTextDecoderIterator(arrayBufferIterator, options = {}) {
+  const textDecoder = new TextDecoder(void 0, options);
+  for await (const arrayBuffer of arrayBufferIterator) {
+    yield typeof arrayBuffer === "string" ? arrayBuffer : textDecoder.decode(arrayBuffer, { stream: true });
+  }
+}
+async function* makeTextEncoderIterator(textIterator) {
+  const textEncoder = new TextEncoder();
+  for await (const text of textIterator) {
+    yield typeof text === "string" ? textEncoder.encode(text).buffer : text;
+  }
+}
+async function* makeLineIterator(textIterator) {
+  let previous = "";
+  for await (const textChunk of textIterator) {
+    previous += textChunk;
+    let eolIndex;
+    eolIndex = previous.indexOf("\n");
+    while (eolIndex >= 0) {
+      const line = previous.slice(0, eolIndex + 1);
+      previous = previous.slice(eolIndex + 1);
+      yield line;
+      eolIndex = previous.indexOf("\n");
+    }
+  }
+  if (previous.length > 0) {
+    yield previous;
+  }
+}
+async function* makeNumberedLineIterator(lineIterator) {
+  let counter = 1;
+  for await (const line of lineIterator) {
+    yield { counter, line };
+    counter++;
+  }
+}
+
+// ../loader-utils/src/lib/iterators/async-iteration.ts
+async function forEach(iterable, visitor) {
+  const iterator = toAsyncIterator(iterable);
+  while (true) {
+    const { done, value } = await iterator.next();
+    if (done) {
+      if (iterator.return) {
+        iterator.return();
+      }
+      return;
+    }
+    const cancel = visitor(value);
+    if (cancel) {
+      return;
+    }
+  }
+}
+async function concatenateArrayBuffersAsync(asyncIterator) {
+  const arrayBuffers = [];
+  for await (const chunk of asyncIterator) {
+    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);
+    }
+  };
+}
+
+// ../loader-utils/src/lib/request-utils/request-scheduler.ts
+var import_stats = require("@probe.gl/stats");
+var STAT_QUEUED_REQUESTS = "Queued Requests";
+var STAT_ACTIVE_REQUESTS = "Active Requests";
+var STAT_CANCELLED_REQUESTS = "Cancelled Requests";
+var STAT_QUEUED_REQUESTS_EVER = "Queued Requests Ever";
+var STAT_ACTIVE_REQUESTS_EVER = "Active Requests Ever";
+var DEFAULT_PROPS2 = {
+  id: "request-scheduler",
+  /** Specifies if the request scheduler should throttle incoming requests, mainly for comparative testing. */
+  throttleRequests: true,
+  /** The maximum number of simultaneous active requests. Un-throttled requests do not observe this limit. */
+  maxRequests: 6,
+  /**
+   * Specifies a debounce time, in milliseconds. All requests are queued, until no new requests have
+   * been added to the queue for this amount of time.
+   */
+  debounceTime: 0
+};
+var RequestScheduler = class {
+  props;
+  stats;
+  activeRequestCount = 0;
+  /** Tracks the number of active requests and prioritizes/cancels queued requests. */
+  requestQueue = [];
+  requestMap = /* @__PURE__ */ new Map();
+  updateTimer = null;
+  constructor(props = {}) {
+    this.props = { ...DEFAULT_PROPS2, ...props };
+    this.stats = new import_stats.Stats({ id: this.props.id });
+    this.stats.get(STAT_QUEUED_REQUESTS);
+    this.stats.get(STAT_ACTIVE_REQUESTS);
+    this.stats.get(STAT_CANCELLED_REQUESTS);
+    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
+   *
+   * When the returned promise resolved, it is OK for the application to issue a request.
+   * The promise resolves to an object that contains a `done` method.
+   * When the application's request has completed (or failed), the application must call the `done` function
+   *
+   * @param handle
+   * @param getPriority will be called when request "slots" open up,
+   *    allowing the caller to update priority or cancel the request
+   *    Highest priority executes first, priority < 0 cancels the request
+   * @returns a promise
+   *   - resolves to a object (with a `done` field) when the request can be issued without queueing,
+   *   - resolves to `null` if the request has been cancelled (by the callback return < 0).
+   *     In this case the application should not issue the request
+   */
+  scheduleRequest(handle, getPriority = () => 0) {
+    if (!this.props.throttleRequests) {
+      return Promise.resolve({ done: () => {
+      } });
+    }
+    if (this.requestMap.has(handle)) {
+      return this.requestMap.get(handle);
+    }
+    const request = { handle, priority: 0, getPriority };
+    const promise = new Promise((resolve2) => {
+      request.resolve = resolve2;
+      return request;
+    });
+    this.requestQueue.push(request);
+    this.requestMap.set(handle, promise);
+    this._issueNewRequests();
+    return promise;
+  }
+  // PRIVATE
+  _issueRequest(request) {
+    const { handle, resolve: resolve2 } = request;
+    let isDone = false;
+    const done = () => {
+      if (!isDone) {
+        isDone = true;
+        this.requestMap.delete(handle);
+        this.activeRequestCount--;
+        this._issueNewRequests();
+      }
+    };
+    this.activeRequestCount++;
+    return resolve2 ? resolve2({ done }) : Promise.resolve({ done });
+  }
+  /** We check requests asynchronously, to prevent multiple updates */
+  _issueNewRequests() {
+    if (this.updateTimer !== null) {
+      clearTimeout(this.updateTimer);
+    }
+    this.updateTimer = setTimeout(() => this._issueNewRequestsAsync(), this.props.debounceTime);
+  }
+  /** Refresh all requests  */
+  _issueNewRequestsAsync() {
+    if (this.updateTimer !== null) {
+      clearTimeout(this.updateTimer);
+    }
+    this.updateTimer = null;
+    const freeSlots = Math.max(this.props.maxRequests - this.activeRequestCount, 0);
+    if (freeSlots === 0) {
+      return;
+    }
+    this._updateAllRequests();
+    for (let i = 0; i < freeSlots; ++i) {
+      const request = this.requestQueue.shift();
+      if (request) {
+        this._issueRequest(request);
+      }
+    }
+  }
+  /** Ensure all requests have updated priorities, and that no longer valid requests are cancelled */
+  _updateAllRequests() {
+    const requestQueue = this.requestQueue;
+    for (let i = 0; i < requestQueue.length; ++i) {
+      const request = requestQueue[i];
+      if (!this._updateRequest(request)) {
+        requestQueue.splice(i, 1);
+        this.requestMap.delete(request.handle);
+        i--;
+      }
+    }
+    requestQueue.sort((a, b) => a.priority - b.priority);
+  }
+  /** Update a single request by calling the callback */
+  _updateRequest(request) {
+    request.priority = request.getPriority(request.handle);
+    if (request.priority < 0) {
+      request.resolve(null);
+      return false;
+    }
+    return true;
+  }
+};
+
+// ../loader-utils/src/lib/request-utils/request-credentials.ts
+var AUTHENTICATED_FETCH = /* @__PURE__ */ Symbol("loaders.gl.authenticated-fetch");
+var refreshPromises = /* @__PURE__ */ new WeakMap();
+function createAuthenticatedFetch(options) {
+  const baseFetch = options.fetch || ((url, requestOptions) => fetch(url, requestOptions));
+  if (!options.credentials.length) return baseFetch;
+  const existingMetadata = baseFetch[AUTHENTICATED_FETCH];
+  if (existingMetadata === options.credentials) return baseFetch;
+  const authenticatedFetch = async (url, requestOptions = {}) => {
+    var _a, _b, _c;
+    const resolvedURL = parseHTTPURL(url);
+    if (!resolvedURL) return baseFetch(url, requestOptions);
+    const authorization = await authorizeRequest(resolvedURL, requestOptions, options.credentials);
+    const response = await baseFetch(authorization.url, authorization.options);
+    const refreshableCredentials = authorization.credentials.filter(
+      ({ credential }) => typeof credential.token === "function" && credential.refreshStatusCodes.includes(response.status)
+    );
+    if (!refreshableCredentials.length || !isReplayableRequest(requestOptions)) return response;
+    if ((_a = requestOptions.signal) == null ? void 0 : _a.aborted) throw createAbortError3();
+    const refreshedTokens = /* @__PURE__ */ new Map();
+    await Promise.all(
+      refreshableCredentials.map(async ({ credential }) => {
+        const token = await refreshCredential(credential, url, response);
+        if (token) refreshedTokens.set(credential, token);
+      })
+    );
+    if (!refreshedTokens.size) return response;
+    await ((_b = response.body) == null ? void 0 : _b.cancel().catch(() => {
+    }));
+    if ((_c = requestOptions.signal) == null ? void 0 : _c.aborted) throw createAbortError3();
+    const replayAuthorization = await authorizeRequest(
+      resolvedURL,
+      requestOptions,
+      options.credentials,
+      refreshedTokens,
+      authorization.credentials
+    );
+    return baseFetch(replayAuthorization.url, replayAuthorization.options);
+  };
+  Object.defineProperty(authenticatedFetch, AUTHENTICATED_FETCH, {
+    value: options.credentials
+  });
+  return authenticatedFetch;
+}
+async function authorizeRequest(sourceURL, requestOptions, credentials, tokenOverrides = /* @__PURE__ */ new Map(), previousCredentials = []) {
+  const url = new URL(sourceURL);
+  const headers = new Headers(requestOptions.headers);
+  const resolvedCredentials = [];
+  const previousTokens = new Map(
+    previousCredentials.map(({ credential, token }) => [credential, token])
+  );
+  for (const credential of credentials) {
+    if (!credential.origins.includes(url.origin)) continue;
+    const overrideToken = tokenOverrides.get(credential);
+    const previousToken = previousTokens.get(credential);
+    const ownsQueryParameter = credential.type === "query-parameter" && previousToken !== void 0;
+    const ownsHeader = credential.type === "header" && previousToken !== void 0;
+    if (credential.type === "query-parameter" && url.searchParams.has(credential.name) && !ownsQueryParameter || credential.type === "header" && headers.has(credential.name) && !ownsHeader) {
+      continue;
+    }
+    const token = overrideToken ?? previousToken ?? await resolveToken(credential.token, { url: sourceURL.toString(), reason: "request" });
+    if (!token) continue;
+    if (credential.type === "query-parameter") {
+      url.searchParams.set(credential.name, token);
+    } else {
+      headers.set(credential.name, `${credential.prefix || ""}${token}`);
+    }
+    resolvedCredentials.push({ credential, token });
+  }
+  return {
+    url: url.toString(),
+    options: { ...requestOptions, headers },
+    credentials: resolvedCredentials
+  };
+}
+async function refreshCredential(credential, url, response) {
+  const existingPromise = refreshPromises.get(credential);
+  if (existingPromise) return existingPromise;
+  const tokenProvider = credential.token;
+  const promise = Promise.resolve(
+    tokenProvider({
+      url,
+      reason: "refresh",
+      response: { status: response.status, headers: response.headers }
+    })
+  ).finally(() => refreshPromises.delete(credential));
+  refreshPromises.set(credential, promise);
+  return promise;
+}
+async function resolveToken(token, context) {
+  return typeof token === "function" ? token(context) : token;
+}
+function parseHTTPURL(url) {
+  try {
+    const parsedURL = new URL(url);
+    return ["http:", "https:"].includes(parsedURL.protocol) ? parsedURL : null;
+  } catch {
+    return null;
+  }
+}
+function isReplayableRequest(options) {
+  const method = (options.method || "GET").toUpperCase();
+  if (!["GET", "HEAD", "OPTIONS", "PUT", "DELETE"].includes(method)) return false;
+  return !(options.body && typeof ReadableStream !== "undefined" && options.body instanceof ReadableStream);
+}
+function createAbortError3() {
+  return new DOMException("The operation was aborted.", "AbortError");
+}
+
+// ../loader-utils/src/lib/path-utils/file-aliases.ts
+var pathPrefix = "";
+var fileAliases = {};
+function setPathPrefix(prefix) {
+  pathPrefix = prefix;
+}
+function getPathPrefix() {
+  return pathPrefix;
+}
+function resolvePath(filename2) {
+  for (const alias in fileAliases) {
+    if (filename2.startsWith(alias)) {
+      const replacement = fileAliases[alias];
+      filename2 = filename2.replace(alias, replacement);
+    }
+  }
+  if (!filename2.startsWith("http://") && !filename2.startsWith("https://")) {
+    filename2 = `${pathPrefix}${filename2}`;
+  }
+  return filename2;
+}
+
+// ../loader-utils/src/lib/path-utils/path.ts
+var path_exports = {};
+__export(path_exports, {
+  dirname: () => dirname,
+  filename: () => filename,
+  join: () => join,
+  resolve: () => resolve
+});
+
+// ../loader-utils/src/lib/path-utils/get-cwd.ts
+function getCWD() {
+  var _a;
+  if (typeof process !== "undefined" && typeof process.cwd !== "undefined") {
+    return process.cwd();
+  }
+  const pathname = (_a = window.location) == null ? void 0 : _a.pathname;
+  return (pathname == null ? void 0 : pathname.slice(0, pathname.lastIndexOf("/") + 1)) || "";
+}
+
+// ../loader-utils/src/lib/path-utils/path.ts
+function filename(url) {
+  const slashIndex = url ? url.lastIndexOf("/") : -1;
+  return slashIndex >= 0 ? url.substr(slashIndex + 1) : url;
+}
+function dirname(url) {
+  const slashIndex = url ? url.lastIndexOf("/") : -1;
+  return slashIndex >= 0 ? url.substr(0, slashIndex) : "";
+}
+function join(...parts) {
+  const separator = "/";
+  parts = parts.map((part, index) => {
+    if (index) {
+      part = part.replace(new RegExp(`^${separator}`), "");
+    }
+    if (index !== parts.length - 1) {
+      part = part.replace(new RegExp(`${separator}$`), "");
+    }
+    return part;
+  });
+  return parts.join(separator);
+}
+function resolve(...components) {
+  const paths = [];
+  for (let _i = 0; _i < components.length; _i++) {
+    paths[_i] = components[_i];
+  }
+  let resolvedPath = "";
+  let resolvedAbsolute = false;
+  let cwd;
+  for (let i = paths.length - 1; i >= -1 && !resolvedAbsolute; i--) {
+    let path;
+    if (i >= 0) {
+      path = paths[i];
+    } else {
+      if (cwd === void 0) {
+        cwd = getCWD();
+      }
+      path = cwd;
+    }
+    if (path.length === 0) {
+      continue;
+    }
+    resolvedPath = `${path}/${resolvedPath}`;
+    resolvedAbsolute = path.charCodeAt(0) === SLASH;
+  }
+  resolvedPath = normalizeStringPosix(resolvedPath, !resolvedAbsolute);
+  if (resolvedAbsolute) {
+    return `/${resolvedPath}`;
+  } else if (resolvedPath.length > 0) {
+    return resolvedPath;
+  }
+  return ".";
+}
+var SLASH = 47;
+var DOT = 46;
+function normalizeStringPosix(path, allowAboveRoot) {
+  let res = "";
+  let lastSlash = -1;
+  let dots = 0;
+  let code;
+  let isAboveRoot = false;
+  for (let i = 0; i <= path.length; ++i) {
+    if (i < path.length) {
+      code = path.charCodeAt(i);
+    } else if (code === SLASH) {
+      break;
+    } else {
+      code = SLASH;
+    }
+    if (code === SLASH) {
+      if (lastSlash === i - 1 || dots === 1) {
+      } else if (lastSlash !== i - 1 && dots === 2) {
+        if (res.length < 2 || !isAboveRoot || res.charCodeAt(res.length - 1) !== DOT || res.charCodeAt(res.length - 2) !== DOT) {
+          if (res.length > 2) {
+            const start = res.length - 1;
+            let j = start;
+            for (; j >= 0; --j) {
+              if (res.charCodeAt(j) === SLASH) {
+                break;
+              }
+            }
+            if (j !== start) {
+              res = j === -1 ? "" : res.slice(0, j);
+              lastSlash = i;
+              dots = 0;
+              isAboveRoot = false;
+              continue;
+            }
+          } else if (res.length === 2 || res.length === 1) {
+            res = "";
+            lastSlash = i;
+            dots = 0;
+            isAboveRoot = false;
+            continue;
+          }
+        }
+        if (allowAboveRoot) {
+          if (res.length > 0) {
+            res += "/..";
+          } else {
+            res = "..";
+          }
+          isAboveRoot = true;
+        }
+      } else {
+        const slice = path.slice(lastSlash + 1, i);
+        if (res.length > 0) {
+          res += `/${slice}`;
+        } else {
+          res = slice;
+        }
+        isAboveRoot = false;
+      }
+      lastSlash = i;
+      dots = 0;
+    } else if (code === DOT && dots !== -1) {
+      ++dots;
+    } else {
+      dots = -1;
+    }
+  }
+  return res;
+}
+
+// ../loader-utils/src/json-loader.ts
+var VERSION3 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+var JSONLoader = {
+  dataType: null,
+  batchType: null,
+  name: "JSON",
+  id: "json",
+  module: "json",
+  version: VERSION3,
+  encoding: "json",
+  format: "json",
+  extensions: ["json", "geojson"],
+  mimeTypes: ["application/json"],
+  category: "json",
+  text: true,
+  parseTextSync,
+  parse: async (arrayBuffer) => parseTextSync(new TextDecoder().decode(arrayBuffer)),
+  options: {}
+};
+function parseTextSync(text) {
+  return JSON.parse(text);
+}
+
+// ../loader-utils/src/lib/node/buffer.browser.ts
+function toArrayBuffer(buffer) {
+  return buffer;
+}
+
+// ../loader-utils/src/lib/binary-utils/memory-conversion-utils.ts
+function isBuffer(value) {
+  return value && typeof value === "object" && value.isBuffer;
+}
+function toArrayBuffer2(data) {
+  if (isBuffer(data)) {
+    return toArrayBuffer(data);
+  }
+  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 buffer;
+    }
+    return buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
+  }
+  if (typeof data === "string") {
+    const text = data;
+    const uint8Array = new TextEncoder().encode(text);
+    return uint8Array.buffer;
+  }
+  if (data && typeof data === "object" && data._toArrayBuffer) {
+    return data._toArrayBuffer();
+  }
+  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/files/blob-file.ts
+var BlobFile = class {
+  handle;
+  size;
+  bigsize;
+  url;
+  constructor(blob) {
+    this.handle = blob instanceof ArrayBuffer ? new Blob([blob]) : blob;
+    this.size = blob instanceof ArrayBuffer ? blob.byteLength : blob.size;
+    this.bigsize = BigInt(this.size);
+    this.url = blob instanceof File ? blob.name : "";
+  }
+  async close() {
+  }
+  async stat() {
+    return {
+      size: this.handle.size,
+      bigsize: BigInt(this.handle.size),
+      isDirectory: false
+    };
+  }
+  async read(start, length, signal) {
+    if (signal == null ? void 0 : signal.aborted) {
+      throw new Error("Request aborted");
+    }
+    const arrayBuffer = await this.handle.slice(Number(start), Number(start) + Number(length)).arrayBuffer();
+    if (signal == null ? void 0 : signal.aborted) {
+      throw new Error("Request aborted");
+    }
+    return arrayBuffer;
+  }
+};
+
+// ../loader-utils/src/lib/files/node-file-facade.ts
+var NOT_IMPLEMENTED = new Error("Not implemented");
+var NodeFileFacade = class {
+  handle;
+  size = 0;
+  bigsize = 0n;
+  url = "";
+  constructor(url, flags, mode) {
+    var _a;
+    if ((_a = globalThis.loaders) == null ? void 0 : _a.NodeFile) {
+      return new globalThis.loaders.NodeFile(url, flags, mode);
+    }
+    if (isBrowser) {
+      throw new Error("Can't instantiate NodeFile in browser.");
+    }
+    throw new Error("Can't instantiate NodeFile. Make sure to import @loaders.gl/polyfills first.");
+  }
+  /** Read data */
+  async read(start, length) {
+    throw NOT_IMPLEMENTED;
+  }
+  /** Write to file. The number of bytes written will be returned */
+  async write(arrayBuffer, offset, length) {
+    throw NOT_IMPLEMENTED;
+  }
+  /** Get information about file */
+  async stat() {
+    throw NOT_IMPLEMENTED;
+  }
+  /** Truncates the file descriptor. Only available on NodeFile. */
+  async truncate(length) {
+    throw NOT_IMPLEMENTED;
+  }
+  /** Append data to a file. Only available on NodeFile. */
+  async append(data) {
+    throw NOT_IMPLEMENTED;
+  }
+  /** Close the file */
+  async close() {
+  }
+};
+
+// ../loader-utils/src/source-types.ts
+function isSourceLoader(loader) {
+  return Boolean(loader && typeof loader === "object" && "createDataSource" in loader);
+}
 
 // dist/lib/fetch/fetch-error.js
 var FetchError = class extends Error {
@@ -106,9 +1730,6 @@ 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.+]+)/;
@@ -119,16 +1740,16 @@ function compareMIMETypes(mimeType1, mimeType2) {
   return false;
 }
 function parseMIMEType(mimeString) {
-  const matches = MIME_TYPE_PATTERN.exec(mimeString);
-  if (matches) {
-    return matches[1];
+  const matches3 = MIME_TYPE_PATTERN.exec(mimeString);
+  if (matches3) {
+    return matches3[1];
   }
   return mimeString;
 }
 function parseMIMETypeFromURL(url) {
-  const matches = DATA_URL_PATTERN.exec(url);
-  if (matches) {
-    return matches[1];
+  const matches3 = DATA_URL_PATTERN.exec(url);
+  if (matches3) {
+    return matches3[1];
   }
   return "";
 }
@@ -136,8 +1757,8 @@ function parseMIMETypeFromURL(url) {
 // dist/lib/utils/url-utils.js
 var QUERY_STRING_PATTERN = /\?.*/;
 function extractQueryString(url) {
-  const matches = url.match(QUERY_STRING_PATTERN);
-  return matches && matches[0];
+  const matches3 = url.match(QUERY_STRING_PATTERN);
+  return matches3 && matches3[0];
 }
 function stripQueryString(url) {
   return url.replace(QUERY_STRING_PATTERN, "");
@@ -153,10 +1774,10 @@ function shortenUrlForDisplay(url) {
 
 // dist/lib/utils/resource-utils.js
 function getResourceUrl(resource) {
-  if ((0, import_loader_utils.isResponse)(resource)) {
+  if (isResponse(resource)) {
     return resource.url;
   }
-  if ((0, import_loader_utils.isBlob)(resource)) {
+  if (isBlob(resource)) {
     const fileName = "name" in resource ? resource.name : "";
     return fileName || "";
   }
@@ -166,12 +1787,12 @@ function getResourceUrl(resource) {
   return "";
 }
 function getResourceMIMEType(resource) {
-  if ((0, import_loader_utils.isResponse)(resource)) {
+  if (isResponse(resource)) {
     const contentTypeHeader = resource.headers.get("content-type") || "";
     const noQueryUrl = stripQueryString(resource.url);
     return parseMIMEType(contentTypeHeader) || parseMIMETypeFromURL(noQueryUrl);
   }
-  if ((0, import_loader_utils.isBlob)(resource)) {
+  if (isBlob(resource)) {
     return resource.type || "";
   }
   if (typeof resource === "string") {
@@ -180,11 +1801,11 @@ function getResourceMIMEType(resource) {
   return "";
 }
 function getResourceContentLength(resource) {
-  if ((0, import_loader_utils.isResponse)(resource)) {
+  if (isResponse(resource)) {
     const response = resource;
     return response.headers["content-length"] || -1;
   }
-  if ((0, import_loader_utils.isBlob)(resource)) {
+  if (isBlob(resource)) {
     const blob = resource;
     return blob.size;
   }
@@ -202,7 +1823,7 @@ function getResourceContentLength(resource) {
 
 // dist/lib/utils/response-utils.js
 async function makeResponse(resource) {
-  if ((0, import_loader_utils2.isResponse)(resource)) {
+  if (isResponse(resource)) {
     return resource;
   }
   const headers = {};
@@ -255,11 +1876,11 @@ async function getInitialDataUrl(resource) {
   }
   if (resource instanceof Blob) {
     const blobSlice = resource.slice(0, 5);
-    return await new Promise((resolve) => {
+    return await new Promise((resolve2) => {
       const reader = new FileReader();
       reader.onload = (event) => {
         var _a;
-        return resolve((_a = event == null ? void 0 : event.target) == null ? void 0 : _a.result);
+        return resolve2((_a = event == null ? void 0 : event.target) == null ? void 0 : _a.result);
       };
       reader.readAsDataURL(blobSlice);
     });
@@ -293,7 +1914,7 @@ function isDataURL(url) {
 async function fetchFile(urlOrData, fetchOptions) {
   var _a, _b;
   if (typeof urlOrData === "string") {
-    const url = (0, import_loader_utils3.resolvePath)(urlOrData);
+    const url = 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);
@@ -313,23 +1934,20 @@ async function readArrayBuffer(file, start, length) {
   return await readBlob(slice);
 }
 async function readBlob(blob) {
-  return await new Promise((resolve, reject) => {
+  return await new Promise((resolve2, reject) => {
     const fileReader = new FileReader();
     fileReader.onload = (event) => {
       var _a;
-      return resolve((_a = event == null ? void 0 : event.target) == null ? void 0 : _a.result);
+      return resolve2((_a = event == null ? void 0 : event.target) == null ? void 0 : _a.result);
     };
     fileReader.onerror = (error) => reject(error);
     fileReader.readAsArrayBuffer(blob);
   });
 }
 
-// dist/lib/loader-utils/option-utils.js
-var import_loader_utils5 = require("@loaders.gl/loader-utils");
-
 // dist/lib/loader-utils/loggers.js
-var import_log = require("@probe.gl/log");
-var probeLog = new import_log.Log({ id: "loaders.gl" });
+var import_log3 = require("@probe.gl/log");
+var probeLog = new import_log3.Log({ id: "loaders.gl" });
 var NullLog = class {
   /** Drops a log message. */
   log() {
@@ -395,7 +2013,6 @@ var ConsoleLog = class {
 };
 
 // dist/lib/loader-utils/option-defaults.js
-var import_loader_utils4 = require("@loaders.gl/loader-utils");
 var DEFAULT_LOADER_OPTIONS = {
   core: {
     baseUrl: void 0,
@@ -416,7 +2033,7 @@ var DEFAULT_LOADER_OPTIONS = {
     // 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,
+    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
@@ -521,7 +2138,7 @@ function setGlobalOptions(options) {
   const state = getGlobalLoaderState();
   const globalOptions = getGlobalLoaderOptions();
   state.globalOptions = normalizeOptionsInternal(globalOptions, options);
-  (0, import_loader_utils5.registerJSModules)(options.modules);
+  registerJSModules(options.modules);
 }
 function normalizeOptions(options, loader, loaders, url) {
   loaders = loaders || [];
@@ -555,7 +2172,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 && (0, import_loader_utils5.isObject)(options[key]);
+    const isSubOptions = !id && isObject(options[key]);
     const isBaseUriOption = key === "baseUri" && !id;
     const isWorkerUrlOption = key === "workerUrl" && id;
     if (!(key in defaultOptions) && !isBaseUriOption && !isWorkerUrlOption) {
@@ -615,20 +2232,20 @@ function applyCoreShapeDefault(mergedOptions, userOptions, loader) {
     return;
   }
   const loaderScopedDefaults = (_b = loader.options) == null ? void 0 : _b[loader.id];
-  if (!(0, import_loader_utils5.isPureObject)(loaderScopedDefaults) || !("shape" in loaderScopedDefaults)) {
+  if (!isPureObject(loaderScopedDefaults) || !("shape" in loaderScopedDefaults)) {
     return;
   }
   const globalLoaderScopedOptions = getGlobalLoaderOptions()[loader.id];
-  if ((0, import_loader_utils5.isPureObject)(globalLoaderScopedOptions) && "shape" in globalLoaderScopedOptions) {
+  if (isPureObject(globalLoaderScopedOptions) && "shape" in globalLoaderScopedOptions) {
     return;
   }
   const userLoaderScopedOptions = userOptions[loader.id];
-  if ((0, import_loader_utils5.isPureObject)(userLoaderScopedOptions) && "shape" in userLoaderScopedOptions) {
+  if (isPureObject(userLoaderScopedOptions) && "shape" in userLoaderScopedOptions) {
     return;
   }
   const loaderScopedOptions = mergedOptions[loader.id];
   mergedOptions[loader.id] = {
-    ...(0, import_loader_utils5.isPureObject)(loaderScopedOptions) ? loaderScopedOptions : {},
+    ...isPureObject(loaderScopedOptions) ? loaderScopedOptions : {},
     shape: coreShape
   };
 }
@@ -636,7 +2253,7 @@ function mergeNestedFields(mergedOptions, options) {
   for (const key in options) {
     if (key in options) {
       const value = options[key];
-      if ((0, import_loader_utils5.isPureObject)(value) && (0, import_loader_utils5.isPureObject)(mergedOptions[key])) {
+      if (isPureObject(value) && isPureObject(mergedOptions[key])) {
         mergedOptions[key] = {
           ...mergedOptions[key],
           ...options[key]
@@ -655,7 +2272,7 @@ function addUrlOptions(options, url) {
   const hasCoreBaseUrl = ((_a = options.core) == null ? void 0 : _a.baseUrl) !== void 0;
   if (!hasCoreBaseUrl) {
     options.core ||= {};
-    options.core.baseUrl = import_loader_utils5.path.dirname(stripQueryString(url));
+    options.core.baseUrl = path_exports.dirname(stripQueryString(url));
   }
 }
 function cloneLoaderOptions(options) {
@@ -703,7 +2320,6 @@ function addDeprecatedTopLevelOptions(options) {
 }
 
 // dist/lib/loader-utils/normalize-loader.js
-var import_loader_utils6 = require("@loaders.gl/loader-utils");
 function isLoaderObject(loader) {
   if (!loader) {
     return false;
@@ -715,8 +2331,8 @@ function isLoaderObject(loader) {
   return hasExtensions;
 }
 function normalizeLoader(loader) {
-  (0, import_loader_utils6.assert)(loader, "null loader");
-  (0, import_loader_utils6.assert)(isLoaderObject(loader), "invalid loader");
+  assert(loader, "null loader");
+  assert(isLoaderObject(loader), "invalid loader");
   let options;
   if (Array.isArray(loader)) {
     options = loader[1];
@@ -760,7 +2376,6 @@ function _unregisterLoaders() {
 }
 
 // dist/lib/api/select-loader.js
-var import_loader_utils7 = require("@loaders.gl/loader-utils");
 var EXT_PATTERN = /\.([^.]+)$/;
 async function selectLoader(data, loaders = [], options, context) {
   if (!validHTTPResponse(data)) {
@@ -779,7 +2394,7 @@ async function selectLoader(data, loaders = [], options, context) {
   if (loader) {
     return loader;
   }
-  if ((0, import_loader_utils7.isBlob)(data)) {
+  if (isBlob(data)) {
     data = await data.slice(0, 10).arrayBuffer();
     loader = selectLoaderSync(data, loaders, normalizedOptions, context);
   }
@@ -843,7 +2458,7 @@ 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 (!loader && (0, import_loader_utils7.isBlob)(data)) {
+  if (!loader && isBlob(data)) {
     loader = findSourceLoaderByTestData(loaders, data);
     reason = reason || (loader ? "matched source testData" : "");
   }
@@ -852,7 +2467,7 @@ function selectLoaderInternal(data, loaders, options, context) {
     reason = reason || (loader ? `matched fallback MIME type ${type}` : "");
   }
   if (reason) {
-    import_loader_utils7.log.log(1, `selectLoader selected ${loader == null ? void 0 : loader.name}: ${reason}.`);
+    log.log(1, `selectLoader selected ${loader == null ? void 0 : loader.name}: ${reason}.`);
   }
   return loader;
 }
@@ -868,7 +2483,7 @@ function getNoValidLoaderMessage(data) {
   const url = getResourceUrl(data);
   const type = getResourceMIMEType(data);
   let message = "No valid loader found (";
-  message += url ? `${import_loader_utils7.path.filename(url)}, ` : "no url provided, ";
+  message += url ? `${path_exports.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";
@@ -898,7 +2513,7 @@ function findLoaderByExtension(loaders, extension) {
 }
 function findSourceLoaderByType(loaders, type) {
   for (const loader of loaders) {
-    if ((0, import_loader_utils7.isSourceLoader)(loader) && loader.type === type) {
+    if (isSourceLoader(loader) && loader.type === type) {
       return loader;
     }
   }
@@ -909,7 +2524,7 @@ function findSourceLoaderByTestURL(loaders, url) {
     return null;
   }
   for (const loader of loaders) {
-    if ((0, import_loader_utils7.isSourceLoader)(loader) && loader.testURL(url)) {
+    if (isSourceLoader(loader) && loader.testURL(url)) {
       return loader;
     }
   }
@@ -918,7 +2533,7 @@ function findSourceLoaderByTestURL(loaders, url) {
 function findSourceLoaderByTestData(loaders, data) {
   var _a;
   for (const loader of loaders) {
-    if ((0, import_loader_utils7.isSourceLoader)(loader)) {
+    if (isSourceLoader(loader)) {
       if ((_a = loader.testData) == null ? void 0 : _a.call(loader, data)) {
         return loader;
       }
@@ -972,12 +2587,12 @@ function testDataAgainstBinary(data, byteOffset, loader) {
   return tests.some((test) => testBinary(data, byteOffset, loader, test));
 }
 function testBinary(data, byteOffset, loader, test) {
-  if ((0, import_loader_utils7.isArrayBufferLike)(test)) {
-    return (0, import_loader_utils7.compareArrayBuffers)(test, data, test.byteLength);
+  if (isArrayBufferLike(test)) {
+    return compareArrayBuffers(test, data, test.byteLength);
   }
   switch (typeof test) {
     case "function":
-      return test((0, import_loader_utils7.ensureArrayBuffer)(data));
+      return test(ensureArrayBuffer(data));
     case "string":
       const magic = getMagicString(data, byteOffset, test.length);
       return test === magic;
@@ -1008,15 +2623,7 @@ function getMagicString(arrayBuffer, byteOffset, length) {
   return magic;
 }
 
-// dist/lib/api/parse.js
-var import_loader_utils18 = require("@loaders.gl/loader-utils");
-var import_worker_utils2 = require("@loaders.gl/worker-utils");
-
-// dist/lib/loader-utils/get-data.js
-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;
@@ -1026,7 +2633,7 @@ function* makeStringIterator(string, options) {
     const chunkLength = Math.min(string.length - offset, chunkSize);
     const chunk = string.slice(offset, offset + chunkLength);
     offset += chunkLength;
-    yield (0, import_loader_utils8.ensureArrayBuffer)(textEncoder.encode(chunk));
+    yield ensureArrayBuffer(textEncoder.encode(chunk));
   }
 }
 
@@ -1060,37 +2667,72 @@ async function* makeBlobIterator(blob, options) {
 }
 
 // dist/iterators/make-iterator/make-stream-iterator.js
-var import_loader_utils9 = require("@loaders.gl/loader-utils");
 function makeStreamIterator(stream, options) {
-  return import_loader_utils9.isBrowser ? makeBrowserStreamIterator(stream, options) : makeNodeStreamIterator(stream, options);
+  return isBrowser ? makeBrowserStreamIterator(stream, options) : makeNodeStreamIterator(stream, options);
 }
 async function* makeBrowserStreamIterator(stream, options) {
   const reader = stream.getReader();
   let nextBatchPromise;
+  let streamFinished = false;
+  let streamReadFailed = false;
+  let iteratorFailed = false;
   try {
     while (true) {
       const currentBatchPromise = nextBatchPromise || reader.read();
-      if (options == null ? void 0 : options._streamReadAhead) {
-        nextBatchPromise = reader.read();
+      nextBatchPromise = void 0;
+      let batch;
+      try {
+        batch = await currentBatchPromise;
+      } catch (error) {
+        streamReadFailed = true;
+        throw error;
       }
-      const { done, value } = await currentBatchPromise;
+      const { done, value } = batch;
       if (done) {
+        streamFinished = true;
         return;
       }
-      yield (0, import_loader_utils9.toArrayBuffer)(value);
+      if (options == null ? void 0 : options._streamReadAhead) {
+        nextBatchPromise = reader.read();
+        void nextBatchPromise.catch(() => {
+        });
+      }
+      yield toArrayBuffer2(value);
+    }
+  } catch (error) {
+    iteratorFailed = true;
+    throw error;
+  } finally {
+    let cleanupFailed = false;
+    let cleanupError;
+    if (!streamFinished && !streamReadFailed) {
+      try {
+        await reader.cancel();
+      } catch (error) {
+        cleanupFailed = true;
+        cleanupError = error;
+      }
+    }
+    try {
+      reader.releaseLock();
+    } catch (error) {
+      if (!cleanupFailed) {
+        cleanupFailed = true;
+        cleanupError = error;
+      }
+    }
+    if (!iteratorFailed && cleanupFailed) {
+      throw cleanupError;
     }
-  } catch (_error) {
-    reader.releaseLock();
   }
 }
 async function* makeNodeStreamIterator(stream, options) {
   for await (const chunk of stream) {
-    yield (0, import_loader_utils9.toArrayBuffer)(chunk);
+    yield toArrayBuffer2(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);
@@ -1098,13 +2740,13 @@ function makeIterator(data, options) {
   if (data instanceof ArrayBuffer) {
     return makeArrayBufferIterator(data, options);
   }
-  if ((0, import_loader_utils10.isBlob)(data)) {
+  if (isBlob(data)) {
     return makeBlobIterator(data, options);
   }
-  if ((0, import_loader_utils10.isReadableStream)(data)) {
+  if (isReadableStream(data)) {
     return makeStreamIterator(data, options);
   }
-  if ((0, import_loader_utils10.isResponse)(data)) {
+  if (isResponse(data)) {
     const responseBody = data.body;
     if (!responseBody) {
       throw new Error("Readable stream not available on Response");
@@ -1120,35 +2762,35 @@ function getArrayBufferOrStringFromDataSync(data, loader, options) {
   if (loader.text && typeof data === "string") {
     return data;
   }
-  if ((0, import_loader_utils11.isBuffer)(data)) {
+  if (isBuffer(data)) {
     data = data.buffer;
   }
-  if ((0, import_loader_utils11.isArrayBufferLike)(data)) {
-    const bufferSource = (0, import_loader_utils11.toArrayBufferView)(data);
+  if (isArrayBufferLike(data)) {
+    const bufferSource = toArrayBufferView(data);
     if (loader.text && !loader.binary) {
       const textDecoder = new TextDecoder("utf8");
       return textDecoder.decode(bufferSource);
     }
-    return (0, import_loader_utils11.toArrayBuffer)(bufferSource);
+    return toArrayBuffer2(bufferSource);
   }
   throw new Error(ERR_DATA);
 }
 async function getArrayBufferOrStringFromData(data, loader, options) {
-  if (typeof data === "string" || (0, import_loader_utils11.isArrayBufferLike)(data)) {
+  if (typeof data === "string" || isArrayBufferLike(data)) {
     return getArrayBufferOrStringFromDataSync(data, loader, options);
   }
-  if ((0, import_loader_utils11.isBlob)(data)) {
+  if (isBlob(data)) {
     data = await makeResponse(data);
   }
-  if ((0, import_loader_utils11.isResponse)(data)) {
+  if (isResponse(data)) {
     await checkResponse(data);
     return loader.binary ? await data.arrayBuffer() : await data.text();
   }
-  if ((0, import_loader_utils11.isReadableStream)(data)) {
+  if (isReadableStream(data)) {
     data = makeIterator(data, options);
   }
-  if ((0, import_loader_utils11.isIterable)(data) || (0, import_loader_utils11.isAsyncIterable)(data)) {
-    return (0, import_loader_utils11.concatenateArrayBuffersAsync)(data);
+  if (isIterable(data) || isAsyncIterable(data)) {
+    return concatenateArrayBuffersAsync(data);
   }
   throw new Error(ERR_DATA);
 }
@@ -1156,32 +2798,32 @@ async function getArrayBufferFromData(data, options) {
   if (typeof data === "string") {
     return new TextEncoder().encode(data).buffer;
   }
-  if ((0, import_loader_utils11.isArrayBufferLike)(data)) {
-    return (0, import_loader_utils11.toArrayBuffer)((0, import_loader_utils11.toArrayBufferView)(data));
+  if (isArrayBufferLike(data)) {
+    return toArrayBuffer2(toArrayBufferView(data));
   }
-  if ((0, import_loader_utils11.isBlob)(data)) {
+  if (isBlob(data)) {
     data = await makeResponse(data);
   }
-  if ((0, import_loader_utils11.isResponse)(data)) {
+  if (isResponse(data)) {
     await checkResponse(data);
     return await data.arrayBuffer();
   }
-  if ((0, import_loader_utils11.isReadableStream)(data)) {
+  if (isReadableStream(data)) {
     data = makeIterator(data, options);
   }
-  if ((0, import_loader_utils11.isIterable)(data) || (0, import_loader_utils11.isAsyncIterable)(data)) {
-    return (0, import_loader_utils11.concatenateArrayBuffersAsync)(data);
+  if (isIterable(data) || isAsyncIterable(data)) {
+    return concatenateArrayBuffersAsync(data);
   }
   throw new Error(ERR_DATA);
 }
 async function getAsyncIterableFromData(data, options) {
-  if ((0, import_loader_utils11.isPromise)(data)) {
+  if (isPromise(data)) {
     data = await data;
   }
-  if ((0, import_loader_utils11.isIterator)(data)) {
+  if (isIterator(data)) {
     return data;
   }
-  if ((0, import_loader_utils11.isResponse)(data)) {
+  if (isResponse(data)) {
     await checkResponse(data);
     const body = await data.body;
     if (!body) {
@@ -1189,63 +2831,68 @@ async function getAsyncIterableFromData(data, options) {
     }
     return makeIterator(body, options);
   }
-  if ((0, import_loader_utils11.isBlob)(data) || (0, import_loader_utils11.isReadableStream)(data)) {
+  if (isBlob(data) || isReadableStream(data)) {
     return makeIterator(data, options);
   }
-  if ((0, import_loader_utils11.isAsyncIterable)(data)) {
+  if (isAsyncIterable(data)) {
     return data;
   }
-  if ((0, import_loader_utils11.isIterable)(data)) {
+  if (isIterable(data)) {
     return data;
   }
   return getIterableFromData(data);
 }
 function getIterableFromData(data) {
   if (ArrayBuffer.isView(data)) {
-    return function* oneChunk() {
-      yield (0, import_loader_utils11.toArrayBuffer)(data);
-    }();
+    return (function* oneChunk() {
+      yield toArrayBuffer2(data);
+    })();
   }
-  if ((0, import_loader_utils11.isArrayBufferLike)(data)) {
-    return function* oneChunk() {
-      yield (0, import_loader_utils11.toArrayBuffer)(data);
-    }();
+  if (isArrayBufferLike(data)) {
+    return (function* oneChunk() {
+      yield toArrayBuffer2(data);
+    })();
   }
-  if ((0, import_loader_utils11.isIterator)(data)) {
+  if (isIterator(data)) {
     return data;
   }
-  if ((0, import_loader_utils11.isIterable)(data)) {
+  if (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;
+  var _a, _b;
   const globalOptions = getGlobalLoaderOptions();
   const loaderOptions = options || globalOptions;
   const fetchOption = loaderOptions.fetch ?? ((_a = loaderOptions.core) == null ? void 0 : _a.fetch);
+  let fetchFunction;
   if (typeof fetchOption === "function") {
-    return fetchOption;
-  }
-  if ((0, import_loader_utils12.isObject)(fetchOption)) {
-    return (url) => fetchFile(url, fetchOption);
+    fetchFunction = fetchOption;
+  } else if (isObject(fetchOption)) {
+    fetchFunction = (url, requestOptions) => fetchFile(url, mergeFetchOptions(fetchOption, requestOptions));
+  } else if (context == null ? void 0 : context.fetch) {
+    fetchFunction = context.fetch;
+  } else {
+    fetchFunction = fetchFile;
   }
-  if (context == null ? void 0 : context.fetch) {
-    return context == null ? void 0 : context.fetch;
+  return createAuthenticatedFetch({
+    fetch: fetchFunction,
+    credentials: ((_b = loaderOptions.core) == null ? void 0 : _b.credentials) || []
+  });
+}
+function mergeFetchOptions(defaultOptions, requestOptions) {
+  const options = { ...defaultOptions, ...requestOptions };
+  if (defaultOptions.headers || (requestOptions == null ? void 0 : requestOptions.headers)) {
+    const headers = new Headers(defaultOptions.headers);
+    new Headers(requestOptions == null ? void 0 : requestOptions.headers).forEach((value, key) => headers.set(key, value));
+    options.headers = headers;
   }
-  return fetchFile;
+  return options;
 }
 
-// dist/lib/loader-utils/loader-context.js
-var import_loader_utils17 = require("@loaders.gl/loader-utils");
-
-// dist/lib/api/parse-file.js
-var import_loader_utils13 = require("@loaders.gl/loader-utils");
-var import_worker_utils = require("@loaders.gl/worker-utils");
-
 // dist/lib/api/load-loader.js
 var loaderImplementationPromises = /* @__PURE__ */ new Map();
 var loaderImplementations = /* @__PURE__ */ new Map();
@@ -1327,10 +2974,7 @@ function getLoaderImplementationCacheKey(loader, options) {
   var _a;
   const loaderOptions = options == null ? void 0 : options[loader.id];
   const defaultLoaderOptions = (_a = loader.options) == null ? void 0 : _a[loader.id];
-  return String((loaderOptions == null ? void 0 : loaderOptions.backend) || getDeprecatedImplementationBackend(loaderOptions == null ? void 0 : loaderOptions.implementation) || (defaultLoaderOptions == null ? void 0 : defaultLoaderOptions.backend) || "");
-}
-function getDeprecatedImplementationBackend(implementation) {
-  return implementation === "js" ? "typescript" : implementation;
+  return String((loaderOptions == null ? void 0 : loaderOptions.backend) || (defaultLoaderOptions == null ? void 0 : defaultLoaderOptions.backend) || "");
 }
 async function importLoaderImplementation(implementationSpecifier, loaderId) {
   const moduleExports = await import(
@@ -1361,7 +3005,7 @@ async function parseFile(file, loaders, options, context) {
   if (!loader) {
     return null;
   }
-  if ((0, import_loader_utils13.isSourceLoader)(loader)) {
+  if (isSourceLoader(loader)) {
     throw new Error(`${loader.id} is a SourceLoader. Use load() to create a runtime source object instead of parseFile().`);
   }
   const strictOptions = normalizeOptions(options, loader, candidateLoaders, url);
@@ -1374,8 +3018,8 @@ async function parseFile(file, loaders, options, context) {
   return await parseFileWithLoader(loader, file, strictOptions, context);
 }
 async function parseFileWithLoader(loader, file, options, context) {
-  (0, import_worker_utils.validateWorkerVersion)(loader);
-  options = (0, import_loader_utils13.mergeOptions)(loader.options, options);
+  validateWorkerVersion(loader);
+  options = mergeOptions(loader.options, options);
   const loaderWithParser = await getLoaderImplementation(loader, options, context.url);
   if (loaderWithParser.parseFile) {
     return await loaderWithParser.parseFile(file, options, context);
@@ -1393,7 +3037,6 @@ async function parseFileWithLoader(loader, file, options, context) {
 }
 
 // dist/lib/api/parse-sync.js
-var import_loader_utils14 = require("@loaders.gl/loader-utils");
 function parseSync(data, loaders, options, context) {
   if (!Array.isArray(loaders) && !isLoaderObject(loaders)) {
     context = void 0;
@@ -1407,7 +3050,7 @@ function parseSync(data, loaders, options, context) {
   if (!loader) {
     return null;
   }
-  if ((0, import_loader_utils14.isSourceLoader)(loader)) {
+  if (isSourceLoader(loader)) {
     throw new Error(`${loader.id} is a SourceLoader. Use load() to create a runtime source object instead of parseSync().`);
   }
   const strictOptions = normalizeOptions(options, loader, candidateLoaders);
@@ -1433,9 +3076,50 @@ function parseWithLoaderSync(loader, data, options, context) {
   throw new Error(`${loader.name} loader: 'parseSync' not supported by this loader, use 'parse' instead. ${context.url || ""}`);
 }
 
+// ../schema-utils/src/lib/table/tables/table-accessors.ts
+function isTable(table) {
+  var _a;
+  const shape = typeof table === "object" && (table == null ? void 0 : table.shape);
+  switch (shape) {
+    case "array-row-table":
+    case "object-row-table":
+      return Array.isArray(table.data);
+    case "geojson-table":
+      return Array.isArray(table.features);
+    case "columnar-table":
+      return Boolean(table.data && typeof table.data === "object");
+    case "arrow-table":
+      return Boolean(((_a = table == null ? void 0 : table.data) == null ? void 0 : _a.numRows) !== void 0);
+    default:
+      return false;
+  }
+}
+function getTableLength(table) {
+  switch (table.shape) {
+    case "array-row-table":
+    case "object-row-table":
+      return table.data.length;
+    case "geojson-table":
+      return table.features.length;
+    case "arrow-table":
+      const arrowTable = table.data;
+      return arrowTable.numRows;
+    case "columnar-table":
+      for (const column of Object.values(table.data)) {
+        return column.length || 0;
+      }
+      return 0;
+    default:
+      throw new Error("table");
+  }
+}
+
+// ../schema-utils/src/lib/table/batches/make-table-batch-iterator.ts
+function makeBatchFromTable(table) {
+  return { ...table, length: getTableLength(table), batchType: "data" };
+}
+
 // dist/lib/api/parse-in-batches.js
-var import_schema_utils = require("@loaders.gl/schema-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)) {
@@ -1488,7 +3172,7 @@ async function parseToOutputIterator(loader, data, options, context) {
   return parseChunkInBatches(transformedIterator, loader, options, context);
 }
 async function* parseChunkInBatches(transformedIterator, loader, options, context) {
-  const arrayBuffer = await (0, import_loader_utils15.concatenateArrayBuffersAsync)(transformedIterator);
+  const arrayBuffer = await concatenateArrayBuffersAsync(transformedIterator);
   const parsedData = await parse(
     arrayBuffer,
     loader,
@@ -1500,7 +3184,7 @@ async function* parseChunkInBatches(transformedIterator, loader, options, contex
   yield batch;
 }
 function convertDataToBatch(parsedData, loader) {
-  const batch = (0, import_schema_utils.isTable)(parsedData) ? (0, import_schema_utils.makeBatchFromTable)(parsedData) : {
+  const batch = isTable(parsedData) ? makeBatchFromTable(parsedData) : {
     shape: "unknown",
     batchType: "data",
     data: parsedData,
@@ -1517,9 +3201,6 @@ async function applyInputTransforms(inputIterator, transforms = []) {
   return iteratorChain;
 }
 
-// dist/lib/api/load.js
-var import_loader_utils16 = require("@loaders.gl/loader-utils");
-
 // dist/lib/api/load-in-batches.js
 function loadInBatches(files, loaders, options, context) {
   let loadersArray;
@@ -1559,7 +3240,8 @@ async function load(url, loaders, options, context) {
     resolvedLoaders = loaders;
     resolvedOptions = options;
   }
-  if (!Array.isArray(resolvedLoaders) && (0, import_loader_utils16.isSourceLoader)(resolvedLoaders)) {
+  if (!Array.isArray(resolvedLoaders) && isSourceLoader(resolvedLoaders)) {
+    const sourceLoader = await resolveSourceLoader(resolvedLoaders, url, resolvedOptions);
     const runtimeCoreApi = {
       fetchFile,
       parse,
@@ -1569,9 +3251,10 @@ async function load(url, loaders, options, context) {
       load,
       loadInBatches
     };
-    return resolvedLoaders.createDataSource(url, resolvedOptions || {}, runtimeCoreApi);
+    return sourceLoader.createDataSource(url, resolvedOptions || {}, runtimeCoreApi);
   }
-  if (Array.isArray(resolvedLoaders) && resolvedLoaders.length === 1 && (0, import_loader_utils16.isSourceLoader)(resolvedLoaders[0])) {
+  if (Array.isArray(resolvedLoaders) && resolvedLoaders.length === 1 && isSourceLoader(resolvedLoaders[0])) {
+    const sourceLoader = await resolveSourceLoader(resolvedLoaders[0], url, resolvedOptions);
     const runtimeCoreApi = {
       fetchFile,
       parse,
@@ -1581,15 +3264,16 @@ async function load(url, loaders, options, context) {
       load,
       loadInBatches
     };
-    return resolvedLoaders[0].createDataSource(url, resolvedOptions || {}, runtimeCoreApi);
+    return sourceLoader.createDataSource(url, resolvedOptions || {}, runtimeCoreApi);
   }
-  if (typeof url === "string" || (0, import_loader_utils16.isBlob)(url)) {
+  if (typeof url === "string" || isBlob(url)) {
     const selectedLoader = await selectLoader(url, resolvedLoaders, {
       ...resolvedOptions,
       core: { ...resolvedOptions == null ? void 0 : resolvedOptions.core, nothrow: true }
     });
-    if (selectedLoader && (0, import_loader_utils16.isSourceLoader)(selectedLoader)) {
-      return selectedLoader.createDataSource(url, resolvedOptions || {}, {
+    if (selectedLoader && isSourceLoader(selectedLoader)) {
+      const sourceLoader = await resolveSourceLoader(selectedLoader, url, resolvedOptions);
+      return sourceLoader.createDataSource(url, resolvedOptions || {}, {
         fetchFile,
         parse,
         parseFile,
@@ -1599,13 +3283,19 @@ async function load(url, loaders, options, context) {
         loadInBatches
       });
     }
+    if (selectedLoader && typeof url === "string") {
+      const loaderImplementation = await getLoaderImplementation(selectedLoader, resolvedOptions, url);
+      const parseUrl = loaderImplementation.parseUrl;
+      if (parseUrl)
+        return await parseUrl(url, resolvedOptions, context);
+    }
   }
   const fetch2 = getFetchFunction(resolvedOptions);
   let data = url;
   if (typeof url === "string") {
     data = await fetch2(url);
   }
-  if ((0, import_loader_utils16.isBlob)(url)) {
+  if (isBlob(url)) {
     data = await fetch2(url);
   }
   if (typeof url === "string") {
@@ -1622,6 +3312,16 @@ async function load(url, loaders, options, context) {
   }
   return Array.isArray(resolvedLoaders) ? await parse(data, resolvedLoaders, resolvedOptions, context) : await parse(data, resolvedLoaders, resolvedOptions, context);
 }
+async function resolveSourceLoader(loader, url, options) {
+  if (!loader.preload) {
+    return loader;
+  }
+  const sourceLoader = await loader.preload(typeof url === "string" ? url : "", options);
+  if (!isSourceLoader(sourceLoader)) {
+    throw new Error(`${loader.id} source loader preload() did not return a runtime source loader`);
+  }
+  return sourceLoader;
+}
 
 // dist/lib/api/core-api.js
 var coreApi = Object.freeze({
@@ -1648,8 +3348,8 @@ function getLoaderContext(context, options, parentContext) {
     const baseUrl = stripQueryString(newContext.url);
     newContext.baseUrl = baseUrl;
     newContext.queryString = extractQueryString(newContext.url);
-    newContext.filename = import_loader_utils17.path.filename(baseUrl);
-    newContext.baseUrl = import_loader_utils17.path.dirname(baseUrl);
+    newContext.filename = path_exports.filename(baseUrl);
+    newContext.baseUrl = path_exports.dirname(baseUrl);
   }
   if (!Array.isArray(newContext.loaders)) {
     newContext.loaders = null;
@@ -1687,7 +3387,7 @@ async function parse(data, loaders, options, context) {
   if (!loader) {
     return null;
   }
-  if ((0, import_loader_utils18.isSourceLoader)(loader)) {
+  if (isSourceLoader(loader)) {
     throw new Error(`${loader.id} is a SourceLoader. Use load() to create a runtime source object instead of parse().`);
   }
   const strictOptions = normalizeOptions(options, loader, candidateLoaders, url);
@@ -1700,17 +3400,20 @@ async function parse(data, loaders, options, context) {
   return await parseWithLoader(loader, data, strictOptions, context);
 }
 async function parseWithLoader(loader, data, options, context) {
-  (0, import_worker_utils2.validateWorkerVersion)(loader);
-  options = (0, import_loader_utils18.mergeOptions)(loader.options, options);
-  if ((0, import_loader_utils18.isResponse)(data)) {
+  validateWorkerVersion(loader);
+  options = mergeOptions(loader.options, options);
+  if (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 };
   }
   const loaderWithParser = await getLoaderImplementation(loader, options, context.url);
-  if ((0, import_loader_utils18.canParseWithWorker)(loaderWithParser, options)) {
+  if (canParseWithWorker(loaderWithParser, options)) {
     data = await getArrayBufferFromData(data, options);
-    return await (0, import_loader_utils18.parseWithWorker)(loaderWithParser, data, options, context, parse);
+    return await parseWithWorker(loaderWithParser, data, options, context, parse);
+  }
+  if (isBlob(data) && loaderWithParser.parseBlob) {
+    return await loaderWithParser.parseBlob(data, options, context);
   }
   data = await getArrayBufferOrStringFromData(data, loader, options);
   return await parseWithLoaderImplementation(loaderWithParser, data, options, context);
@@ -1740,14 +3443,13 @@ function preloadSync(loader) {
 }
 
 // dist/lib/api/encode-table.js
-var import_loader_utils19 = 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 (0, import_loader_utils19.ensureArrayBuffer)(new TextEncoder().encode(text));
+    return ensureArrayBuffer(new TextEncoder().encode(text));
   }
   if (writer.encodeInBatches) {
     const batches = encodeTableInBatches(data, writer, options);
@@ -1755,7 +3457,7 @@ async function encodeTable(data, writer, options) {
     for await (const batch of batches) {
       chunks.push(batch);
     }
-    return (0, import_loader_utils19.concatenateArrayBuffers)(...chunks);
+    return concatenateArrayBuffers(...chunks);
   }
   throw new Error("Writer could not encode data");
 }
@@ -1782,16 +3484,14 @@ function getIterator(data) {
 }
 
 // dist/lib/api/encode.js
-var import_loader_utils20 = require("@loaders.gl/loader-utils");
-var import_worker_utils3 = require("@loaders.gl/worker-utils");
 async function encode(data, writer, options_) {
   const globalOptions = getGlobalLoaderOptions();
   const options = { ...globalOptions, ...options_ };
   if (writer.encodeURLtoURL) {
     return encodeWithCommandLineTool(writer, data, options);
   }
-  if ((0, import_loader_utils20.canEncodeWithWorker)(writer, options)) {
-    return await (0, import_worker_utils3.processOnWorker)(writer, data, options);
+  if (canEncodeWithWorker(writer, options)) {
+    return await processOnWorker(writer, data, options);
   }
   return await writer.encode(data, options);
 }
@@ -1800,7 +3500,7 @@ function encodeSync(data, writer, options) {
     return writer.encodeSync(data, options);
   }
   if (writer.encodeTextSync) {
-    return (0, import_loader_utils20.ensureArrayBuffer)(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`);
 }
@@ -1835,20 +3535,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_utils20.resolvePath)(inputUrl);
-  outputUrl = (0, import_loader_utils20.resolvePath)(outputUrl);
-  if (import_loader_utils20.isBrowser || !writer.encodeURLtoURL) {
+  inputUrl = resolvePath(inputUrl);
+  outputUrl = resolvePath(outputUrl);
+  if (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_utils20.isBrowser) {
+  if (isBrowser) {
     throw new Error(`Writer ${writer.name} not supported in browser`);
   }
   const tmpInputFilename = getTemporaryFilename("input");
-  const file = new import_loader_utils20.NodeFile(tmpInputFilename, "w");
+  const file = new NodeFileFacade(tmpInputFilename, "w");
   await file.write(data);
   const tmpOutputFilename = getTemporaryFilename("output");
   const outputFilename = await encodeURLtoURL(tmpInputFilename, tmpOutputFilename, writer, options);
@@ -1859,8 +3559,8 @@ function getIterator2(data) {
   const dataIterator = [{ ...data, start: 0, end: data.length }];
   return dataIterator;
 }
-function getTemporaryFilename(filename) {
-  return `/tmp/${filename}`;
+function getTemporaryFilename(filename2) {
+  return `/tmp/${filename2}`;
 }
 
 // dist/lib/api/create-data-source.js
@@ -1911,10 +3611,6 @@ function getSourceOfType2(type, sources) {
   return null;
 }
 
-// dist/index.js
-var import_loader_utils22 = require("@loaders.gl/loader-utils");
-var import_loader_utils23 = require("@loaders.gl/loader-utils");
-
 // dist/iterators/make-stream/make-stream.js
 function makeStream(source, options) {
   if (globalThis.loaders.makeNodeStream) {
@@ -1955,14 +3651,14 @@ function makeStream(source, options) {
 }
 
 // dist/null-loader.js
-var VERSION = true ? "5.0.0-alpha.1" : "latest";
+var VERSION4 = true ? "5.0.0-alpha.3" : "latest";
 var NullWorkerLoader = {
   dataType: null,
   batchType: null,
   name: "Null loader",
   id: "null",
   module: "core",
-  version: VERSION,
+  version: VERSION4,
   worker: true,
   mimeTypes: ["application/x.empty"],
   extensions: ["null"],
@@ -1977,7 +3673,7 @@ var NullLoader = {
   name: "Null loader",
   id: "null",
   module: "core",
-  version: VERSION,
+  version: VERSION4,
   mimeTypes: ["application/x.empty"],
   extensions: ["null"],
   parse: async (arrayBuffer, options, context) => parseSync2(arrayBuffer, options || {}, context),
@@ -1996,9 +3692,6 @@ function parseSync2(arrayBuffer, options, context) {
   return null;
 }
 
-// dist/index.js
-var import_loader_utils24 = require("@loaders.gl/loader-utils");
-
 // dist/lib/progress/fetch-progress.js
 async function fetchProgress(response, onProgress, onDone = () => {
 }, onError = () => {
@@ -2047,7 +3740,6 @@ async function read(controller, reader, loadedBytes, totalBytes, onProgress, onD
 }
 
 // dist/lib/filesystems/browser-filesystem.js
-var import_loader_utils21 = require("@loaders.gl/loader-utils");
 var BrowserFileSystem = class {
   _fetch;
   files = {};
@@ -2073,27 +3765,38 @@ var BrowserFileSystem = class {
    * Implementation of fetch against this file system
    * Delegates to global fetch for http{s}:// or data://
    */
-  async fetch(path4, options) {
-    if (path4.includes("://")) {
-      return this._fetch(path4, options);
+  async fetch(path, options) {
+    if (path.includes("://")) {
+      return this._fetch(path, options);
     }
-    const file = this.files[path4];
+    const file = this._getFile(path, true);
     if (!file) {
-      return new Response(path4, { status: 400, statusText: "NOT FOUND" });
+      return new Response(path, { status: 400, statusText: "NOT FOUND" });
     }
     const headers = new Headers(options == null ? void 0 : options.headers);
     const range = headers.get("Range");
-    const bytes = range && /bytes=($1)-($2)/.exec(range);
+    const bytes = range && /bytes=(\d+)-(\d+)/.exec(range);
     if (bytes) {
       const start = parseInt(bytes[1]);
-      const end = parseInt(bytes[2]);
-      const data = await file.slice(start, end).arrayBuffer();
-      const response2 = new Response(data);
-      Object.defineProperty(response2, "url", { value: path4 });
+      const end = Math.min(parseInt(bytes[2]), file.size - 1);
+      if (start > end) {
+        const response3 = new Response(null, {
+          status: 416,
+          headers: { "Content-Range": `bytes */${file.size}` }
+        });
+        Object.defineProperty(response3, "url", { value: path });
+        return response3;
+      }
+      const data = await file.slice(start, end + 1).arrayBuffer();
+      const response2 = new Response(data, {
+        status: 206,
+        headers: { "Content-Range": `bytes ${start}-${end}/${file.size}` }
+      });
+      Object.defineProperty(response2, "url", { value: path });
       return response2;
     }
     const response = new Response(file);
-    Object.defineProperty(response, "url", { value: path4 });
+    Object.defineProperty(response, "url", { value: path });
     return response;
   }
   /**
@@ -2101,51 +3804,47 @@ var BrowserFileSystem = class {
    * @param dirname
    * @returns
    */
-  async readdir(dirname) {
+  async readdir(dirname2) {
     const files = [];
-    for (const path4 in this.files) {
-      files.push(path4);
+    for (const path in this.files) {
+      files.push(path);
     }
     return files;
   }
   /**
    * Return information (size) about files in this file system
    */
-  async stat(path4, options) {
-    const file = this.files[path4];
+  async stat(path, options) {
+    const file = this._getFile(path, false);
     if (!file) {
-      throw new Error(path4);
+      throw new Error(path);
     }
     return { size: file.size };
   }
   /**
    * Just removes the file from the list
    */
-  async unlink(path4) {
-    delete this.files[path4];
-    delete this.lowerCaseFiles[path4];
-    this.usedFiles[path4] = true;
+  async unlink(path) {
+    const file = this._getFile(path, false);
+    if (file) {
+      delete this.files[file.name];
+      delete this.lowerCaseFiles[file.name.toLowerCase()];
+      this.usedFiles[file.name] = true;
+    }
   }
   // implements IRandomAccessFileSystem
   // RANDOM ACCESS
   async openReadableFile(pathname, flags) {
-    return new import_loader_utils21.BlobFile(this.files[pathname]);
+    return new BlobFile(this._getFile(pathname, true));
   }
   // PRIVATE
   // Supports case independent paths, and file usage tracking
-  _getFile(path4, used) {
-    const file = this.files[path4] || this.lowerCaseFiles[path4];
+  _getFile(path, used) {
+    const file = this.files[path] || this.lowerCaseFiles[path.toLowerCase()];
     if (file && used) {
-      this.usedFiles[path4] = true;
+      this.usedFiles[path] = true;
     }
     return file;
   }
 };
-
-// dist/index.js
-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");
-var import_loader_utils28 = require("@loaders.gl/loader-utils");
-var import_loader_utils29 = require("@loaders.gl/loader-utils");
 //# sourceMappingURL=index.cjs.map