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

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() {
     }
   };
@@ -998,8 +1023,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 {
@@ -1124,13 +1150,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();
@@ -1167,9 +1196,11 @@ var __exports__ = (() => {
     onDebug: () => {
     }
   };
-  var _WorkerFarm = class {
+  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();
@@ -1238,9 +1269,6 @@ var __exports__ = (() => {
       };
     }
   };
-  var WorkerFarm = _WorkerFarm;
-  // singleton
-  __publicField(WorkerFarm, "_workerFarm");
 
   // ../worker-utils/src/lib/worker-api/get-worker-url.ts
   var warnedWorkerVersionFallbacks = /* @__PURE__ */ new Set();
@@ -1250,8 +1278,11 @@ var __exports__ = (() => {
   }
   function getWorkerURL(worker, options = {}) {
     const workerOptions = options[worker.id] || {};
-    const workerFile = isBrowser3 ? `${worker.id}-worker.js` : `${worker.id}-worker-node.js`;
+    const workerFile = isBrowser3 ? `${worker.id}-worker.js` : worker.workerNode || `${worker.id}-worker-node.js`;
     let url = workerOptions.workerUrl;
+    if (!url && typeof worker.worker === "string") {
+      url = worker.worker;
+    }
     if (!url && worker.id === "compression") {
       url = options.workerUrl;
     }
@@ -1294,9 +1325,11 @@ var __exports__ = (() => {
     if (!WorkerFarm.isSupported()) {
       return false;
     }
-    return worker.worker && options?.worker;
+    const workerOptions = options?.[worker.id];
+    return Boolean((worker.worker || 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;
@@ -1311,15 +1344,41 @@ var __exports__ = (() => {
       // 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 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;
   }
   async function onMessage(context, job, type, payload) {
     switch (type) {
@@ -1373,11 +1432,12 @@ var __exports__ = (() => {
     }
     return Boolean(canProcessOnWorker(loader, workerOptions));
   }
-  async function parseWithWorker(loader, data, options, context, parseOnMainThread) {
+  async function parseWithWorker(loader, data, options, context, parseOnMainThread, signal) {
+    const workerSignal = signal || getWorkerAbortSignal(options);
     const result = await processOnWorker(
       loader,
       data,
-      getWorkerOptions(options),
+      { ...getWorkerOptions(options), signal: workerSignal },
       {
         process: async (input, processOptions, _workerContext, parseContext) => {
           if (!parseOnMainThread) {
@@ -1396,6 +1456,13 @@ var __exports__ = (() => {
     );
     return isLoaderWithWorkerResultDeserializer(loader) ? loader.deserializeWorkerResult(result, options, context) : result;
   }
+  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) {
     if (parseOnMainThread.length <= 2) {
       return parseOnMainThread(input, options);
@@ -1917,6 +1984,114 @@ var __exports__ = (() => {
     }
   };
 
+  // ../loader-utils/src/lib/request-utils/request-credentials.ts
+  var AUTHENTICATED_FETCH = /* @__PURE__ */ Symbol("loaders.gl.authenticated-fetch");
+  var refreshPromises = /* @__PURE__ */ new WeakMap();
+  function createAuthenticatedFetch(options) {
+    const baseFetch = options.fetch || ((url, requestOptions) => fetch(url, requestOptions));
+    if (!options.credentials.length) return baseFetch;
+    const existingMetadata = baseFetch[AUTHENTICATED_FETCH];
+    if (existingMetadata === options.credentials) return baseFetch;
+    const authenticatedFetch = async (url, requestOptions = {}) => {
+      const resolvedURL = parseHTTPURL(url);
+      if (!resolvedURL) return baseFetch(url, requestOptions);
+      const authorization = await authorizeRequest(resolvedURL, requestOptions, options.credentials);
+      const response = await baseFetch(authorization.url, authorization.options);
+      const refreshableCredentials = authorization.credentials.filter(
+        ({ credential }) => typeof credential.token === "function" && credential.refreshStatusCodes.includes(response.status)
+      );
+      if (!refreshableCredentials.length || !isReplayableRequest(requestOptions)) return response;
+      if (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) return response;
+      await response.body?.cancel().catch(() => {
+      });
+      if (requestOptions.signal?.aborted) throw createAbortError3();
+      const replayAuthorization = await authorizeRequest(
+        resolvedURL,
+        requestOptions,
+        options.credentials,
+        refreshedTokens,
+        authorization.credentials
+      );
+      return baseFetch(replayAuthorization.url, replayAuthorization.options);
+    };
+    Object.defineProperty(authenticatedFetch, AUTHENTICATED_FETCH, {
+      value: options.credentials
+    });
+    return authenticatedFetch;
+  }
+  async function authorizeRequest(sourceURL, requestOptions, credentials, tokenOverrides = /* @__PURE__ */ new Map(), previousCredentials = []) {
+    const url = new URL(sourceURL);
+    const headers = new Headers(requestOptions.headers);
+    const resolvedCredentials = [];
+    const previousTokens = new Map(
+      previousCredentials.map(({ credential, token }) => [credential, token])
+    );
+    for (const credential of credentials) {
+      if (!credential.origins.includes(url.origin)) continue;
+      const overrideToken = tokenOverrides.get(credential);
+      const previousToken = previousTokens.get(credential);
+      const ownsQueryParameter = credential.type === "query-parameter" && previousToken !== void 0;
+      const ownsHeader = credential.type === "header" && previousToken !== void 0;
+      if (credential.type === "query-parameter" && url.searchParams.has(credential.name) && !ownsQueryParameter || credential.type === "header" && headers.has(credential.name) && !ownsHeader) {
+        continue;
+      }
+      const token = overrideToken ?? previousToken ?? await resolveToken(credential.token, { url: sourceURL.toString(), reason: "request" });
+      if (!token) continue;
+      if (credential.type === "query-parameter") {
+        url.searchParams.set(credential.name, token);
+      } else {
+        headers.set(credential.name, `${credential.prefix || ""}${token}`);
+      }
+      resolvedCredentials.push({ credential, token });
+    }
+    return {
+      url: url.toString(),
+      options: { ...requestOptions, headers },
+      credentials: resolvedCredentials
+    };
+  }
+  async function refreshCredential(credential, url, response) {
+    const existingPromise = refreshPromises.get(credential);
+    if (existingPromise) return existingPromise;
+    const tokenProvider = credential.token;
+    const promise = Promise.resolve(
+      tokenProvider({
+        url,
+        reason: "refresh",
+        response: { status: response.status, headers: response.headers }
+      })
+    ).finally(() => refreshPromises.delete(credential));
+    refreshPromises.set(credential, promise);
+    return promise;
+  }
+  async function resolveToken(token, context) {
+    return typeof token === "function" ? token(context) : token;
+  }
+  function parseHTTPURL(url) {
+    try {
+      const parsedURL = new URL(url);
+      return ["http:", "https:"].includes(parsedURL.protocol) ? parsedURL : null;
+    } catch {
+      return null;
+    }
+  }
+  function isReplayableRequest(options) {
+    const method = (options.method || "GET").toUpperCase();
+    if (!["GET", "HEAD", "OPTIONS", "PUT", "DELETE"].includes(method)) return false;
+    return !(options.body && typeof ReadableStream !== "undefined" && options.body instanceof ReadableStream);
+  }
+  function createAbortError3() {
+    return new DOMException("The operation was aborted.", "AbortError");
+  }
+
   // ../loader-utils/src/lib/path-utils/file-aliases.ts
   var pathPrefix = "";
   var fileAliases = {};
@@ -1939,91 +2114,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, {
@@ -2167,6 +2257,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 +2363,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;
     }
   };
@@ -3201,20 +3382,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 +3553,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,16 +3576,29 @@ 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);
+      fetchFunction = fetchOption;
+    } else if (isObject(fetchOption)) {
+      fetchFunction = (url, requestOptions) => fetchFile(url, mergeFetchOptions(fetchOption, requestOptions));
+    } else if (context?.fetch) {
+      fetchFunction = context.fetch;
+    } else {
+      fetchFunction = fetchFile;
     }
-    if (context?.fetch) {
-      return context?.fetch;
+    return createAuthenticatedFetch({
+      fetch: fetchFunction,
+      credentials: loaderOptions.core?.credentials || []
+    });
+  }
+  function mergeFetchOptions(defaultOptions, requestOptions) {
+    const options = { ...defaultOptions, ...requestOptions };
+    if (defaultOptions.headers || requestOptions?.headers) {
+      const headers = new Headers(defaultOptions.headers);
+      new Headers(requestOptions?.headers).forEach((value, key) => headers.set(key, value));
+      options.headers = headers;
     }
-    return fetchFile;
+    return options;
   }
 
   // src/lib/api/load-loader.ts
@@ -3451,12 +3682,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(
@@ -3587,7 +3813,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:
@@ -3747,6 +3973,7 @@ var __exports__ = (() => {
       resolvedOptions = options;
     }
     if (!Array.isArray(resolvedLoaders) && isSourceLoader(resolvedLoaders)) {
+      const sourceLoader = await resolveSourceLoader(resolvedLoaders, url, resolvedOptions);
       const runtimeCoreApi = {
         fetchFile,
         parse,
@@ -3756,13 +3983,14 @@ 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);
       const runtimeCoreApi = {
         fetchFile,
         parse,
@@ -3772,7 +4000,7 @@ var __exports__ = (() => {
         load,
         loadInBatches
       };
-      return resolvedLoaders[0].createDataSource(
+      return sourceLoader.createDataSource(
         url,
         resolvedOptions || {},
         runtimeCoreApi
@@ -3784,7 +4012,8 @@ var __exports__ = (() => {
         core: { ...resolvedOptions?.core, nothrow: true }
       });
       if (selectedLoader && isSourceLoader(selectedLoader)) {
-        return selectedLoader.createDataSource(
+        const sourceLoader = await resolveSourceLoader(selectedLoader, url, resolvedOptions);
+        return sourceLoader.createDataSource(
           url,
           resolvedOptions || {},
           {
@@ -3798,6 +4027,15 @@ var __exports__ = (() => {
           }
         );
       }
+      if (selectedLoader && typeof url === "string") {
+        const loaderImplementation = await getLoaderImplementation(
+          selectedLoader,
+          resolvedOptions,
+          url
+        );
+        const parseUrl = loaderImplementation.parseUrl;
+        if (parseUrl) return await parseUrl(url, resolvedOptions, context);
+      }
     }
     const fetch2 = getFetchFunction(resolvedOptions);
     let data = url;
@@ -3821,6 +4059,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({
@@ -3913,6 +4161,9 @@ var __exports__ = (() => {
       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);
   }
@@ -4267,18 +4518,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 +4564,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 +4574,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;
       }