@loaders.gl/core 4.5.3 → 5.0.0-alpha.10

package/dist/index.cjs

@@ -18,21 +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_utils22.JSONLoader,
+  JSONLoader: () => JSONLoader,
   NullLoader: () => NullLoader,
   NullWorkerLoader: () => NullWorkerLoader,
-  RequestScheduler: () => import_loader_utils21.RequestScheduler,
+  RequestScheduler: () => RequestScheduler,
   _BrowserFileSystem: () => BrowserFileSystem,
   _fetchProgress: () => fetchProgress,
-  _selectSource: () => selectSource2,
+  _selectSource: () => selectSource,
   _unregisterLoaders: () => _unregisterLoaders,
-  assert: () => import_loader_utils24.assert,
-  concatenateArrayBuffersAsync: () => import_loader_utils25.concatenateArrayBuffersAsync,
+  assert: () => assert,
+  concatenateArrayBuffersAsync: () => concatenateArrayBuffersAsync,
+  coreApi: () => coreApi,
   createDataSource: () => createDataSource,
-  document: () => import_loader_utils23.document,
+  document: () => document_,
   encode: () => encode,
   encodeInBatches: () => encodeInBatches,
   encodeSync: () => encodeSync,
@@ -43,48 +44,2231 @@ __export(dist_exports, {
   encodeTextSync: () => encodeTextSync,
   encodeURLtoURL: () => encodeURLtoURL,
   fetchFile: () => fetchFile,
-  forEach: () => import_loader_utils25.forEach,
+  forEach: () => forEach,
   getLoaderOptions: () => getGlobalLoaderOptions,
-  getPathPrefix: () => import_loader_utils20.getPathPrefix,
-  global: () => import_loader_utils23.global,
-  isAsyncIterable: () => import_loader_utils27.isAsyncIterable,
-  isBrowser: () => import_loader_utils23.isBrowser,
-  isIterable: () => import_loader_utils27.isIterable,
-  isIterator: () => import_loader_utils27.isIterator,
-  isPromise: () => import_loader_utils27.isPromise,
-  isPureObject: () => import_loader_utils27.isPureObject,
-  isReadableStream: () => import_loader_utils27.isReadableStream,
-  isResponse: () => import_loader_utils27.isResponse,
-  isWorker: () => import_loader_utils23.isWorker,
-  isWritableStream: () => import_loader_utils27.isWritableStream,
+  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_utils26.makeLineIterator,
-  makeNumberedLineIterator: () => import_loader_utils26.makeNumberedLineIterator,
+  makeLineIterator: () => makeLineIterator,
+  makeNumberedLineIterator: () => makeNumberedLineIterator,
   makeStream: () => makeStream,
-  makeTextDecoderIterator: () => import_loader_utils26.makeTextDecoderIterator,
-  makeTextEncoderIterator: () => import_loader_utils26.makeTextEncoderIterator,
+  makeTextDecoderIterator: () => makeTextDecoderIterator,
+  makeTextEncoderIterator: () => makeTextEncoderIterator,
   parse: () => parse,
+  parseFile: () => parseFile,
   parseInBatches: () => parseInBatches,
   parseSync: () => parseSync,
+  preload: () => preload,
+  preloadSync: () => preloadSync,
   readArrayBuffer: () => readArrayBuffer,
   registerLoaders: () => registerLoaders,
-  resolvePath: () => import_loader_utils20.resolvePath,
+  resolvePath: () => resolvePath,
   selectLoader: () => selectLoader,
   selectLoaderSync: () => selectLoaderSync,
-  self: () => import_loader_utils23.self,
+  self: () => self_,
   setLoaderOptions: () => setGlobalOptions,
-  setPathPrefix: () => import_loader_utils20.setPathPrefix,
-  window: () => import_loader_utils23.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.");
+  }
+}
+
+// ../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;
+  /** Lazily resolves the classic worker URL used as a fallback. */
+  getUrl;
+  /** Creates a browser Worker directly. */
+  loadWorker;
+  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, getUrl, loadWorker } = props;
+    assert2(source || url || getUrl || loadWorker);
+    this.name = name;
+    this.source = source;
+    this.url = url;
+    this.getUrl = getUrl;
+    this.loadWorker = loadWorker;
+    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 || "built-in worker factory"}. `;
+    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() {
+    var _a;
+    if (this.loadWorker) {
+      try {
+        const worker2 = this.loadWorker();
+        if (worker2) {
+          return this._initializeBrowserWorker(worker2);
+        }
+      } catch (error) {
+        if (!this.source && !this.url && !this.getUrl) {
+          throw error;
+        }
+      }
+    }
+    const url = this.url || ((_a = this.getUrl) == null ? void 0 : _a.call(this));
+    this._loadableURL = getLoadableWorkerURL({ source: this.source, url });
+    const worker = new Worker(this._loadableURL, { name: this.name });
+    return this._initializeBrowserWorker(worker);
+  }
+  /** Attaches protocol handlers to a browser worker. */
+  _initializeBrowserWorker(worker) {
+    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;
+  /** Lazily resolves a classic worker fallback URL. */
+  getUrl;
+  /** Creates a browser Worker directly. */
+  loadWorker;
+  maxConcurrency = 1;
+  maxMobileConcurrency = 1;
+  onDebug = () => {
+  };
+  reuseWorkers = true;
+  props = {};
+  jobQueue = [];
+  idleQueue = [];
+  activeJobs = /* @__PURE__ */ new Set();
+  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.getUrl = props.getUrl;
+    this.loadWorker = props.loadWorker;
+    this.setProps(props);
+  }
+  /**
+   * Terminates all workers in the pool and aborts active jobs.
+   * @param reason Optional error delivered to active jobs.
+   * @note Can free up significant memory
+   */
+  destroy(reason = new Error("Worker pool was destroyed")) {
+    this.activeJobs.forEach((job) => job.abort(reason));
+    const queuedJobs = this.jobQueue.splice(0);
+    queuedJobs.forEach((queuedJob) => queuedJob.onReject(reason));
+    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)) {
+    if (this.isDestroyed) {
+      return Promise.reject(new Error("Worker pool was destroyed"));
+    }
+    const startPromise = new Promise((onStart, onReject) => {
+      this.jobQueue.push({ name, onMessage: onMessage2, onError, onStart, onReject });
+      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);
+      this.activeJobs.add(job);
+      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.activeJobs.delete(job);
+        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,
+        getUrl: this.getUrl,
+        loadWorker: this.loadWorker
+      });
+    }
+    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 loadWorkerIds = /* @__PURE__ */ new WeakMap();
+var nextLoadWorkerId = 1;
+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 and abort active jobs.
+   * @param reason Optional error delivered to active jobs.
+   * @note Can free up significant memory
+   */
+  destroy(reason) {
+    for (const workerPool of this.workerPools.values()) {
+      workerPool.destroy(reason);
+    }
+    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 Worker target used to identify and initialize the pool.
+   * @param options.name Worker name used as the base pool identity.
+   * @param options.url Worker script URL.
+   * @param options.source Inline worker source.
+   * @param options.loadWorker Built-in browser worker factory.
+   * @example
+   *   const job = WorkerFarm.getWorkerFarm().getWorkerPool({name, url}).startJob(...);
+   */
+  getWorkerPool(options) {
+    const { name, source, url, getUrl, loadWorker } = options;
+    const workerPoolKey = getWorkerPoolKey(options);
+    let workerPool = this.workerPools.get(workerPoolKey);
+    if (!workerPool) {
+      workerPool = new WorkerPool({
+        name,
+        source,
+        url,
+        getUrl,
+        loadWorker
+      });
+      workerPool.setProps(this._getWorkerPoolProps());
+      this.workerPools.set(workerPoolKey, workerPool);
+    }
+    return workerPool;
+  }
+  _getWorkerPoolProps() {
+    return {
+      maxConcurrency: this.props.maxConcurrency,
+      maxMobileConcurrency: this.props.maxMobileConcurrency,
+      reuseWorkers: this.props.reuseWorkers,
+      onDebug: this.props.onDebug
+    };
+  }
+};
+function getWorkerPoolKey(options) {
+  const { name, source, url, urlKey, loadWorker } = options;
+  const sourceKey = source ? `source:${source}` : "";
+  const urlKeyPart = url || urlKey ? `url:${url || urlKey}` : "";
+  const loadWorkerKey = loadWorker ? `loadWorker:${getLoadWorkerId(loadWorker)}` : "";
+  return [name, sourceKey, urlKeyPart, loadWorkerKey].filter(Boolean).join("|");
+}
+function getLoadWorkerId(loadWorker) {
+  let loadWorkerId = loadWorkerIds.get(loadWorker);
+  if (!loadWorkerId) {
+    loadWorkerId = nextLoadWorkerId++;
+    loadWorkerIds.set(loadWorker, loadWorkerId);
+  }
+  return loadWorkerId;
+}
+
+// ../worker-utils/src/lib/async-queue/async-queue.ts
+var AsyncQueue = class {
+  _values;
+  _settlers;
+  _closed;
+  constructor() {
+    this._values = [];
+    this._settlers = [];
+    this._closed = false;
+  }
+  /** Return an async iterator for this queue */
+  [Symbol.asyncIterator]() {
+    return this;
+  }
+  /** Push a new value - the async iterator will yield a promise resolved to this value */
+  push(value) {
+    return this.enqueue(value);
+  }
+  /**
+   * Push a new value - the async iterator will yield a promise resolved to this value
+   * Add an error - the async iterator will yield a promise rejected with this value
+   */
+  enqueue(value) {
+    if (this._closed) {
+      throw new Error("Closed");
+    }
+    if (this._settlers.length > 0) {
+      if (this._values.length > 0) {
+        throw new Error("Illegal internal state");
+      }
+      const settler = this._settlers.shift();
+      if (value instanceof Error) {
+        settler.reject(value);
+      } else {
+        settler.resolve({ value });
+      }
+    } else {
+      this._values.push(value);
+    }
+  }
+  /** Indicate that we not waiting for more values - The async iterator will be done */
+  close() {
+    while (this._settlers.length > 0) {
+      const settler = this._settlers.shift();
+      settler.resolve({ done: true });
+    }
+    this._closed = true;
+  }
+  // ITERATOR IMPLEMENTATION
+  /** @returns a Promise for an IteratorResult */
+  next() {
+    if (this._values.length > 0) {
+      const value = this._values.shift();
+      if (value instanceof Error) {
+        return Promise.reject(value);
+      }
+      return Promise.resolve({ done: false, value });
+    }
+    if (this._closed) {
+      if (this._settlers.length > 0) {
+        throw new Error("Illegal internal state");
+      }
+      return Promise.resolve({ done: true, value: void 0 });
+    }
+    return new Promise((resolve2, reject) => {
+      this._settlers.push({ resolve: resolve2, reject });
+    });
+  }
+};
+
+// ../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 getCustomWorkerURL(worker, options = {}) {
+  var _a;
+  const workerOptions = options[worker.id] || {};
+  const workerFile = isBrowser2 ? worker.workerFile || `${worker.id}-worker.js` : worker.workerNode || `${worker.id}-worker-node.js`;
+  let url = workerOptions.workerUrl;
+  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 (!url && workerType === "test") {
+    if (isBrowser2) {
+      url = `modules/${worker.module}/dist/${workerFile}`;
+    } else {
+      url = `modules/${worker.module}/src/workers/${worker.id}-worker-node.ts`;
+    }
+  }
+  return url || null;
+}
+function getWorkerURL(worker, options = {}) {
+  const customWorkerUrl = getCustomWorkerURL(worker, options);
+  const descriptorWorkerUrl = typeof worker.worker === "string" ? worker.worker : null;
+  const url = customWorkerUrl || descriptorWorkerUrl || getDefaultWorkerURL(worker, true);
+  assert2(url);
+  return url;
+}
+function getDefaultWorkerURL(worker, warn = false) {
+  const workerFile = isBrowser2 ? worker.workerFile || `${worker.id}-worker.js` : worker.workerNode || `${worker.id}-worker-node.js`;
+  let version2 = worker.version;
+  if (version2 === "latest") {
+    version2 = NPM_TAG;
+  }
+  const versionTag = version2 ? `@${version2}` : "";
+  const url = `https://unpkg.com/@loaders.gl/${worker.module}${versionTag}/dist/${workerFile}`;
+  if (warn) {
+    warnIfUsingNpmTagFallback(worker, 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 || worker.loadWorker || (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 workerPool = workerFarm.getWorkerPool(getWorkerPoolTarget(worker, options, name));
+  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 processOnWorkerInBatches(worker, input, options = {}, context = {}, jobContext = {}) {
+  return processOnWorkerInBatchesIterator(worker, input, options, context, jobContext);
+}
+async function* processOnWorkerInBatchesIterator(worker, input, options, context, jobContext) {
+  var _a, _b, _c;
+  throwIfAborted(options.signal);
+  const name = getWorkerName(worker);
+  const workerFarm = WorkerFarm.getWorkerFarm(options);
+  const workerPool = workerFarm.getWorkerPool(getWorkerPoolTarget(worker, options, name));
+  const outputBatches = new AsyncQueue();
+  const inputIterator = getAsyncIterator(input);
+  let outputFinished = false;
+  let inputFinished = false;
+  let inputRequest = Promise.resolve();
+  const batchJobFailed = new Error("Worker batch job failed");
+  const finishOutput = () => {
+    if (!outputFinished) {
+      outputFinished = true;
+      outputBatches.close();
+    }
+  };
+  const failOutput = (_error) => {
+    if (!outputFinished) {
+      outputFinished = true;
+      outputBatches.enqueue(batchJobFailed);
+      outputBatches.close();
+    }
+  };
+  const job = await workerPool.startJob(
+    options.jobName || worker.name,
+    (activeJob, type, payload) => {
+      switch (type) {
+        case "input-request":
+          inputRequest = inputRequest.then(async () => {
+            const nextBatch = await inputIterator.next();
+            if (!activeJob.isRunning) {
+              return;
+            }
+            if (nextBatch.done) {
+              inputFinished = true;
+              activeJob.postMessage("input-done", {});
+            } else {
+              activeJob.postMessage("input-batch", { input: nextBatch.value });
+            }
+          }).catch((error) => activeJob.abort(error));
+          break;
+        case "output-batch":
+          outputBatches.push(payload.result);
+          break;
+        case "done":
+          activeJob.done(payload);
+          finishOutput();
+          break;
+        case "error": {
+          const error = new Error(payload.error || "Worker batch processing failed");
+          activeJob.error(error);
+          failOutput(error);
+          break;
+        }
+        case "process":
+          void onMessage(context, activeJob, type, payload);
+          break;
+        default: {
+          const error = new Error(`Unexpected worker batch message: ${type}`);
+          activeJob.error(error);
+          failOutput(error);
+          break;
+        }
+      }
+    }
+  );
+  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();
+  }
+  void job.result.catch(failOutput);
+  try {
+    const { signal: _signal, ...workerOptions } = options;
+    if (job.isRunning) {
+      job.postMessage("process-in-batches", {
+        options: getTransferListForWriter(workerOptions),
+        context: getTransferListForWriter(jobContext)
+      });
+    }
+    try {
+      for await (const outputBatch of outputBatches) {
+        yield outputBatch;
+        if (job.isRunning) {
+          job.postMessage("output-ack", {});
+        }
+      }
+    } catch (error) {
+      if (error === batchJobFailed) {
+        await job.result;
+      }
+      throw error;
+    }
+    await job.result;
+  } finally {
+    (_c = options.signal) == null ? void 0 : _c.removeEventListener("abort", abortJob);
+    if (job.isRunning) {
+      job.abort(createAbortError2("Worker batch iterator was closed"));
+    }
+    if (!inputFinished) {
+      closeInputIterator(inputIterator);
+    }
+  }
+}
+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;
+}
+function getAsyncIterator(input) {
+  if (Symbol.asyncIterator in input) {
+    return input[Symbol.asyncIterator]();
+  }
+  return (async function* iterateSynchronously() {
+    yield* input;
+  })();
+}
+function closeInputIterator(inputIterator) {
+  var _a;
+  try {
+    void Promise.resolve((_a = inputIterator.return) == null ? void 0 : _a.call(inputIterator)).catch(() => void 0);
+  } catch {
+  }
+}
+function getWorkerPoolTarget(worker, options, name) {
+  if (options.source) {
+    return { name, source: options.source };
+  }
+  const customWorkerUrl = getCustomWorkerURL(worker, options);
+  if (customWorkerUrl) {
+    return { name, url: customWorkerUrl };
+  }
+  if (isBrowser2 && worker.loadWorker) {
+    return {
+      name,
+      loadWorker: worker.loadWorker,
+      getUrl: () => getWorkerURL(worker, options),
+      urlKey: getDefaultWorkerURL(worker)
+    };
+  }
+  return { name, url: getWorkerURL(worker, options) };
+}
+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, _c;
+  if ((_b = (_a = options == null ? void 0 : options.core) == null ? void 0 : _a.credentials) == null ? void 0 : _b.some(
+    (credential) => credential.type === "request" || "token" in credential && typeof credential.token === "function"
+  ))
+    return false;
+  const workerOptions = getWorkerOptions(options);
+  const nodeWorkers = workerOptions._nodeWorkers;
+  if (!isBrowser2 && !nodeWorkers) {
+    return false;
+  }
+  if (loader.id === "las" && (((_c = options == null ? void 0 : options.las) == null ? void 0 : _c.shape) ?? "arrow-table") === "arrow-table") {
+    return false;
+  }
+  if (loader.id === "csv" && !shouldParseCSVWithWorker(options)) {
+    return false;
+  }
+  return Boolean(canProcessOnWorker(loader, workerOptions));
+}
+function shouldParseWithWorker(loader, data, options, context, estimateLoader = loader) {
+  var _a, _b;
+  if (!canParseWithWorker(loader, options)) {
+    return false;
+  }
+  if (((_a = options == null ? void 0 : options.core) == null ? void 0 : _a.worker) !== "auto" || !estimateLoader.getWorkerEstimate) {
+    return true;
+  }
+  try {
+    const estimate = estimateLoader.getWorkerEstimate(data, options, context);
+    if (estimate === void 0 || !Number.isFinite(estimate) || estimate < 0 || estimate > 1) {
+      return true;
+    }
+    return estimate >= (((_b = options.core) == null ? void 0 : _b.workerThreshold) ?? 0.1);
+  } catch {
+    return true;
+  }
+}
+async function parseWithWorker(loader, data, options, context, parseOnMainThread, signal) {
+  const workerSignal = signal || getWorkerAbortSignal(options);
+  const result = await processOnWorker(
+    loader,
+    data,
+    { ...getWorkerOptions(options, loader), signal: workerSignal },
+    {
+      process: async (input, processOptions, _workerContext, parseContext) => {
+        if (!parseOnMainThread) {
+          throw new Error("Worker not set up to parse on main thread");
+        }
+        const { _loaderIds, _loaderIsArray, ...workerParseContext } = parseContext || {};
+        const mainThreadContext = context || parseContext ? { ...context, ...workerParseContext } : void 0;
+        return await callParseOnMainThread(
+          parseOnMainThread,
+          input,
+          processOptions,
+          mainThreadContext,
+          resolveWorkerLoaders(loader, _loaderIds, _loaderIsArray, context, options)
+        );
+      }
+    },
+    getSerializableLoaderContext(context)
+  );
+  return isLoaderWithWorkerResultDeserializer(loader) ? loader.deserializeWorkerResult(result, options, context) : result;
+}
+async function* parseWithWorkerInBatches(loader, inputIterator, options, context, parseOnMainThread, signal) {
+  const workerSignal = signal || getWorkerAbortSignal(options);
+  const outputIterator = processOnWorkerInBatches(
+    loader,
+    inputIterator,
+    { ...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 { _loaderIds, _loaderIsArray, ...workerParseContext } = parseContext || {};
+        const mainThreadContext = context || parseContext ? { ...context, ...workerParseContext } : void 0;
+        return await callParseOnMainThread(
+          parseOnMainThread,
+          input,
+          processOptions,
+          mainThreadContext,
+          resolveWorkerLoaders(loader, _loaderIds, _loaderIsArray, context, options)
+        );
+      }
+    },
+    getSerializableLoaderContext(context)
+  );
+  for await (const batch of outputIterator) {
+    yield loader.deserializeWorkerBatch ? loader.deserializeWorkerBatch(batch, options, context) : batch;
+  }
+}
+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, loaders) {
+  if (!loaders && parseOnMainThread.length <= 2) {
+    return parseOnMainThread(input, options);
+  }
+  return parseOnMainThread(input, loaders, options, context);
+}
+function resolveWorkerLoaders(loader, loaderIds, loaderIsArray, context, options) {
+  if (!loaderIds) return void 0;
+  const availableLoaders = /* @__PURE__ */ new Map();
+  const visitedLoaders = /* @__PURE__ */ new Set();
+  for (const candidate of [loader, ...(context == null ? void 0 : context.loaders) || []]) {
+    visitLoader(candidate);
+  }
+  const selectedLoaders = loaderIds.map((loaderId) => {
+    const selectedLoader = availableLoaders.get(loaderId);
+    if (!selectedLoader) {
+      throw new Error(
+        `Worker requested unknown loader "${loaderId}". Declare it in loader.subloaders or pass it in context.loaders.`
+      );
+    }
+    return selectedLoader;
+  });
+  return loaderIsArray ? selectedLoaders : selectedLoaders[0];
+  function visitLoader(candidate) {
+    var _a, _b;
+    if (visitedLoaders.has(candidate)) return;
+    visitedLoaders.add(candidate);
+    availableLoaders.set(candidate.id, candidate);
+    for (const [name, dependency] of Object.entries(candidate.subloaders || {})) {
+      const replacement = ((_b = (_a = options == null ? void 0 : options.core) == null ? void 0 : _a.subloaders) == null ? void 0 : _b[name]) || dependency;
+      visitLoader(replacement);
+      availableLoaders.set(dependency.id, replacement);
+    }
+  }
+}
+function getWorkerOptions(options = {}, loader) {
+  const serializedOptions = JSON.parse(
+    JSON.stringify({
+      ...options,
+      ...options.core ? { core: { ...options.core, authentications: void 0 } } : {}
+    })
+  );
+  const workerOptions = {
+    ...serializedOptions.core,
+    ...serializedOptions
+  };
+  if (workerOptions.worker === "auto") {
+    workerOptions.worker = true;
+  }
+  if (loader) {
+    workerOptions._workerLoaderId = loader.id;
+  }
+  return workerOptions;
+}
+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/binary-utils/encode-array-buffer-to-base64.ts
+function encodeArrayBufferToBase64(arrayBuffer) {
+  const bytes = new Uint8Array(arrayBuffer);
+  const encodedChunks = [];
+  const chunkByteLength = 3 * 4096;
+  for (let byteOffset = 0; byteOffset < bytes.length; byteOffset += chunkByteLength) {
+    encodedChunks.push(
+      btoa(String.fromCharCode(...bytes.subarray(byteOffset, byteOffset + chunkByteLength)))
+    );
+  }
+  return encodedChunks.join("");
+}
+
+// ../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);
+    }
+  };
+}
 
