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

package/dist/dist.dev.js

@@ -10,7 +10,6 @@ var __exports__ = (() => {
   var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
   var __getOwnPropNames = Object.getOwnPropertyNames;
   var __hasOwnProp = Object.prototype.hasOwnProperty;
-  var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
   var __export = (target, all) => {
     for (var name in all)
       __defProp(target, name, { get: all[name], enumerable: true });
@@ -24,10 +23,6 @@ var __exports__ = (() => {
     return to;
   };
   var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-  var __publicField = (obj, key, value) => {
-    __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-    return value;
-  };
 
   // bundle.ts
   var bundle_exports = {};
@@ -686,7 +681,7 @@ var __exports__ = (() => {
     }
     const options = { ...baseOptions };
     for (const [key, newValue] of Object.entries(newOptions)) {
-      if (newValue && typeof newValue === "object" && !Array.isArray(newValue)) {
+      if (isPureObject(newValue)) {
         options[key] = mergeOptionsRecursively(
           options[key] || {},
           newOptions[key],
@@ -784,7 +779,9 @@ var __exports__ = (() => {
      * Call to resolve the `result` Promise with the supplied value
      */
     done(value) {
-      assert3(this.isRunning);
+      if (!this.isRunning) {
+        return;
+      }
       this.isRunning = false;
       this._resolve(value);
     }
@@ -792,14 +789,42 @@ var __exports__ = (() => {
      * Call to reject the `result` Promise with the supplied error
      */
     error(error) {
-      assert3(this.isRunning);
+      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_) {
+      const runtimeProcess = globalThis.process;
+      const WorkerConstructor = runtimeProcess?.getBuiltinModule?.("node:worker_threads").Worker;
+      if (WorkerConstructor) {
+        return new WorkerConstructor(...arguments_);
+      }
+    }
+    /** No-op browser fallback matching the native Worker API. */
     terminate() {
     }
   };
@@ -900,6 +925,10 @@ var __exports__ = (() => {
     name;
     source;
     url;
+    /** Lazily resolves the classic worker URL used as a fallback. */
+    getUrl;
+    /** Creates a browser Worker directly. */
+    loadWorker;
     terminated = false;
     worker;
     onMessage;
@@ -910,11 +939,13 @@ var __exports__ = (() => {
       return typeof Worker !== "undefined" && isBrowser3 || typeof NodeWorker !== "undefined" && !isBrowser3;
     }
     constructor(props) {
-      const { name, source, url } = props;
-      assert3(source || url);
+      const { name, source, url, getUrl, loadWorker } = props;
+      assert3(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 = isBrowser3 ? this._createBrowserWorker() : this._createNodeWorker();
@@ -960,7 +991,7 @@ var __exports__ = (() => {
      */
     _getErrorFromErrorEvent(event) {
       let message = "Failed to load ";
-      message += `worker ${this.name} from ${this.url}. `;
+      message += `worker ${this.name} from ${this.url || "built-in worker factory"}. `;
       if (event.message) {
         message += `${event.message} in `;
       }
@@ -973,8 +1004,25 @@ var __exports__ = (() => {
      * Creates a worker thread on the browser
      */
     _createBrowserWorker() {
-      this._loadableURL = getLoadableWorkerURL({ source: this.source, url: this.url });
+      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 || this.getUrl?.();
+      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"));
@@ -998,8 +1046,9 @@ var __exports__ = (() => {
       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(url, { eval: false, type });
+        worker = new NodeWorker(workerUrl, { eval: false, type });
       } else if (this.source) {
         worker = new NodeWorker(this.source, { eval: true });
       } else {
@@ -1023,6 +1072,10 @@ var __exports__ = (() => {
     source;
     // | Function;
     url;
+    /** Lazily resolves a classic worker fallback URL. */
+    getUrl;
+    /** Creates a browser Worker directly. */
+    loadWorker;
     maxConcurrency = 1;
     maxMobileConcurrency = 1;
     onDebug = () => {
@@ -1031,6 +1084,7 @@ var __exports__ = (() => {
     props = {};
     jobQueue = [];
     idleQueue = [];
+    activeJobs = /* @__PURE__ */ new Set();
     count = 0;
     isDestroyed = false;
     /** Checks if workers are supported on this platform */
@@ -1044,13 +1098,19 @@ var __exports__ = (() => {
     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
+     * 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() {
+    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;
     }
@@ -1073,8 +1133,11 @@ var __exports__ = (() => {
       }
     }
     async startJob(name, onMessage2 = (job, type, data) => job.done(data), onError = (job, error) => job.error(error)) {
-      const startPromise = new Promise((onStart) => {
-        this.jobQueue.push({ name, onMessage: onMessage2, onError, onStart });
+      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();
@@ -1102,6 +1165,7 @@ var __exports__ = (() => {
           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);
@@ -1110,6 +1174,7 @@ var __exports__ = (() => {
           await job.result;
         } catch {
         } finally {
+          this.activeJobs.delete(job);
           this.returnWorkerToQueue(workerThread);
         }
       }
@@ -1124,13 +1189,16 @@ var __exports__ = (() => {
      */
     returnWorkerToQueue(worker) {
       const shouldDestroyWorker = (
-        // If the pool is destroyed, there is no reason to keep the worker around
+        // 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) {
-        worker.destroy();
+        if (!worker.terminated) {
+          worker.destroy();
+        }
         this.count--;
       } else {
         worker.unref();
@@ -1150,7 +1218,13 @@ var __exports__ = (() => {
       if (this.count < this._getMaxConcurrency()) {
         this.count++;
         const name = `${this.name.toLowerCase()} (#${this.count} of ${this.maxConcurrency})`;
-        return new WorkerThread({ name, source: this.source, url: this.url });
+        return new WorkerThread({
+          name,
+          source: this.source,
+          url: this.url,
+          getUrl: this.getUrl,
+          loadWorker: this.loadWorker
+        });
       }
       return null;
     }
@@ -1167,9 +1241,13 @@ var __exports__ = (() => {
     onDebug: () => {
     }
   };
-  var _WorkerFarm = class {
+  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();
@@ -1187,12 +1265,13 @@ var __exports__ = (() => {
       this.workerPools = /* @__PURE__ */ new Map();
     }
     /**
-     * Terminate all workers in the farm
+     * 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() {
+    destroy(reason) {
       for (const workerPool of this.workerPools.values()) {
-        workerPool.destroy();
+        workerPool.destroy(reason);
       }
       this.workerPools = /* @__PURE__ */ new Map();
     }
@@ -1208,24 +1287,28 @@ var __exports__ = (() => {
     }
     /**
      * Returns a worker pool for the specified worker
-     * @param options - only used first time for a specific worker name
-     * @param options.name - the name of the worker - used to identify worker pool
-     * @param options.url -
-     * @param options.source -
+     * @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 } = options;
-      let workerPool = this.workerPools.get(name);
+      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
+          url,
+          getUrl,
+          loadWorker
         });
         workerPool.setProps(this._getWorkerPoolProps());
-        this.workerPools.set(name, workerPool);
+        this.workerPools.set(workerPoolKey, workerPool);
       }
       return workerPool;
     }
@@ -1238,9 +1321,91 @@ var __exports__ = (() => {
       };
     }
   };
-  var WorkerFarm = _WorkerFarm;
-  // singleton
-  __publicField(WorkerFarm, "_workerFarm");
+  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();
@@ -1248,31 +1413,41 @@ var __exports__ = (() => {
     const warning = worker.version !== VERSION3 ? ` (worker-utils@${VERSION3})` : "";
     return `${worker.name}@${worker.version}${warning}`;
   }
-  function getWorkerURL(worker, options = {}) {
+  function getCustomWorkerURL(worker, options = {}) {
     const workerOptions = options[worker.id] || {};
-    const workerFile = isBrowser3 ? `${worker.id}-worker.js` : `${worker.id}-worker-node.js`;
+    const workerFile = isBrowser3 ? 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 || options?.core?._workerType;
-    if (workerType === "test") {
+    if (!url && workerType === "test") {
       if (isBrowser3) {
         url = `modules/${worker.module}/dist/${workerFile}`;
       } else {
         url = `modules/${worker.module}/src/workers/${worker.id}-worker-node.ts`;
       }
     }
-    if (!url) {
-      let version2 = worker.version;
-      if (version2 === "latest") {
-        version2 = NPM_TAG;
-      }
-      const versionTag = version2 ? `@${version2}` : "";
-      url = `https://unpkg.com/@loaders.gl/${worker.module}${versionTag}/dist/${workerFile}`;
+    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);
+    assert3(url);
+    return url;
+  }
+  function getDefaultWorkerURL(worker, warn = false) {
+    const workerFile = isBrowser3 ? 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);
     }
-    assert3(url);
     return url;
   }
   function warnIfUsingNpmTagFallback(worker, url) {
@@ -1294,32 +1469,197 @@ var __exports__ = (() => {
     if (!WorkerFarm.isSupported()) {
       return false;
     }
-    return worker.worker && options?.worker;
+    const workerOptions = options?.[worker.id];
+    return Boolean(
+      (worker.worker || worker.loadWorker || workerOptions?.workerUrl) && options?.worker
+    );
   }
   async function processOnWorker(worker, data, options = {}, context = {}, jobContext = {}) {
+    throwIfAborted(options.signal);
     const name = getWorkerName(worker);
     const workerFarm = WorkerFarm.getWorkerFarm(options);
-    const { source } = options;
-    const workerPoolProps = { name, source };
-    if (!source) {
-      workerPoolProps.url = getWorkerURL(worker, options);
-    }
-    const workerPool = workerFarm.getWorkerPool(workerPoolProps);
+    const 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 transferableOptions = getTransferListForWriter(options);
-    const transferableContext = getTransferListForWriter(jobContext);
-    job.postMessage("process", {
-      input: data,
-      options: transferableOptions,
-      context: transferableContext
-    });
-    const result = await job.result;
-    return result.result;
+    const abortJob = () => job.abort(getAbortReason(options.signal));
+    options.signal?.addEventListener("abort", abortJob, { once: true });
+    if (options.signal?.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 {
+      options.signal?.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) {
+    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));
+    options.signal?.addEventListener("abort", abortJob, { once: true });
+    if (options.signal?.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 {
+      options.signal?.removeEventListener("abort", abortJob);
+      if (job.isRunning) {
+        job.abort(createAbortError2("Worker batch iterator was closed"));
+      }
+      if (!inputFinished) {
+        closeInputIterator(inputIterator);
+      }
+    }
+  }
+  function throwIfAborted(signal) {
+    if (!signal?.aborted) {
+      return;
+    }
+    throw getAbortReason(signal);
+  }
+  function getAbortReason(signal) {
+    return 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) {
+    try {
+      void Promise.resolve(inputIterator.return?.()).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 (isBrowser3 && 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) {
@@ -1360,12 +1700,16 @@ var __exports__ = (() => {
 
   // ../loader-utils/src/lib/worker-loader-utils/parse-with-worker.ts
   function canParseWithWorker(loader, options) {
+    if (options?.core?.credentials?.some(
+      (credential) => credential.type === "request" || "token" in credential && typeof credential.token === "function"
+    ))
+      return false;
     const workerOptions = getWorkerOptions(options);
     const nodeWorkers = workerOptions._nodeWorkers;
     if (!isBrowser3 && !nodeWorkers) {
       return false;
     }
-    if (loader.id === "excel" && options?.excel?.shape === "arrow-table" || loader.id === "ply" && options?.ply?.shape === "arrow-table") {
+    if (loader.id === "las" && (options?.las?.shape ?? "arrow-table") === "arrow-table") {
       return false;
     }
     if (loader.id === "csv" && !shouldParseCSVWithWorker(options)) {
@@ -1373,22 +1717,42 @@ var __exports__ = (() => {
     }
     return Boolean(canProcessOnWorker(loader, workerOptions));
   }
-  async function parseWithWorker(loader, data, options, context, parseOnMainThread) {
+  function shouldParseWithWorker(loader, data, options, context, estimateLoader = loader) {
+    if (!canParseWithWorker(loader, options)) {
+      return false;
+    }
+    if (options?.core?.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 >= (options.core?.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),
+      { ...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 mainThreadContext = context ? { ...context, ...parseContext || {} } : void 0;
+          const { _loaderIds, _loaderIsArray, ...workerParseContext } = parseContext || {};
+          const mainThreadContext = context || parseContext ? { ...context, ...workerParseContext } : void 0;
           return await callParseOnMainThread(
             parseOnMainThread,
             input,
             processOptions,
-            mainThreadContext
+            mainThreadContext,
+            resolveWorkerLoaders(loader, _loaderIds, _loaderIsArray, context, options)
           );
         }
       },
@@ -1396,18 +1760,93 @@ var __exports__ = (() => {
     );
     return isLoaderWithWorkerResultDeserializer(loader) ? loader.deserializeWorkerResult(result, options, context) : result;
   }
-  function callParseOnMainThread(parseOnMainThread, input, options, context) {
-    if (parseOnMainThread.length <= 2) {
+  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) {
+    const parquetSignal = options?.parquet?.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, void 0, options, context);
+    return parseOnMainThread(input, loaders, options, context);
   }
-  function getWorkerOptions(options = {}) {
-    const serializedOptions = JSON.parse(JSON.stringify(options));
-    return {
+  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?.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) {
+      if (visitedLoaders.has(candidate)) return;
+      visitedLoaders.add(candidate);
+      availableLoaders.set(candidate.id, candidate);
+      for (const [name, dependency] of Object.entries(candidate.subloaders || {})) {
+        const replacement = options?.core?.subloaders?.[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) {
@@ -1469,6 +1908,19 @@ var __exports__ = (() => {
     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);
@@ -1795,6 +2247,7 @@ var __exports__ = (() => {
     /** 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 };
@@ -1862,20 +2315,27 @@ var __exports__ = (() => {
           isDone = true;
           this.requestMap.delete(handle);
           this.activeRequestCount--;
-          this._issueNewRequests();
+          this.scheduleRefill();
         }
       };
       this.activeRequestCount++;
       return resolve2 ? resolve2({ done }) : Promise.resolve({ done });
     }
-    /** We check requests asynchronously, to prevent multiple updates */
+    /** 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);
     }
-    /** Refresh all requests  */
+    /** Clears timer ownership before updating priorities and dispatching queued requests. */
     _issueNewRequestsAsync() {
       if (this.updateTimer !== null) {
         clearTimeout(this.updateTimer);
@@ -1917,6 +2377,267 @@ var __exports__ = (() => {
     }
   };
 
+  // ../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?.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) {
+    if (!options.core?.credentials?.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) {
+    if (!options.core?.credentials?.length || options.core.credentials.every(isAuthentication)) {
+      return options;
+    }
+    const contributions = await loader?.getAuthentications?.(url, options);
+    if (!contributions?.length) return resolveAuthenticationOptions(options);
+    return resolveAuthenticationOptions({
+      ...options,
+      core: {
+        ...options.core,
+        authentications: [...options.core?.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?.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?.credentials.length === resolvedCredentials.length && resolvedCredentials.every(
+      (credential, index) => credential === existingMetadata.credentials[index]
+    )))
+      return suppliedFetch;
+    const baseFetch = existingMetadata?.fetch || suppliedFetch;
+    const credentials = existingMetadata ? [.../* @__PURE__ */ new Set([...resolvedCredentials, ...existingMetadata.credentials])] : resolvedCredentials;
+    const fetchOptions = mergeFetchOptions(
+      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 = {}) => {
+      requestOptions = mergeFetchOptions(fetchOptions, requestOptions);
+      if (requestOptions.signal?.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) || credential.canReplayRequest?.(url, requestOptions)) && (isReplayableRequest(signedRequest.options) || credential.canReplayRequest?.(signedRequest.url, signedRequest.options)) && (credential.refreshStatusCodes.includes(response.status) || await credential.shouldRefresh?.(response)))
+          refreshableCredentials.push(resolvedCredential);
+      }
+      const shouldRetrySignature = isReplayableRequest(requestOptions) && isReplayableRequest(signedRequest.options) && signedRequest.credentials.some(
+        (credential) => credential.refreshStatusCodes?.includes(response.status)
+      );
+      if (!refreshableCredentials.length && !shouldRetrySignature) return response;
+      if (requestOptions.signal?.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 response.body?.cancel().catch(() => {
+      });
+      if (requestOptions.signal?.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?.headers) {
+      const headers = new Headers(defaultOptions.headers);
+      new Headers(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?.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?.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 = {};
@@ -1939,91 +2660,6 @@ var __exports__ = (() => {
     return filename2;
   }
 
-  // ../loader-utils/src/json-loader.ts
-  var VERSION4 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
-  var JSONLoader = {
-    dataType: null,
-    batchType: null,
-    name: "JSON",
-    id: "json",
-    module: "json",
-    version: VERSION4,
-    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/path-utils/path.ts
   var path_exports = {};
   __export(path_exports, {
@@ -2038,7 +2674,7 @@ var __exports__ = (() => {
     if (typeof process !== "undefined" && typeof process.cwd !== "undefined") {
       return process.cwd();
     }
-    const pathname = window.location?.pathname;
+    const pathname = globalThis.location?.pathname;
     return pathname?.slice(0, pathname.lastIndexOf("/") + 1) || "";
   }
 
@@ -2167,6 +2803,91 @@ var __exports__ = (() => {
     return res;
   }
 
+  // ../loader-utils/src/json-loader.ts
+  var VERSION4 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+  var JSONLoader = {
+    dataType: null,
+    batchType: null,
+    name: "JSON",
+    id: "json",
+    module: "json",
+    version: VERSION4,
+    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;
@@ -2188,8 +2909,14 @@ var __exports__ = (() => {
         isDirectory: false
       };
     }
-    async read(start, length) {
+    async read(start, length, signal) {
+      if (signal?.aborted) {
+        throw new Error("Request aborted");
+      }
       const arrayBuffer = await this.handle.slice(Number(start), Number(start) + Number(length)).arrayBuffer();
+      if (signal?.aborted) {
+        throw new Error("Request aborted");
+      }
       return arrayBuffer;
     }
   };
@@ -2410,19 +3137,11 @@ var __exports__ = (() => {
     }
     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);
-  }
 
   // src/lib/fetch/fetch-file.ts
   function isNodePath(url) {
@@ -2532,6 +3251,7 @@ var __exports__ = (() => {
 
   // src/lib/loader-utils/option-defaults.ts
   var DEFAULT_LOADER_OPTIONS = {
+    searchParams: void 0,
     core: {
       baseUrl: void 0,
       // baseUrl
@@ -2544,9 +3264,11 @@ var __exports__ = (() => {
       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,
@@ -2622,6 +3344,7 @@ var __exports__ = (() => {
     "useLocalLibraries",
     "CDN",
     "worker",
+    "workerThreshold",
     "maxConcurrency",
     "maxMobileConcurrency",
     "reuseWorkers",
@@ -2636,6 +3359,27 @@ var __exports__ = (() => {
     "metadata",
     "transforms"
   ];
+  function applySearchParamsToUrl(url, options) {
+    const searchParams = 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;
@@ -2662,7 +3406,10 @@ var __exports__ = (() => {
     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);
@@ -2686,6 +3433,12 @@ var __exports__ = (() => {
       validateOptionsObject(idOptions, loader.id, loaderOptions, deprecatedOptions, loaders);
     }
   }
+  function validateWorkerThreshold(options) {
+    const threshold = options.core?.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}.` : "";
@@ -3201,20 +3954,57 @@ var __exports__ = (() => {
   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?._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;
         }
+        if (options?._streamReadAhead) {
+          nextBatchPromise = reader.read();
+          void nextBatchPromise.catch(() => {
+          });
+        }
         yield toArrayBuffer2(value);
       }
-    } catch (_error) {
-      reader.releaseLock();
+    } catch (error) {
+      iteratorFailed = true;
+      throw error;
+    } finally {
+      let cleanupFailed = false;
+      let cleanupError;
+      if (!streamFinished && !streamReadFailed) {
+        try {
+          await reader.cancel();
+        } catch (error) {
+          cleanupFailed = true;
+          cleanupError = error;
+        }
+      }
+      try {
+        reader.releaseLock();
+      } catch (error) {
+        if (!cleanupFailed) {
+          cleanupFailed = true;
+          cleanupError = error;
+        }
+      }
+      if (!iteratorFailed && cleanupFailed) {
+        throw cleanupError;
+      }
     }
   }
   async function* makeNodeStreamIterator(stream, options) {
@@ -3335,14 +4125,14 @@ var __exports__ = (() => {
   }
   function getIterableFromData(data) {
     if (ArrayBuffer.isView(data)) {
-      return function* oneChunk() {
+      return (function* oneChunk() {
         yield toArrayBuffer2(data);
-      }();
+      })();
     }
     if (isArrayBufferLike(data)) {
-      return function* oneChunk() {
+      return (function* oneChunk() {
         yield toArrayBuffer2(data);
-      }();
+      })();
     }
     if (isIterator(data)) {
       return data;
@@ -3358,22 +4148,37 @@ var __exports__ = (() => {
     const globalOptions = getGlobalLoaderOptions();
     const loaderOptions = options || globalOptions;
     const fetchOption = loaderOptions.fetch ?? loaderOptions.core?.fetch;
+    let fetchFunction;
     if (typeof fetchOption === "function") {
-      return fetchOption;
-    }
-    if (isObject(fetchOption)) {
-      return (url) => fetchFile(url, fetchOption);
-    }
-    if (context?.fetch) {
-      return context?.fetch;
+      fetchFunction = fetchOption;
+    } else if (isObject(fetchOption)) {
+      fetchFunction = context?.fetch || fetchFile;
+    } else if (context?.fetch) {
+      fetchFunction = context.fetch;
+    } else {
+      fetchFunction = fetchFile;
     }
-    return fetchFile;
+    return createAuthenticatedFetch({
+      fetch: fetchFunction,
+      credentials: loaderOptions.core?.credentials || [],
+      authentications: loaderOptions.core?.authentications,
+      fetchOptions: isObject(fetchOption) ? fetchOption : void 0
+    });
   }
 
   // src/lib/api/load-loader.ts
   var loaderImplementationPromises = /* @__PURE__ */ new Map();
   var loaderImplementations = /* @__PURE__ */ new Map();
   async function getLoaderImplementation(loader, options, url) {
+    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 (isLoaderWithParser(loader)) {
       return loader;
     }
@@ -3409,6 +4214,11 @@ var __exports__ = (() => {
     return await loaderImplementationPromise;
   }
   function getLoaderImplementationSync(loader) {
+    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;
     }
@@ -3451,12 +4261,7 @@ var __exports__ = (() => {
   function getLoaderImplementationCacheKey(loader, options) {
     const loaderOptions = options?.[loader.id];
     const defaultLoaderOptions = loader.options?.[loader.id];
-    return String(
-      loaderOptions?.backend || getDeprecatedImplementationBackend(loaderOptions?.implementation) || defaultLoaderOptions?.backend || ""
-    );
-  }
-  function getDeprecatedImplementationBackend(implementation) {
-    return implementation === "js" ? "typescript" : implementation;
+    return String(loaderOptions?.backend || defaultLoaderOptions?.backend || "");
   }
   async function importLoaderImplementation(implementationSpecifier, loaderId) {
     const moduleExports = await import(
@@ -3473,6 +4278,104 @@ var __exports__ = (() => {
       `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) {
+    const overrides = options?.core?.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]);
+      }
+    }
+  }
+  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) => {
+          const forwardedOptions = mergeOptions(options, parseOptions || {});
+          return parser.call(
+            implementation,
+            data,
+            {
+              ...forwardedOptions,
+              core: {
+                ...forwardedOptions.core,
+                subloaders: options?.core?.subloaders || parseOptions?.core?.subloaders,
+                worker: false
+              },
+              [loader.id]: { ...forwardedOptions[loader.id], subloaders }
+            },
+            context
+          );
+        };
+      }
+    }
+    preparedLoaders.add(prepared);
+    return prepared;
+  }
 
   // src/lib/api/parse-file.ts
   async function parseFile(file, loaders, options, context) {
@@ -3494,7 +4397,13 @@ var __exports__ = (() => {
         `${loader.id} is a SourceLoader. Use load() to create a runtime source object instead of parseFile().`
       );
     }
-    const strictOptions = normalizeOptions(options, loader, candidateLoaders, url);
+    const normalizedOptions = normalizeOptions(options, loader, candidateLoaders, url);
+    const authenticationLoader = !loader.getAuthentications && normalizedOptions.core?.credentials?.length ? await getLoaderImplementation(loader, normalizedOptions, url || context?.url) : loader;
+    const strictOptions = await resolveLoaderAuthenticationOptions(
+      authenticationLoader,
+      url,
+      normalizedOptions
+    );
     context = getLoaderContext(
       // @ts-expect-error candidateLoaders may be a single forced loader
       { url, _parse: parse, loaders: candidateLoaders },
@@ -3587,7 +4496,7 @@ var __exports__ = (() => {
       case "geojson-table":
         return Array.isArray(table.features);
       case "columnar-table":
-        return table.data && typeof table.data === "object";
+        return Boolean(table.data && typeof table.data === "object");
       case "arrow-table":
         return Boolean(table?.data?.numRows !== void 0);
       default:
@@ -3634,7 +4543,13 @@ var __exports__ = (() => {
     if (!loader) {
       return [];
     }
-    const strictOptions = normalizeOptions(options, loader, loaderArray, url);
+    const normalizedOptions = normalizeOptions(options, loader, loaderArray, url);
+    const authenticationLoader = !loader.getAuthentications && normalizedOptions.core?.credentials?.length ? await getLoaderImplementation(loader, normalizedOptions, url || context?.url) : loader;
+    const strictOptions = await resolveLoaderAuthenticationOptions(
+      authenticationLoader,
+      url || "",
+      normalizedOptions
+    );
     context = getLoaderContext(
       { url, _parseInBatches: parseInBatches, _parse: parse, loaders: loaderArray },
       strictOptions,
@@ -3672,6 +4587,9 @@ var __exports__ = (() => {
       options?.core?.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);
@@ -3716,19 +4634,23 @@ var __exports__ = (() => {
     } else {
       loadersArray = loaders;
     }
-    const fetch2 = getFetchFunction(options || {});
     if (!Array.isArray(files)) {
-      return loadOneFileInBatches(files, loadersArray, options || {}, fetch2);
+      return loadOneFileInBatches(files, loadersArray, options || {});
     }
-    const promises = files.map(
-      (file) => loadOneFileInBatches(file, loadersArray, options || {}, fetch2)
-    );
+    const promises = files.map((file) => loadOneFileInBatches(file, loadersArray, options || {}));
     return promises;
   }
-  async function loadOneFileInBatches(file, loaders, options, fetch2) {
+  async function loadOneFileInBatches(file, loaders, options) {
     if (typeof file === "string") {
       const url = file;
-      const response = await fetch2(url);
+      const loader = await selectLoader(url, loaders, {
+        ...options,
+        core: { ...options.core, nothrow: true }
+      });
+      const authenticationLoader = loader && !loader.getAuthentications && options.core?.credentials?.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);
@@ -3746,7 +4668,14 @@ var __exports__ = (() => {
       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,
@@ -3756,13 +4685,19 @@ var __exports__ = (() => {
         load,
         loadInBatches
       };
-      return resolvedLoaders.createDataSource(
+      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,
@@ -3772,7 +4707,7 @@ var __exports__ = (() => {
         load,
         loadInBatches
       };
-      return resolvedLoaders[0].createDataSource(
+      return sourceLoader.createDataSource(
         url,
         resolvedOptions || {},
         runtimeCoreApi
@@ -3784,7 +4719,13 @@ var __exports__ = (() => {
         core: { ...resolvedOptions?.core, nothrow: true }
       });
       if (selectedLoader && isSourceLoader(selectedLoader)) {
-        return selectedLoader.createDataSource(
+        const sourceLoader = await resolveSourceLoader(selectedLoader, url, resolvedOptions);
+        resolvedOptions = await resolveLoaderAuthenticationOptions(
+          selectedLoader.getAuthentications ? selectedLoader : sourceLoader,
+          typeof url === "string" ? url : "",
+          resolvedOptions || {}
+        );
+        return sourceLoader.createDataSource(
           url,
           resolvedOptions || {},
           {
@@ -3798,11 +4739,29 @@ var __exports__ = (() => {
           }
         );
       }
+      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 (isBlob(url)) {
       data = await fetch2(url);
@@ -3821,6 +4780,16 @@ var __exports__ = (() => {
     }
     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;
+  }
 
   // src/lib/api/core-api.ts
   var coreApi = Object.freeze({
@@ -3836,7 +4805,12 @@ var __exports__ = (() => {
   // src/lib/loader-utils/loader-context.ts
   function getLoaderContext(context, options, parentContext) {
     if (parentContext) {
-      return parentContext;
+      return {
+        ...parentContext,
+        coreApi: parentContext.coreApi || context.coreApi || coreApi,
+        _parse: parentContext._parse || context._parse,
+        fetch: getFetchFunction(options, parentContext)
+      };
     }
     const newContext = {
       ...context,
@@ -3891,7 +4865,13 @@ var __exports__ = (() => {
         `${loader.id} is a SourceLoader. Use load() to create a runtime source object instead of parse().`
       );
     }
-    const strictOptions = normalizeOptions(options, loader, candidateLoaders, url);
+    const normalizedOptions = normalizeOptions(options, loader, candidateLoaders, url);
+    const authenticationLoader = !loader.getAuthentications && normalizedOptions.core?.credentials?.length ? await getLoaderImplementation(loader, normalizedOptions, url || context?.url) : loader;
+    const strictOptions = await resolveLoaderAuthenticationOptions(
+      authenticationLoader,
+      url || "",
+      normalizedOptions
+    );
     context = getLoaderContext(
       // @ts-expect-error
       { url, _parse: parse, loaders: candidateLoaders },
@@ -3909,10 +4889,13 @@ var __exports__ = (() => {
       context.response = { headers, ok, redirected, status, statusText, type, url };
     }
     const loaderWithParser = await getLoaderImplementation(loader, options, context.url);
-    if (canParseWithWorker(loaderWithParser, options)) {
+    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);
   }
@@ -3936,7 +4919,7 @@ var __exports__ = (() => {
 
   // src/lib/api/preload.ts
   async function preload(loader, options, url) {
-    return await getLoaderImplementation(loader, options, url);
+    return loader.subloaders ? await preloadLoaderDependencies(loader, options, url) : await getLoaderImplementation(loader, options, url);
   }
   function preloadSync(loader) {
     return getLoaderImplementationSync(loader);
@@ -4064,7 +5047,7 @@ var __exports__ = (() => {
   }
 
   // src/lib/api/create-data-source.ts
-  function createDataSource(data, sources, options) {
+  function createDataSource(data, sources, options = {}) {
     const resolvedOptions = options || {};
     const type = resolvedOptions?.core?.type || resolvedOptions.type || "auto";
     const source = sources.length === 1 ? sources[0] : type === "auto" ? selectLoaderSync(data, sources, {
@@ -4076,7 +5059,29 @@ var __exports__ = (() => {
     if (!source) {
       throw new Error("Not a valid source type");
     }
-    return source.createDataSource(data, resolvedOptions, coreApi);
+    const contributions = resolvedOptions.core?.credentials?.length ? source.getAuthentications?.(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?.length ? {
+        ...resolvedOptions,
+        core: {
+          ...resolvedOptions.core,
+          authentications: [
+            ...resolvedOptions.core?.authentications || [],
+            ...contributions || []
+          ]
+        }
+      } : resolvedOptions
+    );
+    return source.createDataSource(
+      data,
+      authenticatedOptions,
+      coreApi
+    );
   }
   function getSourceOfType(type, sources) {
     for (const service of sources) {
@@ -4267,18 +5272,29 @@ var __exports__ = (() => {
       if (path.includes("://")) {
         return this._fetch(path, options);
       }
-      const file = this.files[path];
+      const file = this._getFile(path, true);
       if (!file) {
         return new Response(path, { status: 400, statusText: "NOT FOUND" });
       }
       const headers = new Headers(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);
+        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;
       }
@@ -4302,7 +5318,7 @@ var __exports__ = (() => {
      * Return information (size) about files in this file system
      */
     async stat(path, options) {
-      const file = this.files[path];
+      const file = this._getFile(path, false);
       if (!file) {
         throw new Error(path);
       }
@@ -4312,19 +5328,22 @@ var __exports__ = (() => {
      * Just removes the file from the list
      */
     async unlink(path) {
-      delete this.files[path];
-      delete this.lowerCaseFiles[path];
-      this.usedFiles[path] = true;
+      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 BlobFile(this.files[pathname]);
+      return new BlobFile(this._getFile(pathname, true));
     }
     // PRIVATE
     // Supports case independent paths, and file usage tracking
     _getFile(path, used) {
-      const file = this.files[path] || this.lowerCaseFiles[path];
+      const file = this.files[path] || this.lowerCaseFiles[path.toLowerCase()];
       if (file && used) {
         this.usedFiles[path] = true;
       }