-// dist/lib/utils/response-utils.js
-var import_loader_utils2 = require("@loaders.gl/loader-utils");
+// ../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();
+  /** Pending arrival debounce or next-tick refill; only new arrivals replace this timer. */
+  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.scheduleRefill();
+      }
+    };
+    this.activeRequestCount++;
+    return resolve2 ? resolve2({ done }) : Promise.resolve({ done });
+  }
+  /** Refills freed slots on the next tick while preserving any pending arrival debounce. */
+  scheduleRefill() {
+    if (this.updateTimer !== null) {
+      return;
+    }
+    this.updateTimer = setTimeout(() => this._issueNewRequestsAsync(), 0);
+  }
+  /** Restarts the quiet period when a new request enters the queue. */
+  _issueNewRequests() {
+    if (this.updateTimer !== null) {
+      clearTimeout(this.updateTimer);
+    }
+    this.updateTimer = setTimeout(() => this._issueNewRequestsAsync(), this.props.debounceTime);
+  }
+  /** Clears timer ownership before updating priorities and dispatching queued 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/authentication.ts
+function resolveCredentials(credentials, authentications = []) {
+  if (credentials.every(isAuthentication)) return credentials;
+  return credentials.map((credential, index) => {
+    if (isAuthentication(credential)) return credential;
+    const AuthenticationClass = authentications.find(
+      (authentication2) => authentication2.type === (credential == null ? void 0 : credential.type)
+    );
+    if (!AuthenticationClass) {
+      throw new Error(`No authentication class registered for credential at index ${index}.`);
+    }
+    let authentication;
+    try {
+      authentication = new AuthenticationClass(credential);
+    } catch {
+      throw new Error(`Invalid authentication configuration at index ${index}.`);
+    }
+    if (!isAuthentication(authentication)) {
+      throw new Error(`Authentication class returned an invalid credential at index ${index}.`);
+    }
+    return authentication;
+  });
+}
+function resolveAuthenticationOptions(options) {
+  var _a, _b;
+  if (!((_b = (_a = options.core) == null ? void 0 : _a.credentials) == null ? void 0 : _b.length)) return options;
+  const credentials = resolveCredentials(options.core.credentials, options.core.authentications);
+  if (credentials === options.core.credentials) return options;
+  return { ...options, core: { ...options.core, credentials } };
+}
+async function resolveLoaderAuthenticationOptions(loader, url, options) {
+  var _a, _b, _c, _d;
+  if (!((_b = (_a = options.core) == null ? void 0 : _a.credentials) == null ? void 0 : _b.length) || options.core.credentials.every(isAuthentication)) {
+    return options;
+  }
+  const contributions = await ((_c = loader == null ? void 0 : loader.getAuthentications) == null ? void 0 : _c.call(loader, url, options));
+  if (!(contributions == null ? void 0 : contributions.length)) return resolveAuthenticationOptions(options);
+  return resolveAuthenticationOptions({
+    ...options,
+    core: {
+      ...options.core,
+      authentications: [...((_d = options.core) == null ? void 0 : _d.authentications) || [], ...contributions]
+    }
+  });
+}
+function isAuthentication(credential) {
+  if (!credential || typeof credential !== "object") return false;
+  if (typeof credential.id !== "string" || !Array.isArray(credential.origins)) return false;
+  if (credential.type === "request") return typeof credential.authenticate === "function";
+  return (credential.type === "header" || credential.type === "query-parameter") && typeof credential.name === "string" && (typeof credential.token === "string" || typeof credential.token === "function") && Array.isArray(credential.refreshStatusCodes);
+}
+
+// ../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 suppliedFetch = options.fetch || ((url, requestOptions) => fetch(url, requestOptions));
+  const existingMetadata = suppliedFetch[AUTHENTICATED_FETCH];
+  const credentialResolutions = new Map(existingMetadata == null ? void 0 : existingMetadata.credentialResolutions);
+  const resolvedCredentials = resolveCredentials(
+    options.credentials.map((credential) => credentialResolutions.get(credential) || credential),
+    options.authentications
+  );
+  options.credentials.forEach((credential, index) => {
+    credentialResolutions.set(credential, resolvedCredentials[index]);
+  });
+  if (!options.fetchOptions && (!resolvedCredentials.length || (existingMetadata == null ? void 0 : existingMetadata.credentials.length) === resolvedCredentials.length && resolvedCredentials.every(
+    (credential, index) => credential === existingMetadata.credentials[index]
+  )))
+    return suppliedFetch;
+  const baseFetch = (existingMetadata == null ? void 0 : existingMetadata.fetch) || suppliedFetch;
+  const credentials = existingMetadata ? [.../* @__PURE__ */ new Set([...resolvedCredentials, ...existingMetadata.credentials])] : resolvedCredentials;
+  const fetchOptions = mergeFetchOptions(
+    (existingMetadata == null ? void 0 : existingMetadata.fetchOptions) || {},
+    options.fetchOptions
+  );
+  const tokenCredentials = credentials.filter(
+    (credential) => credential.type !== "request"
+  );
+  const requestCredentials = credentials.filter(
+    (credential) => credential.type === "request"
+  );
+  for (const credential of requestCredentials) normalizeRequestOrigins(credential.origins);
+  const authenticatedFetch = async (url, requestOptions = {}) => {
+    var _a, _b, _c, _d, _e, _f, _g;
+    requestOptions = mergeFetchOptions(fetchOptions, requestOptions);
+    if ((_a = requestOptions.signal) == null ? void 0 : _a.aborted) throw createAbortError3();
+    if (!credentials.length) return baseFetch(url, requestOptions);
+    const resolvedURL = parseHTTPURL(url);
+    const authorization = resolvedURL ? await authorizeRequest(resolvedURL, requestOptions, tokenCredentials) : { url, options: requestOptions, credentials: [] };
+    const signedRequest = await authenticateRequest(authorization, requestCredentials, "request");
+    const response = await baseFetch(signedRequest.url, signedRequest.options);
+    const refreshableCredentials = [];
+    for (const resolvedCredential of authorization.credentials) {
+      const { credential } = resolvedCredential;
+      if (typeof credential.token === "function" && (isReplayableRequest(requestOptions) || ((_b = credential.canReplayRequest) == null ? void 0 : _b.call(credential, url, requestOptions))) && (isReplayableRequest(signedRequest.options) || ((_c = credential.canReplayRequest) == null ? void 0 : _c.call(credential, signedRequest.url, signedRequest.options))) && (credential.refreshStatusCodes.includes(response.status) || await ((_d = credential.shouldRefresh) == null ? void 0 : _d.call(credential, response))))
+        refreshableCredentials.push(resolvedCredential);
+    }
+    const shouldRetrySignature = isReplayableRequest(requestOptions) && isReplayableRequest(signedRequest.options) && signedRequest.credentials.some(
+      (credential) => {
+        var _a2;
+        return (_a2 = credential.refreshStatusCodes) == null ? void 0 : _a2.includes(response.status);
+      }
+    );
+    if (!refreshableCredentials.length && !shouldRetrySignature) return response;
+    if ((_e = requestOptions.signal) == null ? void 0 : _e.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 && !shouldRetrySignature) return response;
+    await ((_f = response.body) == null ? void 0 : _f.cancel().catch(() => {
+    }));
+    if ((_g = requestOptions.signal) == null ? void 0 : _g.aborted) throw createAbortError3();
+    const replayAuthorization = resolvedURL ? await authorizeRequest(
+      resolvedURL,
+      requestOptions,
+      tokenCredentials,
+      refreshedTokens,
+      authorization.credentials
+    ) : { url, options: requestOptions };
+    const replayRequest = await authenticateRequest(
+      replayAuthorization,
+      requestCredentials,
+      "retry",
+      response
+    );
+    return baseFetch(replayRequest.url, replayRequest.options);
+  };
+  Object.defineProperty(authenticatedFetch, AUTHENTICATED_FETCH, {
+    value: {
+      fetch: baseFetch,
+      credentials,
+      credentialResolutions,
+      fetchOptions
+    }
+  });
+  return authenticatedFetch;
+}
+function mergeFetchOptions(defaultOptions, requestOptions) {
+  const mergedOptions = { ...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));
+    mergedOptions.headers = headers;
+  }
+  return mergedOptions;
+}
+async function authenticateRequest(request, credentials, reason, response) {
+  const appliedCredentials = [];
+  const signal = request.options.signal;
+  for (const credential of credentials) {
+    const origin = getRequestOrigin(request.url);
+    if (!origin || !normalizeRequestOrigins(credential.origins).includes(origin)) continue;
+    if (signal == null ? void 0 : signal.aborted) throw createAbortError3();
+    const authenticatedRequest = await credential.authenticate({
+      url: request.url,
+      options: { ...request.options, headers: new Headers(request.options.headers) },
+      reason,
+      response: response ? { status: response.status, headers: new Headers(response.headers) } : void 0
+    });
+    if (!authenticatedRequest || typeof authenticatedRequest.url !== "string" || !authenticatedRequest.options || typeof authenticatedRequest.options !== "object") {
+      throw new Error("Authentication callback returned an invalid request.");
+    }
+    request = {
+      url: authenticatedRequest.url,
+      options: { ...authenticatedRequest.options, ...signal ? { signal } : {} }
+    };
+    appliedCredentials.push(credential);
+  }
+  if (signal == null ? void 0 : signal.aborted) throw createAbortError3();
+  return { ...request, credentials: appliedCredentials };
+}
+function getRequestOrigin(url) {
+  try {
+    const parsedURL = new URL(url);
+    if (!parsedURL.host || parsedURL.username || parsedURL.password) return null;
+    return parsedURL.origin !== "null" ? parsedURL.origin : `${parsedURL.protocol}//${parsedURL.host}`;
+  } catch {
+    return null;
+  }
+}
+function normalizeRequestOrigins(origins) {
+  if (!origins.length)
+    throw new Error("Request authentication requires at least one exact origin.");
+  return origins.map((origin) => {
+    const resolvedOrigin = getRequestOrigin(origin);
+    let url;
+    try {
+      url = new URL(origin);
+    } catch {
+      throw new Error("Invalid request authentication origin.");
+    }
+    if (!resolvedOrigin || url.pathname && url.pathname !== "/" || url.search || url.hash) {
+      throw new Error("Invalid request authentication origin.");
+    }
+    return resolvedOrigin;
+  });
+}
+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 = globalThis.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 {
@@ -102,9 +2286,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.+]+)/;
@@ -115,16 +2296,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 "";
 }
@@ -132,8 +2313,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, "");
@@ -149,10 +2330,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 || "";
   }
@@ -162,12 +2343,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") {
@@ -176,11 +2357,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;
   }
@@ -198,7 +2379,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 = {};
@@ -240,7 +2421,7 @@ async function getResponseError(response) {
   try {
     const contentType = response.headers.get("Content-Type");
     info.reason = !response.bodyUsed && (contentType == null ? void 0 : contentType.includes("application/json")) ? await response.json() : await response.text();
-  } catch (error) {
+  } catch (_error) {
   }
   return new FetchError(message, info);
 }
@@ -251,30 +2432,22 @@ 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);
     });
   }
   if (resource instanceof ArrayBuffer) {
     const slice = resource.slice(0, INITIAL_DATA_LENGTH);
-    const base64 = arrayBufferToBase64(slice);
+    const base64 = encodeArrayBufferToBase64(slice);
     return `data:base64,${base64}`;
   }
   return null;
 }
-function arrayBufferToBase64(buffer) {
-  let binary = "";
-  const bytes = new Uint8Array(buffer);
-  for (let i = 0; i < bytes.byteLength; i++) {
-    binary += String.fromCharCode(bytes[i]);
-  }
-  return btoa(binary);
-}
 
 // dist/lib/fetch/fetch-file.js
 function isNodePath(url) {
@@ -289,7 +2462,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);
@@ -309,63 +2482,87 @@ 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() {
     return () => {
     };
   }
+  /** Drops an info message. */
   info() {
     return () => {
     };
   }
+  /** Logs one message once; no-op for the null logger. */
+  once() {
+    return () => {
+    };
+  }
+  /** Drops a warning message. */
   warn() {
     return () => {
     };
   }
+  /** Drops an error message. */
   error() {
     return () => {
     };
   }
 };
 var ConsoleLog = class {
+  /** Console-like object used for message output. */
   console;
+  /** Messages already emitted through `once`. */
+  onceMessages = /* @__PURE__ */ new Set();
+  /** Creates a console-backed logger. */
   constructor() {
     this.console = console;
   }
+  /** Logs a message to the console. */
   log(...args) {
     return this.console.log.bind(this.console, ...args);
   }
+  /** Logs an informational message to the console. */
   info(...args) {
     return this.console.info.bind(this.console, ...args);
   }
+  /** Logs one message once to the console. */
+  once(...args) {
+    const message = String(args[0]);
+    if (this.onceMessages.has(message)) {
+      return () => {
+      };
+    }
+    this.onceMessages.add(message);
+    return this.console.info.bind(this.console, ...args);
+  }
+  /** Logs a warning message to the console. */
   warn(...args) {
     return this.console.warn.bind(this.console, ...args);
   }
+  /** Logs an error message to the console. */
   error(...args) {
     return this.console.error.bind(this.console, ...args);
   }
 };
 
 // dist/lib/loader-utils/option-defaults.js
-var import_loader_utils4 = require("@loaders.gl/loader-utils");
 var DEFAULT_LOADER_OPTIONS = {
+  searchParams: void 0,
   core: {
     baseUrl: void 0,
     // baseUrl
@@ -374,17 +2571,20 @@ var DEFAULT_LOADER_OPTIONS = {
     fallbackMimeType: void 0,
     ignoreRegisteredLoaders: void 0,
     nothrow: false,
+    shape: void 0,
     log: new ConsoleLog(),
     // A probe.gl compatible (`log.log()()` syntax) that just logs to console
     useLocalLibraries: false,
+    subloaders: void 0,
     CDN: "https://unpkg.com/@loaders.gl",
     worker: true,
     // By default, use worker if provided by loader.
+    workerThreshold: 0.1,
     maxConcurrency: 3,
     // How many worker instances should be created for each loader.
     maxMobileConcurrency: 1,
     // How many worker instances should be created for each loader on mobile devices.
-    reuseWorkers: import_loader_utils4.isBrowser,
+    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
@@ -419,6 +2619,7 @@ var REMOVED_LOADER_OPTIONS = {
   _worker: "core._workerType",
   limit: "core.limit",
   _limitMB: "core._limitMB",
+  shape: "core.shape",
   batchSize: "core.batchSize",
   batchDebounceMs: "core.batchDebounceMs",
   metadata: "core.metadata",
@@ -454,18 +2655,42 @@ var CORE_LOADER_OPTION_KEYS = [
   "useLocalLibraries",
   "CDN",
   "worker",
+  "workerThreshold",
   "maxConcurrency",
   "maxMobileConcurrency",
   "reuseWorkers",
+  "workerTransferBufferCopy",
   "_nodeWorkers",
   "_workerType",
   "limit",
   "_limitMB",
+  "shape",
   "batchSize",
   "batchDebounceMs",
   "metadata",
   "transforms"
 ];
+function applySearchParamsToUrl(url, options) {
+  const searchParams = options == null ? void 0 : options.searchParams;
+  if (!searchParams || Object.keys(searchParams).length === 0 || /^(?:data|blob):/i.test(url)) {
+    return url;
+  }
+  const hashIndex = url.indexOf("#");
+  const hash = hashIndex >= 0 ? url.slice(hashIndex) : "";
+  const urlWithoutHash = hashIndex >= 0 ? url.slice(0, hashIndex) : url;
+  const queryIndex = urlWithoutHash.indexOf("?");
+  const path = queryIndex >= 0 ? urlWithoutHash.slice(0, queryIndex) : urlWithoutHash;
+  const query = queryIndex >= 0 ? urlWithoutHash.slice(queryIndex + 1) : "";
+  const existingSearchParams = new URLSearchParams(query);
+  const appendedSearchParams = new URLSearchParams();
+  for (const [key, value] of Object.entries(searchParams)) {
+    if (!existingSearchParams.has(key)) {
+      appendedSearchParams.set(key, String(value));
+    }
+  }
+  const serializedAppendedSearchParams = appendedSearchParams.toString();
+  return `${path}${queryIndex >= 0 ? `?${query}` : ""}${serializedAppendedSearchParams ? `${queryIndex >= 0 ? "&" : "?"}${serializedAppendedSearchParams}` : ""}${hash}`;
+}
 function getGlobalLoaderState() {
   globalThis.loaders = globalThis.loaders || {};
   const { loaders } = globalThis;
@@ -486,13 +2711,16 @@ 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 || [];
   loaders = Array.isArray(loaders) ? loaders : [loaders];
   validateOptions(options, loaders);
-  return normalizeLoaderOptions(normalizeOptionsInternal(loader, options, url));
+  validateWorkerThreshold(options);
+  const normalizedOptions = normalizeLoaderOptions(normalizeOptionsInternal(loader, options, url));
+  validateWorkerThreshold(normalizedOptions);
+  return normalizedOptions;
 }
 function normalizeLoaderOptions(options) {
   const normalized = cloneLoaderOptions(options);
@@ -516,11 +2744,18 @@ function validateOptions(options, loaders) {
     validateOptionsObject(idOptions, loader.id, loaderOptions, deprecatedOptions, loaders);
   }
 }
+function validateWorkerThreshold(options) {
+  var _a;
+  const threshold = (_a = options.core) == null ? void 0 : _a.workerThreshold;
+  if (threshold !== void 0 && (!Number.isFinite(threshold) || threshold < 0 || threshold > 1)) {
+    throw new Error("core.workerThreshold must be a finite number between 0 and 1");
+  }
+}
 function validateOptionsObject(options, id, defaultOptions, deprecatedOptions, loaders) {
   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) {
@@ -568,15 +2803,40 @@ function normalizeOptionsInternal(loader, options, url) {
   mergeNestedFields(mergedOptions, normalizeLoaderOptions(getGlobalLoaderOptions()));
   const userOptions = normalizeLoaderOptions(options);
   mergeNestedFields(mergedOptions, userOptions);
+  applyCoreShapeDefault(mergedOptions, userOptions, loader);
   addUrlOptions(mergedOptions, url);
   addDeprecatedTopLevelOptions(mergedOptions);
   return mergedOptions;
 }
+function applyCoreShapeDefault(mergedOptions, userOptions, loader) {
+  var _a, _b;
+  const coreShape = (_a = mergedOptions.core) == null ? void 0 : _a.shape;
+  if (coreShape === void 0) {
+    return;
+  }
+  const loaderScopedDefaults = (_b = loader.options) == null ? void 0 : _b[loader.id];
+  if (!isPureObject(loaderScopedDefaults) || !("shape" in loaderScopedDefaults)) {
+    return;
+  }
+  const globalLoaderScopedOptions = getGlobalLoaderOptions()[loader.id];
+  if (isPureObject(globalLoaderScopedOptions) && "shape" in globalLoaderScopedOptions) {
+    return;
+  }
+  const userLoaderScopedOptions = userOptions[loader.id];
+  if (isPureObject(userLoaderScopedOptions) && "shape" in userLoaderScopedOptions) {
+    return;
+  }
+  const loaderScopedOptions = mergedOptions[loader.id];
+  mergedOptions[loader.id] = {
+    ...isPureObject(loaderScopedOptions) ? loaderScopedOptions : {},
+    shape: coreShape
+  };
+}
 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]
@@ -595,7 +2855,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) {
@@ -614,7 +2874,8 @@ function moveDeprecatedTopLevelOptionsToCore(options) {
   }
   for (const key of CORE_LOADER_OPTION_KEYS) {
     if (options[key] !== void 0) {
-      const coreOptions = options.core = options.core || {};
+      options.core ||= {};
+      const coreOptions = options.core;
       const coreRecord = coreOptions;
       if (coreRecord[key] === void 0) {
         coreRecord[key] = options[key];
@@ -642,7 +2903,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;
@@ -654,8 +2914,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];
@@ -699,7 +2959,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)) {
@@ -718,7 +2977,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);
   }
@@ -765,22 +3024,33 @@ function selectLoaderInternal(data, loaders, options, context) {
   const testUrl = stripQueryString(url) || (context == null ? void 0 : context.url);
   let loader = null;
   let reason = "";
+  const sourceType = (options == null ? void 0 : options.core) && "type" in options.core ? options.core.type : void 0;
+  if (sourceType && sourceType !== "auto") {
+    loader = findSourceLoaderByType(loaders, sourceType);
+    reason = loader ? `match forced by supplied source type ${sourceType}` : "";
+  }
   if ((_a = options == null ? void 0 : options.core) == null ? void 0 : _a.mimeType) {
     loader = findLoaderByMIMEType(loaders, (_b = options == null ? void 0 : options.core) == null ? void 0 : _b.mimeType);
     reason = `match forced by supplied MIME type ${(_c = options == null ? void 0 : options.core) == null ? void 0 : _c.mimeType}`;
   }
+  loader = loader || findSourceLoaderByTestURL(loaders, testUrl);
+  reason = reason || (loader ? `matched source url ${testUrl}` : "");
   loader = loader || findLoaderByUrl(loaders, testUrl);
   reason = reason || (loader ? `matched url ${testUrl}` : "");
   loader = loader || findLoaderByMIMEType(loaders, type);
   reason = reason || (loader ? `matched MIME type ${type}` : "");
   loader = loader || findLoaderByInitialBytes(loaders, data);
   reason = reason || (loader ? `matched initial data ${getFirstCharacters(data)}` : "");
+  if (!loader && isBlob(data)) {
+    loader = findSourceLoaderByTestData(loaders, data);
+    reason = reason || (loader ? "matched source testData" : "");
+  }
   if ((_d = options == null ? void 0 : options.core) == null ? void 0 : _d.fallbackMimeType) {
     loader = loader || findLoaderByMIMEType(loaders, (_e = options == null ? void 0 : options.core) == null ? void 0 : _e.fallbackMimeType);
     reason = reason || (loader ? `matched fallback MIME type ${type}` : "");
   }
   if (reason) {
-    import_loader_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;
 }
@@ -796,7 +3066,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";
@@ -824,6 +3094,36 @@ function findLoaderByExtension(loaders, extension) {
   }
   return null;
 }
+function findSourceLoaderByType(loaders, type) {
+  for (const loader of loaders) {
+    if (isSourceLoader(loader) && loader.type === type) {
+      return loader;
+    }
+  }
+  return null;
+}
+function findSourceLoaderByTestURL(loaders, url) {
+  if (!url) {
+    return null;
+  }
+  for (const loader of loaders) {
+    if (isSourceLoader(loader) && loader.testURL(url)) {
+      return loader;
+    }
+  }
+  return null;
+}
+function findSourceLoaderByTestData(loaders, data) {
+  var _a;
+  for (const loader of loaders) {
+    if (isSourceLoader(loader)) {
+      if ((_a = loader.testData) == null ? void 0 : _a.call(loader, data)) {
+        return loader;
+      }
+    }
+  }
+  return null;
+}
 function findLoaderByMIMEType(loaders, mimeType) {
   var _a;
   for (const loader of loaders) {
@@ -870,12 +3170,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;
@@ -906,15 +3206,7 @@ function getMagicString(arrayBuffer, byteOffset, length) {
   return magic;
 }
 
-// dist/lib/api/parse.js
-var import_loader_utils14 = require("@loaders.gl/loader-utils");
-var import_worker_utils = require("@loaders.gl/worker-utils");
-
-// dist/lib/loader-utils/get-data.js
-var import_loader_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;
@@ -924,7 +3216,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));
   }
 }
 
@@ -958,37 +3250,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) {
-    reader.releaseLock();
+    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;
+    }
   }
 }
 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);
@@ -996,13 +3323,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");
@@ -1018,46 +3345,68 @@ 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 (isIterable(data) || isAsyncIterable(data)) {
+    return concatenateArrayBuffersAsync(data);
+  }
+  throw new Error(ERR_DATA);
+}
+async function getArrayBufferFromData(data, options) {
+  if (typeof data === "string") {
+    return new TextEncoder().encode(data).buffer;
+  }
+  if (isArrayBufferLike(data)) {
+    return toArrayBuffer2(toArrayBufferView(data));
+  }
+  if (isBlob(data)) {
+    data = await makeResponse(data);
+  }
+  if (isResponse(data)) {
+    await checkResponse(data);
+    return await data.arrayBuffer();
+  }
+  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) {
@@ -1065,142 +3414,306 @@ 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, _c;
   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;
+    fetchFunction = fetchOption;
+  } else if (isObject(fetchOption)) {
+    fetchFunction = (context == null ? void 0 : context.fetch) || fetchFile;
+  } else if (context == null ? void 0 : context.fetch) {
+    fetchFunction = context.fetch;
+  } else {
+    fetchFunction = fetchFile;
+  }
+  return createAuthenticatedFetch({
+    fetch: fetchFunction,
+    credentials: ((_b = loaderOptions.core) == null ? void 0 : _b.credentials) || [],
+    authentications: (_c = loaderOptions.core) == null ? void 0 : _c.authentications,
+    fetchOptions: isObject(fetchOption) ? fetchOption : void 0
+  });
+}
+
+// dist/lib/api/load-loader.js
+var loaderImplementationPromises = /* @__PURE__ */ new Map();
+var loaderImplementations = /* @__PURE__ */ new Map();
+async function getLoaderImplementation(loader, options, url) {
+  var _a;
+  if (isSourceLoader(loader)) {
+    const source = loader.preload ? await loader.preload(url || "", options) : loader;
+    if (!isSourceLoader(source)) {
+      throw new Error(`${loader.id} source loader preload() did not return a runtime source loader`);
+    }
+    return source;
   }
-  if ((0, import_loader_utils12.isObject)(fetchOption)) {
-    return (url) => fetchFile(url, fetchOption);
+  if (isLoaderWithParser(loader)) {
+    return loader;
   }
-  if (context == null ? void 0 : context.fetch) {
-    return context == null ? void 0 : context.fetch;
+  const implementationCacheKey = getLoaderImplementationCacheKey(loader, options);
+  const loaderImplementation = (_a = loaderImplementations.get(loader)) == null ? void 0 : _a.get(implementationCacheKey);
+  if (loaderImplementation) {
+    return loaderImplementation;
+  }
+  let loaderImplementationPromisesForLoader = loaderImplementationPromises.get(loader);
+  if (!loaderImplementationPromisesForLoader) {
+    loaderImplementationPromisesForLoader = /* @__PURE__ */ new Map();
+    loaderImplementationPromises.set(loader, loaderImplementationPromisesForLoader);
+  }
+  let loaderImplementationPromise = loaderImplementationPromisesForLoader.get(implementationCacheKey);
+  if (!loaderImplementationPromise) {
+    loaderImplementationPromise = resolveLoaderImplementation(loader, options, url).then((implementation) => {
+      let loaderImplementationsForLoader = loaderImplementations.get(loader);
+      if (!loaderImplementationsForLoader) {
+        loaderImplementationsForLoader = /* @__PURE__ */ new Map();
+        loaderImplementations.set(loader, loaderImplementationsForLoader);
+      }
+      loaderImplementationsForLoader.set(implementationCacheKey, implementation);
+      return implementation;
+    }).catch((error) => {
+      loaderImplementationPromisesForLoader.delete(implementationCacheKey);
+      if (loaderImplementationPromisesForLoader.size === 0) {
+        loaderImplementationPromises.delete(loader);
+      }
+      throw error;
+    });
+    loaderImplementationPromisesForLoader.set(implementationCacheKey, loaderImplementationPromise);
   }
-  return fetchFile;
+  return await loaderImplementationPromise;
 }
-
-// dist/lib/loader-utils/loader-context.js
-var import_loader_utils13 = require("@loaders.gl/loader-utils");
-function getLoaderContext(context, options, parentContext) {
-  if (parentContext) {
-    return parentContext;
+function getLoaderImplementationSync(loader) {
+  var _a;
+  if (loader.subloaders && !preparedLoaders.has(loader)) {
+    const prepared = preparedDefaults.get(loader);
+    if (prepared)
+      return prepared;
+    if (!isLoaderWithParser(loader))
+      return null;
+  }
+  if (isLoaderWithParser(loader)) {
+    return loader;
   }
-  const newContext = {
-    fetch: getFetchFunction(options, context),
-    ...context
-  };
-  if (newContext.url) {
-    const baseUrl = stripQueryString(newContext.url);
-    newContext.baseUrl = baseUrl;
-    newContext.queryString = extractQueryString(newContext.url);
-    newContext.filename = import_loader_utils13.path.filename(baseUrl);
-    newContext.baseUrl = import_loader_utils13.path.dirname(baseUrl);
+  const implementationCacheKey = getLoaderImplementationCacheKey(loader);
+  return ((_a = loaderImplementations.get(loader)) == null ? void 0 : _a.get(implementationCacheKey)) || null;
+}
+function isLoaderWithParser(loader) {
+  const candidate = loader;
+  return Boolean(candidate.parse || candidate.parseSync || candidate.parseInBatches || candidate.parseText || candidate.parseTextSync || candidate.parseFile || candidate.parseFileInBatches);
+}
+async function resolveLoaderImplementation(loader, options, url) {
+  if (loader.preload) {
+    const preloadedLoader = await loader.preload(url || "", options);
+    if (isLoaderWithParser(preloadedLoader)) {
+      return preloadedLoader;
+    }
+    throw new Error(`${loader.id} loader preload() did not return a parser-bearing loader`);
   }
-  if (!Array.isArray(newContext.loaders)) {
-    newContext.loaders = null;
+  const implementationSpecifier = getLoaderImplementationSpecifier(loader, options);
+  return await importLoaderImplementation(implementationSpecifier, loader.id);
+}
+function getLoaderImplementationSpecifier(loader, options) {
+  var _a;
+  const workerType = (options == null ? void 0 : options._workerType) || ((_a = options == null ? void 0 : options.core) == null ? void 0 : _a._workerType);
+  if (workerType === "test") {
+    const sourcePath = `modules/${loader.module}/src/${loader.id}-loader.ts`;
+    if (typeof window !== "undefined") {
+      return `/${sourcePath}`;
+    }
+    if (typeof process !== "undefined" && process.cwd) {
+      return new URL(sourcePath, `file://${process.cwd()}/`).toString();
+    }
+    return sourcePath;
   }
-  return newContext;
+  throw new Error(`${loader.id} loader does not provide a parser implementation. Import a parser-bearing loader directly, or use preload() before parse/load.`);
 }
-function getLoadersFromContext(loaders, context) {
-  if (loaders && !Array.isArray(loaders)) {
-    return loaders;
+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) || (defaultLoaderOptions == null ? void 0 : defaultLoaderOptions.backend) || "");
+}
+async function importLoaderImplementation(implementationSpecifier, loaderId) {
+  const moduleExports = await import(
+    /* webpackIgnore: true */
+    /* @vite-ignore */
+    implementationSpecifier
+  );
+  for (const exportValue of Object.values(moduleExports)) {
+    if (exportValue && typeof exportValue === "object" && exportValue.id === loaderId && isLoaderWithParser(exportValue)) {
+      return exportValue;
+    }
   }
-  let candidateLoaders;
-  if (loaders) {
-    candidateLoaders = Array.isArray(loaders) ? loaders : [loaders];
+  throw new Error(`Could not find parser implementation for ${loaderId} in ${implementationSpecifier}`);
+}
+var preparedLoaders = /* @__PURE__ */ new WeakSet();
+var preparedDefaults = /* @__PURE__ */ new WeakMap();
+var subloaderPreparations = /* @__PURE__ */ new WeakMap();
+async function preloadLoaderDependencies(loader, options, url) {
+  if (preparedLoaders.has(loader))
+    return await getLoaderImplementation(loader, options, url);
+  validateSubloaderGraph(loader, options);
+  return await prepareLoaderDependencies(loader, options, url);
+}
+async function prepareLoaderDependencies(loader, options, url) {
+  if (!options) {
+    const cached = subloaderPreparations.get(loader);
+    if (cached)
+      return await cached;
+  }
+  const preparation = bindSubloaders(loader, options, url);
+  if (!options) {
+    subloaderPreparations.set(loader, preparation);
+    void preparation.catch(() => subloaderPreparations.delete(loader));
+  }
+  const prepared = await preparation;
+  if (!options)
+    preparedDefaults.set(loader, prepared);
+  return prepared;
+}
+function getSubloaders(loader, options) {
+  var _a;
+  const overrides = ((_a = options == null ? void 0 : options.core) == null ? void 0 : _a.subloaders) || {};
+  return Object.fromEntries(Object.entries(loader.subloaders || {}).map(([name, dependency]) => [
+    name,
+    Object.hasOwn(overrides, name) ? overrides[name] : dependency
+  ]));
+}
+function validateSubloaderGraph(loader, options) {
+  visitLoader(loader, []);
+  function visitLoader(currentLoader, ancestors) {
+    if (ancestors.includes(currentLoader)) {
+      throw new Error(`Subloader cycle: ${[...ancestors, currentLoader].map((value) => value.id).join(" -> ")}`);
+    }
+    for (const dependency of Object.values(getSubloaders(currentLoader, options))) {
+      visitLoader(dependency, [...ancestors, currentLoader]);
+    }
   }
-  if (context && context.loaders) {
-    const contextLoaders = Array.isArray(context.loaders) ? context.loaders : [context.loaders];
-    candidateLoaders = candidateLoaders ? [...candidateLoaders, ...contextLoaders] : contextLoaders;
+}
+async function bindSubloaders(loader, options, url) {
+  const [implementation, entries] = await Promise.all([
+    getLoaderImplementation(loader, options, url),
+    Promise.all(Object.entries(getSubloaders(loader, options)).map(async ([name, dependency]) => [name, await prepareLoaderDependencies(dependency, options, url)]))
+  ]);
+  const subloaders = Object.fromEntries(entries);
+  const defaultOptions = mergeOptions(implementation.options, options || {});
+  defaultOptions.core = { ...defaultOptions.core, worker: false };
+  const prepared = { ...implementation, options: defaultOptions, subloaders };
+  delete prepared.preload;
+  prepared.worker = false;
+  for (const method of [
+    "parseBlob",
+    "createDataSource",
+    "parse",
+    "parseSync",
+    "parseText",
+    "parseTextSync",
+    "parseInBatches",
+    "parseFile",
+    "parseFileInBatches",
+    "parseUrl"
+  ]) {
+    const parser = implementation[method];
+    if (typeof parser === "function") {
+      prepared[method] = (data, parseOptions, context) => {
+        var _a, _b;
+        const forwardedOptions = mergeOptions(options, parseOptions || {});
+        return parser.call(implementation, data, {
+          ...forwardedOptions,
+          core: {
+            ...forwardedOptions.core,
+            subloaders: ((_a = options == null ? void 0 : options.core) == null ? void 0 : _a.subloaders) || ((_b = parseOptions == null ? void 0 : parseOptions.core) == null ? void 0 : _b.subloaders),
+            worker: false
+          },
+          [loader.id]: { ...forwardedOptions[loader.id], subloaders }
+        }, context);
+      };
+    }
   }
-  return candidateLoaders && candidateLoaders.length ? candidateLoaders : void 0;
+  preparedLoaders.add(prepared);
+  return prepared;
 }
 
-// dist/lib/api/parse.js
-async function parse(data, loaders, options, context) {
+// dist/lib/api/parse-file.js
+async function parseFile(file, loaders, options, context) {
+  var _a, _b;
   if (loaders && !Array.isArray(loaders) && !isLoaderObject(loaders)) {
     context = void 0;
     options = loaders;
     loaders = void 0;
   }
-  data = await data;
   options = options || {};
-  const url = getResourceUrl(data);
+  const url = file.url || "";
   const typedLoaders = loaders;
   const candidateLoaders = getLoadersFromContext(typedLoaders, context);
-  const loader = await selectLoader(data, candidateLoaders, options);
+  const loader = await selectLoader(url, candidateLoaders, options);
   if (!loader) {
     return null;
   }
-  const strictOptions = normalizeOptions(options, loader, candidateLoaders, url);
+  if (isSourceLoader(loader)) {
+    throw new Error(`${loader.id} is a SourceLoader. Use load() to create a runtime source object instead of parseFile().`);
+  }
+  const normalizedOptions = normalizeOptions(options, loader, candidateLoaders, url);
+  const authenticationLoader = !loader.getAuthentications && ((_b = (_a = normalizedOptions.core) == null ? void 0 : _a.credentials) == null ? void 0 : _b.length) ? await getLoaderImplementation(loader, normalizedOptions, url || (context == null ? void 0 : context.url)) : loader;
+  const strictOptions = await resolveLoaderAuthenticationOptions(authenticationLoader, url, normalizedOptions);
   context = getLoaderContext(
-    // @ts-expect-error
+    // @ts-expect-error candidateLoaders may be a single forced loader
     { url, _parse: parse, loaders: candidateLoaders },
     strictOptions,
     context || null
   );
-  return await parseWithLoader(loader, data, strictOptions, context);
+  return await parseFileWithLoader(loader, file, strictOptions, context);
 }
-async function parseWithLoader(loader, data, options, context) {
-  (0, import_worker_utils.validateWorkerVersion)(loader);
-  options = (0, import_loader_utils14.mergeOptions)(loader.options, options);
-  if ((0, import_loader_utils14.isResponse)(data)) {
-    const { ok, redirected, status, statusText, type, url } = data;
-    const headers = Object.fromEntries(data.headers.entries());
-    context.response = { headers, ok, redirected, status, statusText, type, url };
-  }
-  data = await getArrayBufferOrStringFromData(data, loader, options);
-  const loaderWithParser = loader;
-  if (loaderWithParser.parseTextSync && typeof data === "string") {
-    return loaderWithParser.parseTextSync(data, options, context);
-  }
-  if ((0, import_loader_utils14.canParseWithWorker)(loader, options)) {
-    return await (0, import_loader_utils14.parseWithWorker)(loader, data, options, context, parse);
-  }
-  if (loaderWithParser.parseText && typeof data === "string") {
-    return await loaderWithParser.parseText(data, options, context);
-  }
-  if (loaderWithParser.parse) {
-    return await loaderWithParser.parse(data, options, context);
+async function parseFileWithLoader(loader, file, options, context) {
+  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);
+  }
+  const parseFunction = loaderWithParser.parse;
+  if (parseFunction) {
+    const length = file.bigsize > 0n ? Number(file.bigsize) : file.size;
+    if (!length) {
+      throw new Error(`${loader.id} loader - cannot fall back to parse without a file size`);
+    }
+    const data = await file.read(0n, length);
+    return await parse(data, loaderWithParser, options, context);
   }
-  (0, import_worker_utils.assert)(!loaderWithParser.parseSync);
-  throw new Error(`${loader.id} loader - no parser found and worker is disabled`);
+  throw new Error(`${loader.id} loader - no file parser found`);
 }
 
 // dist/lib/api/parse-sync.js
@@ -1217,13 +3730,17 @@ function parseSync(data, loaders, options, context) {
   if (!loader) {
     return null;
   }
+  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);
   const url = getResourceUrl(data);
   const parse2 = () => {
     throw new Error("parseSync called parse (which is async");
   };
   context = getLoaderContext({ url, _parseSync: parse2, _parse: parse2, loaders }, strictOptions, context || null);
-  return parseWithLoaderSync(loader, data, strictOptions, context);
+  const loaderWithParser = getLoaderImplementationSync(loader);
+  return parseWithLoaderSync(loaderWithParser || loader, data, strictOptions, context);
 }
 function parseWithLoaderSync(loader, data, options, context) {
   data = getArrayBufferOrStringFromDataSync(data, loader, options);
@@ -1233,13 +3750,58 @@ function parseWithLoaderSync(loader, data, options, context) {
   if (loader.parseSync && data instanceof ArrayBuffer) {
     return loader.parseSync(data, options, context);
   }
+  if (loader.preload) {
+    throw new Error(`${loader.name} loader: 'parseSync' requires a parser-bearing loader. Import the loader implementation directly, or call preload(loader) before parseSync(). ${context.url || ""}`);
+  }
   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) {
+  var _a, _b;
   const loaderArray = Array.isArray(loaders) ? loaders : void 0;
   if (!Array.isArray(loaders) && !isLoaderObject(loaders)) {
     context = void 0;
@@ -1253,11 +3815,14 @@ async function parseInBatches(data, loaders, options, context) {
   if (!loader) {
     return [];
   }
-  const strictOptions = normalizeOptions(options, loader, loaderArray, url);
+  const normalizedOptions = normalizeOptions(options, loader, loaderArray, url);
+  const authenticationLoader = !loader.getAuthentications && ((_b = (_a = normalizedOptions.core) == null ? void 0 : _a.credentials) == null ? void 0 : _b.length) ? await getLoaderImplementation(loader, normalizedOptions, url || (context == null ? void 0 : context.url)) : loader;
+  const strictOptions = await resolveLoaderAuthenticationOptions(authenticationLoader, url || "", normalizedOptions);
   context = getLoaderContext({ url, _parseInBatches: parseInBatches, _parse: parse, loaders: loaderArray }, strictOptions, context || null);
-  return await parseWithLoaderInBatches(loader, data, strictOptions, context);
+  const loaderWithParser = await getLoaderImplementation(loader, strictOptions, context.url);
+  return await parseWithLoaderInBatches(loader, loaderWithParser, data, strictOptions, context);
 }
-async function parseWithLoaderInBatches(loader, data, options, context) {
+async function parseWithLoaderInBatches(originalLoader, loader, data, options, context) {
   var _a;
   const outputIterator = await parseToOutputIterator(loader, data, options, context);
   if (!((_a = options == null ? void 0 : options.core) == null ? void 0 : _a.metadata)) {
@@ -1267,7 +3832,7 @@ async function parseWithLoaderInBatches(loader, data, options, context) {
     shape: "metadata",
     batchType: "metadata",
     metadata: {
-      _loader: loader,
+      _loader: originalLoader,
       _context: context
     },
     // Populate with some default fields to avoid crashing
@@ -1285,12 +3850,15 @@ async function parseToOutputIterator(loader, data, options, context) {
   const inputIterator = await getAsyncIterableFromData(data, options);
   const transformedIterator = await applyInputTransforms(inputIterator, ((_a = options == null ? void 0 : options.core) == null ? void 0 : _a.transforms) || []);
   if (loader.parseInBatches) {
+    if (loader.id === "csv" && isBrowser && canParseWithWorker(loader, options)) {
+      return parseWithWorkerInBatches(loader, transformedIterator, options, context, parse);
+    }
     return loader.parseInBatches(transformedIterator, options, context);
   }
   return parseChunkInBatches(transformedIterator, loader, options, context);
 }
 async function* parseChunkInBatches(transformedIterator, loader, options, context) {
-  const arrayBuffer = await (0, import_loader_utils15.concatenateArrayBuffersAsync)(transformedIterator);
+  const arrayBuffer = await concatenateArrayBuffersAsync(transformedIterator);
   const parsedData = await parse(
     arrayBuffer,
     loader,
@@ -1302,7 +3870,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,
@@ -1319,8 +3887,40 @@ async function applyInputTransforms(inputIterator, transforms = []) {
   return iteratorChain;
 }
 
+// dist/lib/api/load-in-batches.js
+function loadInBatches(files, loaders, options, context) {
+  let loadersArray;
+  if (!Array.isArray(loaders) && !isLoaderObject(loaders)) {
+    context = void 0;
+    options = loaders;
+    loadersArray = void 0;
+  } else {
+    loadersArray = loaders;
+  }
+  if (!Array.isArray(files)) {
+    return loadOneFileInBatches(files, loadersArray, options || {});
+  }
+  const promises = files.map((file) => loadOneFileInBatches(file, loadersArray, options || {}));
+  return promises;
+}
+async function loadOneFileInBatches(file, loaders, options) {
+  var _a, _b;
+  if (typeof file === "string") {
+    const url = file;
+    const loader = await selectLoader(url, loaders, {
+      ...options,
+      core: { ...options.core, nothrow: true }
+    });
+    const authenticationLoader = loader && !loader.getAuthentications && ((_b = (_a = options.core) == null ? void 0 : _a.credentials) == null ? void 0 : _b.length) ? await getLoaderImplementation(loader, options, url) : loader;
+    options = await resolveLoaderAuthenticationOptions(authenticationLoader, url, options);
+    const fetch2 = getFetchFunction(options);
+    const response = await fetch2(applySearchParamsToUrl(url, options));
+    return Array.isArray(loaders) ? await parseInBatches(response, loaders, options) : await parseInBatches(response, loaders, options);
+  }
+  return Array.isArray(loaders) ? await parseInBatches(file, loaders, options) : await parseInBatches(file, loaders, options);
+}
+
 // dist/lib/api/load.js
-var import_loader_utils16 = require("@loaders.gl/loader-utils");
 async function load(url, loaders, options, context) {
   var _a;
   let resolvedLoaders;
@@ -1333,12 +3933,71 @@ async function load(url, loaders, options, context) {
     resolvedLoaders = loaders;
     resolvedOptions = options;
   }
+  resolvedOptions ||= getGlobalLoaderOptions();
+  if (!Array.isArray(resolvedLoaders) && isSourceLoader(resolvedLoaders)) {
+    const sourceLoader = await resolveSourceLoader(resolvedLoaders, url, resolvedOptions);
+    resolvedOptions = await resolveLoaderAuthenticationOptions(resolvedLoaders.getAuthentications ? resolvedLoaders : sourceLoader, typeof url === "string" ? url : "", resolvedOptions || {});
+    const runtimeCoreApi = {
+      fetchFile,
+      parse,
+      parseFile,
+      parseSync,
+      parseInBatches,
+      load,
+      loadInBatches
+    };
+    return sourceLoader.createDataSource(url, resolvedOptions || {}, runtimeCoreApi);
+  }
+  if (Array.isArray(resolvedLoaders) && resolvedLoaders.length === 1 && isSourceLoader(resolvedLoaders[0])) {
+    const sourceLoader = await resolveSourceLoader(resolvedLoaders[0], url, resolvedOptions);
+    resolvedOptions = await resolveLoaderAuthenticationOptions(resolvedLoaders[0].getAuthentications ? resolvedLoaders[0] : sourceLoader, typeof url === "string" ? url : "", resolvedOptions || {});
+    const runtimeCoreApi = {
+      fetchFile,
+      parse,
+      parseFile,
+      parseSync,
+      parseInBatches,
+      load,
+      loadInBatches
+    };
+    return sourceLoader.createDataSource(url, resolvedOptions || {}, runtimeCoreApi);
+  }
+  if (typeof url === "string" || isBlob(url)) {
+    const selectedLoader = await selectLoader(url, resolvedLoaders, {
+      ...resolvedOptions,
+      core: { ...resolvedOptions == null ? void 0 : resolvedOptions.core, nothrow: true }
+    });
+    if (selectedLoader && isSourceLoader(selectedLoader)) {
+      const sourceLoader = await resolveSourceLoader(selectedLoader, url, resolvedOptions);
+      resolvedOptions = await resolveLoaderAuthenticationOptions(selectedLoader.getAuthentications ? selectedLoader : sourceLoader, typeof url === "string" ? url : "", resolvedOptions || {});
+      return sourceLoader.createDataSource(url, resolvedOptions || {}, {
+        fetchFile,
+        parse,
+        parseFile,
+        parseSync,
+        parseInBatches,
+        load,
+        loadInBatches
+      });
+    }
+    if (selectedLoader && typeof url === "string") {
+      const loaderImplementation = await getLoaderImplementation(selectedLoader, resolvedOptions, url);
+      resolvedOptions = await resolveLoaderAuthenticationOptions(selectedLoader.getAuthentications ? selectedLoader : loaderImplementation, url, resolvedOptions || {});
+      const parseUrl = loaderImplementation.parseUrl;
+      if (parseUrl) {
+        const requestUrl = applySearchParamsToUrl(url, resolvedOptions);
+        return await parseUrl(requestUrl, resolvedOptions, context);
+      }
+    }
+  }
+  if (resolvedOptions)
+    resolvedOptions = resolveAuthenticationOptions(resolvedOptions);
   const fetch2 = getFetchFunction(resolvedOptions);
   let data = url;
   if (typeof url === "string") {
-    data = await fetch2(url);
+    data = await fetch2(applySearchParamsToUrl(url, resolvedOptions));
   }
-  if ((0, import_loader_utils16.isBlob)(url)) {
+  if (isBlob(url)) {
     data = await fetch2(url);
   }
   if (typeof url === "string") {
@@ -1353,44 +4012,154 @@ async function load(url, loaders, options, context) {
       };
     }
   }
-  return Array.isArray(resolvedLoaders) ? await parse(data, resolvedLoaders, resolvedOptions) : await parse(data, resolvedLoaders, resolvedOptions);
+  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/load-in-batches.js
-function loadInBatches(files, loaders, options, context) {
-  let loadersArray;
-  if (!Array.isArray(loaders) && !isLoaderObject(loaders)) {
+// dist/lib/api/core-api.js
+var coreApi = Object.freeze({
+  fetchFile,
+  parse,
+  parseFile,
+  parseSync,
+  parseInBatches,
+  load,
+  loadInBatches
+});
+
+// dist/lib/loader-utils/loader-context.js
+function getLoaderContext(context, options, parentContext) {
+  if (parentContext) {
+    return {
+      ...parentContext,
+      coreApi: parentContext.coreApi || context.coreApi || coreApi,
+      _parse: parentContext._parse || context._parse,
+      fetch: getFetchFunction(options, parentContext)
+    };
+  }
+  const newContext = {
+    ...context,
+    fetch: getFetchFunction(options, context),
+    coreApi: context.coreApi || coreApi
+  };
+  if (newContext.url) {
+    const baseUrl = stripQueryString(newContext.url);
+    newContext.baseUrl = baseUrl;
+    newContext.queryString = extractQueryString(newContext.url);
+    newContext.filename = path_exports.filename(baseUrl);
+    newContext.baseUrl = path_exports.dirname(baseUrl);
+  }
+  if (!Array.isArray(newContext.loaders)) {
+    newContext.loaders = null;
+  }
+  return newContext;
+}
+function getLoadersFromContext(loaders, context) {
+  if (loaders && !Array.isArray(loaders)) {
+    return loaders;
+  }
+  let candidateLoaders;
+  if (loaders) {
+    candidateLoaders = Array.isArray(loaders) ? loaders : [loaders];
+  }
+  if (context && context.loaders) {
+    const contextLoaders = Array.isArray(context.loaders) ? context.loaders : [context.loaders];
+    candidateLoaders = candidateLoaders ? [...candidateLoaders, ...contextLoaders] : contextLoaders;
+  }
+  return candidateLoaders && candidateLoaders.length ? candidateLoaders : void 0;
+}
+
+// dist/lib/api/parse.js
+async function parse(data, loaders, options, context) {
+  var _a, _b;
+  if (loaders && !Array.isArray(loaders) && !isLoaderObject(loaders)) {
     context = void 0;
     options = loaders;
-    loadersArray = void 0;
-  } else {
-    loadersArray = loaders;
+    loaders = void 0;
   }
-  const fetch2 = getFetchFunction(options || {});
-  if (!Array.isArray(files)) {
-    return loadOneFileInBatches(files, loadersArray, options || {}, fetch2);
+  data = await data;
+  options = options || {};
+  const url = getResourceUrl(data);
+  const typedLoaders = loaders;
+  const candidateLoaders = getLoadersFromContext(typedLoaders, context);
+  const loader = await selectLoader(data, candidateLoaders, options);
+  if (!loader) {
+    return null;
   }
-  const promises = files.map((file) => loadOneFileInBatches(file, loadersArray, options || {}, fetch2));
-  return promises;
+  if (isSourceLoader(loader)) {
+    throw new Error(`${loader.id} is a SourceLoader. Use load() to create a runtime source object instead of parse().`);
+  }
+  const normalizedOptions = normalizeOptions(options, loader, candidateLoaders, url);
+  const authenticationLoader = !loader.getAuthentications && ((_b = (_a = normalizedOptions.core) == null ? void 0 : _a.credentials) == null ? void 0 : _b.length) ? await getLoaderImplementation(loader, normalizedOptions, url || (context == null ? void 0 : context.url)) : loader;
+  const strictOptions = await resolveLoaderAuthenticationOptions(authenticationLoader, url || "", normalizedOptions);
+  context = getLoaderContext(
+    // @ts-expect-error
+    { url, _parse: parse, loaders: candidateLoaders },
+    strictOptions,
+    context || null
+  );
+  return await parseWithLoader(loader, data, strictOptions, context);
 }
-async function loadOneFileInBatches(file, loaders, options, fetch2) {
-  if (typeof file === "string") {
-    const url = file;
-    const response = await fetch2(url);
-    return Array.isArray(loaders) ? await parseInBatches(response, loaders, options) : await parseInBatches(response, loaders, options);
+async function parseWithLoader(loader, data, options, context) {
+  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 };
   }
-  return Array.isArray(loaders) ? await parseInBatches(file, loaders, options) : await parseInBatches(file, loaders, options);
+  const loaderWithParser = await getLoaderImplementation(loader, options, context.url);
+  if (shouldParseWithWorker(loaderWithParser, data, options, context, loader)) {
+    data = await getArrayBufferFromData(data, options);
+    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);
+}
+async function parseWithLoaderImplementation(loader, data, options, context) {
+  if (loader.parseText && typeof data === "string") {
+    return await loader.parseText(data, options, context);
+  }
+  if (loader.parseTextSync && typeof data === "string") {
+    return loader.parseTextSync(data, options, context);
+  }
+  if (loader.parse) {
+    return await loader.parse(data, options, context);
+  }
+  if (loader.parseSync) {
+    throw new Error(`${loader.name} loader: 'parse' not available on parser-bearing sync loader. Add an async 'parse' function to this loader, or call preload(loader) before parseSync(). ${context.url || ""}`);
+  }
+  throw new Error(`${loader.id} loader - no parser found and worker is disabled`);
+}
+
+// dist/lib/api/preload.js
+async function preload(loader, options, url) {
+  return loader.subloaders ? await preloadLoaderDependencies(loader, options, url) : await getLoaderImplementation(loader, options, url);
+}
+function preloadSync(loader) {
+  return getLoaderImplementationSync(loader);
 }
 
 // dist/lib/api/encode-table.js
-var import_loader_utils17 = require("@loaders.gl/loader-utils");
 async function encodeTable(data, writer, options) {
   if (writer.encode) {
     return await writer.encode(data, options);
   }
   if (writer.encodeText) {
     const text = await writer.encodeText(data, options);
-    return (0, import_loader_utils17.ensureArrayBuffer)(new TextEncoder().encode(text));
+    return ensureArrayBuffer(new TextEncoder().encode(text));
   }
   if (writer.encodeInBatches) {
     const batches = encodeTableInBatches(data, writer, options);
@@ -1398,7 +4167,7 @@ async function encodeTable(data, writer, options) {
     for await (const batch of batches) {
       chunks.push(batch);
     }
-    return (0, import_loader_utils17.concatenateArrayBuffers)(...chunks);
+    return concatenateArrayBuffers(...chunks);
   }
   throw new Error("Writer could not encode data");
 }
@@ -1425,16 +4194,14 @@ function getIterator(data) {
 }
 
 // dist/lib/api/encode.js
-var import_loader_utils18 = require("@loaders.gl/loader-utils");
-var import_worker_utils2 = require("@loaders.gl/worker-utils");
 async function encode(data, writer, options_) {
   const globalOptions = getGlobalLoaderOptions();
   const options = { ...globalOptions, ...options_ };
   if (writer.encodeURLtoURL) {
     return encodeWithCommandLineTool(writer, data, options);
   }
-  if ((0, import_loader_utils18.canEncodeWithWorker)(writer, options)) {
-    return await (0, import_worker_utils2.processOnWorker)(writer, data, options);
+  if (canEncodeWithWorker(writer, options)) {
+    return await processOnWorker(writer, data, options);
   }
   return await writer.encode(data, options);
 }
@@ -1443,7 +4210,7 @@ function encodeSync(data, writer, options) {
     return writer.encodeSync(data, options);
   }
   if (writer.encodeTextSync) {
-    return (0, import_loader_utils18.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`);
 }
@@ -1478,20 +4245,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_utils18.resolvePath)(inputUrl);
-  outputUrl = (0, import_loader_utils18.resolvePath)(outputUrl);
-  if (import_loader_utils18.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_utils18.isBrowser) {
+  if (isBrowser) {
     throw new Error(`Writer ${writer.name} not supported in browser`);
   }
   const tmpInputFilename = getTemporaryFilename("input");
-  const file = new import_loader_utils18.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);
@@ -1502,27 +4269,41 @@ 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
-function createDataSource(data, sources, options) {
-  var _a;
-  const type = ((_a = options == null ? void 0 : options.core) == null ? void 0 : _a.type) || options.type || "auto";
-  const source = type === "auto" ? selectSource(data, sources) : getSourceOfType(type, sources);
+function createDataSource(data, sources, options = {}) {
+  var _a, _b, _c, _d, _e;
+  const resolvedOptions = options || {};
+  const type = ((_a = resolvedOptions == null ? void 0 : resolvedOptions.core) == null ? void 0 : _a.type) || resolvedOptions.type || "auto";
+  const source = sources.length === 1 ? sources[0] : type === "auto" ? selectLoaderSync(data, sources, {
+    // `createDataSource` supports non-fetch inputs such as in-memory tables.
+    // Selection remains best-effort for those cases.
+    ...resolvedOptions,
+    core: { ...resolvedOptions == null ? void 0 : resolvedOptions.core, type: "auto" }
+  }) : getSourceOfType(type, sources);
   if (!source) {
     throw new Error("Not a valid source type");
   }
-  return source.createDataSource(data, options);
-}
-function selectSource(url, sources) {
-  for (const service of sources) {
-    if (service.testURL && service.testURL(url)) {
-      return service;
+  const contributions = ((_c = (_b = resolvedOptions.core) == null ? void 0 : _b.credentials) == null ? void 0 : _c.length) ? (_d = source.getAuthentications) == null ? void 0 : _d.call(source, typeof data === "string" ? data : "", resolvedOptions) : void 0;
+  if (contributions && "then" in contributions) {
+    void contributions.catch(() => {
+    });
+    throw new Error("Use load() with an asynchronous getAuthentications() hook.");
+  }
+  const authenticatedOptions = resolveAuthenticationOptions((contributions == null ? void 0 : contributions.length) ? {
+    ...resolvedOptions,
+    core: {
+      ...resolvedOptions.core,
+      authentications: [
+        ...((_e = resolvedOptions.core) == null ? void 0 : _e.authentications) || [],
+        ...contributions || []
+      ]
     }
-  }
-  return null;
+  } : resolvedOptions);
+  return source.createDataSource(data, authenticatedOptions, coreApi);
 }
 function getSourceOfType(type, sources) {
   for (const service of sources) {
@@ -1534,15 +4315,11 @@ function getSourceOfType(type, sources) {
 }
 
 // dist/lib/api/select-source.js
-function selectSource2(url, sources, options) {
+function selectSource(url, sources, options) {
   const type = (options == null ? void 0 : options.type) || "auto";
   let selectedSource = null;
   if (type === "auto") {
-    for (const source of sources) {
-      if (typeof url === "string" && source.testURL && source.testURL(url)) {
-        return source;
-      }
-    }
+    selectedSource = selectLoaderSync(url, sources, { core: { nothrow: true } });
   } else {
     selectedSource = getSourceOfType2(type, sources);
   }
@@ -1560,10 +4337,6 @@ function getSourceOfType2(type, sources) {
   return null;
 }
 
-// dist/index.js
-var import_loader_utils20 = require("@loaders.gl/loader-utils");
-var import_loader_utils21 = require("@loaders.gl/loader-utils");
-
 // dist/iterators/make-stream/make-stream.js
 function makeStream(source, options) {
   if (globalThis.loaders.makeNodeStream) {
@@ -1604,14 +4377,14 @@ function makeStream(source, options) {
 }
 
 // dist/null-loader.js
-var VERSION = true ? "4.5.3" : "latest";
+var VERSION4 = true ? "5.0.0-alpha.10" : "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"],
@@ -1626,7 +4399,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),
@@ -1645,9 +4418,6 @@ function parseSync2(arrayBuffer, options, context) {
   return null;
 }
 
-// dist/index.js
-var import_loader_utils22 = require("@loaders.gl/loader-utils");
-
 // dist/lib/progress/fetch-progress.js
 async function fetchProgress(response, onProgress, onDone = () => {
 }, onError = () => {
@@ -1696,7 +4466,6 @@ async function read(controller, reader, loadedBytes, totalBytes, onProgress, onD
 }
 
 // dist/lib/filesystems/browser-filesystem.js
-var import_loader_utils19 = require("@loaders.gl/loader-utils");
 var BrowserFileSystem = class {
   _fetch;
   files = {};
@@ -1722,27 +4491,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;
   }
   /**
@@ -1750,51 +4530,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_utils19.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_utils23 = require("@loaders.gl/loader-utils");
-var import_loader_utils24 = require("@loaders.gl/loader-utils");
-var import_loader_utils25 = require("@loaders.gl/loader-utils");
-var import_loader_utils26 = require("@loaders.gl/loader-utils");
-var import_loader_utils27 = require("@loaders.gl/loader-utils");
 //# sourceMappingURL=index.cjs.map