@loaders.gl/core 4.4.5 → 5.0.0-alpha.2

package/dist/index.cjs

@@ -18,21 +18,22 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // dist/index.js
-var dist_exports = {};
-__export(dist_exports, {
+var index_exports = {};
+__export(index_exports, {
   FetchError: () => FetchError,
-  JSONLoader: () => import_loader_utils22.JSONLoader,
+  JSONLoader: () => JSONLoader,
   NullLoader: () => NullLoader,
   NullWorkerLoader: () => NullWorkerLoader,
-  RequestScheduler: () => import_loader_utils21.RequestScheduler,
+  RequestScheduler: () => RequestScheduler,
   _BrowserFileSystem: () => BrowserFileSystem,
   _fetchProgress: () => fetchProgress,
-  _selectSource: () => selectSource2,
+  _selectSource: () => selectSource,
   _unregisterLoaders: () => _unregisterLoaders,
-  assert: () => import_loader_utils24.assert,
-  concatenateArrayBuffersAsync: () => import_loader_utils25.concatenateArrayBuffersAsync,
+  assert: () => assert,
+  concatenateArrayBuffersAsync: () => concatenateArrayBuffersAsync,
+  coreApi: () => coreApi,
   createDataSource: () => createDataSource,
-  document: () => import_loader_utils23.document,
+  document: () => document_,
   encode: () => encode,
   encodeInBatches: () => encodeInBatches,
   encodeSync: () => encodeSync,
@@ -43,48 +44,1553 @@ __export(dist_exports, {
   encodeTextSync: () => encodeTextSync,
   encodeURLtoURL: () => encodeURLtoURL,
   fetchFile: () => fetchFile,
-  forEach: () => import_loader_utils25.forEach,
+  forEach: () => forEach,
   getLoaderOptions: () => getGlobalLoaderOptions,
-  getPathPrefix: () => import_loader_utils20.getPathPrefix,
-  global: () => import_loader_utils23.global,
-  isAsyncIterable: () => import_loader_utils27.isAsyncIterable,
-  isBrowser: () => import_loader_utils23.isBrowser,
-  isIterable: () => import_loader_utils27.isIterable,
-  isIterator: () => import_loader_utils27.isIterator,
-  isPromise: () => import_loader_utils27.isPromise,
-  isPureObject: () => import_loader_utils27.isPureObject,
-  isReadableStream: () => import_loader_utils27.isReadableStream,
-  isResponse: () => import_loader_utils27.isResponse,
-  isWorker: () => import_loader_utils23.isWorker,
-  isWritableStream: () => import_loader_utils27.isWritableStream,
+  getPathPrefix: () => getPathPrefix,
+  global: () => global_,
+  isAsyncIterable: () => isAsyncIterable,
+  isBrowser: () => isBrowser,
+  isIterable: () => isIterable,
+  isIterator: () => isIterator,
+  isPromise: () => isPromise,
+  isPureObject: () => isPureObject,
+  isReadableStream: () => isReadableStream,
+  isResponse: () => isResponse,
+  isWorker: () => isWorker,
+  isWritableStream: () => isWritableStream,
   load: () => load,
   loadInBatches: () => loadInBatches,
   makeIterator: () => makeIterator,
-  makeLineIterator: () => import_loader_utils26.makeLineIterator,
-  makeNumberedLineIterator: () => import_loader_utils26.makeNumberedLineIterator,
+  makeLineIterator: () => makeLineIterator,
+  makeNumberedLineIterator: () => makeNumberedLineIterator,
   makeStream: () => makeStream,
-  makeTextDecoderIterator: () => import_loader_utils26.makeTextDecoderIterator,
-  makeTextEncoderIterator: () => import_loader_utils26.makeTextEncoderIterator,
+  makeTextDecoderIterator: () => makeTextDecoderIterator,
+  makeTextEncoderIterator: () => makeTextEncoderIterator,
   parse: () => parse,
+  parseFile: () => parseFile,
   parseInBatches: () => parseInBatches,
   parseSync: () => parseSync,
+  preload: () => preload,
+  preloadSync: () => preloadSync,
   readArrayBuffer: () => readArrayBuffer,
   registerLoaders: () => registerLoaders,
-  resolvePath: () => import_loader_utils20.resolvePath,
+  resolvePath: () => resolvePath,
   selectLoader: () => selectLoader,
   selectLoaderSync: () => selectLoaderSync,
-  self: () => import_loader_utils23.self,
+  self: () => self_,
   setLoaderOptions: () => setGlobalOptions,
-  setPathPrefix: () => import_loader_utils20.setPathPrefix,
-  window: () => import_loader_utils23.window
+  setPathPrefix: () => setPathPrefix,
+  window: () => window_
 });
-module.exports = __toCommonJS(dist_exports);
+module.exports = __toCommonJS(index_exports);
 
-// dist/lib/fetch/fetch-file.js
-var import_loader_utils3 = require("@loaders.gl/loader-utils");
+// ../loader-utils/src/lib/env-utils/assert.ts
+function assert(condition, message) {
+  if (!condition) {
+    throw new Error(message || "loader assertion failed.");
+  }
+}
 
-// dist/lib/utils/response-utils.js
-var import_loader_utils2 = require("@loaders.gl/loader-utils");
+// ../loader-utils/src/lib/env-utils/globals.ts
+var globals = {
+  self: typeof self !== "undefined" && self,
+  window: typeof window !== "undefined" && window,
+  global: typeof global !== "undefined" && global,
+  document: typeof document !== "undefined" && document
+};
+var self_ = globals.self || globals.window || globals.global || {};
+var window_ = globals.window || globals.self || globals.global || {};
+var global_ = globals.global || globals.self || globals.window || {};
+var document_ = globals.document || {};
+var isBrowser = (
+  // @ts-ignore process does not exist on browser
+  Boolean(typeof process !== "object" || String(process) !== "[object process]" || process.browser)
+);
+var isWorker = typeof importScripts === "function";
+var matches = typeof process !== "undefined" && process.version && /v([0-9]*)/.exec(process.version);
+var nodeVersion = matches && parseFloat(matches[1]) || 0;
+
+// ../loader-utils/src/lib/log-utils/log.ts
+var import_log = require("@probe.gl/log");
+var VERSION = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+var version = VERSION[0] >= "0" && VERSION[0] <= "9" ? `v${VERSION}` : "";
+function createLog() {
+  const log2 = new import_log.Log({ id: "loaders.gl" });
+  globalThis.loaders ||= {};
+  globalThis.loaders.log = log2;
+  globalThis.loaders.version = version;
+  globalThis.probe ||= {};
+  globalThis.probe.loaders = log2;
+  return log2;
+}
+var log = createLog();
+
+// ../loader-utils/src/lib/javascript-utils/is-type.ts
+var isBoolean = (value) => typeof value === "boolean";
+var isFunction = (value) => typeof value === "function";
+var isObject = (value) => value !== null && typeof value === "object";
+var isPureObject = (value) => isObject(value) && value.constructor === {}.constructor;
+var isSharedArrayBuffer = (value) => typeof SharedArrayBuffer !== "undefined" && value instanceof SharedArrayBuffer;
+var isArrayBufferLike = (value) => isObject(value) && typeof value.byteLength === "number" && typeof value.slice === "function";
+var isPromise = (value) => isObject(value) && "then" in value && isFunction(value.then);
+var isIterable = (value) => Boolean(value) && isFunction(value[Symbol.iterator]);
+var isAsyncIterable = (value) => Boolean(value) && isFunction(value[Symbol.asyncIterator]);
+var isIterator = (value) => Boolean(value) && isFunction(value.next);
+var isResponse = (value) => typeof Response !== "undefined" && value instanceof Response || isObject(value) && isFunction(value.arrayBuffer) && isFunction(value.text) && isFunction(value.json);
+var isBlob = (value) => typeof Blob !== "undefined" && value instanceof Blob;
+var isWritableDOMStream = (value) => isObject(value) && isFunction(value.abort) && isFunction(value.getWriter);
+var isReadableDOMStream = (value) => typeof ReadableStream !== "undefined" && value instanceof ReadableStream || isObject(value) && isFunction(value.tee) && isFunction(value.cancel) && isFunction(value.getReader);
+var isWritableNodeStream = (value) => isObject(value) && isFunction(value.end) && isFunction(value.write) && isBoolean(value.writable);
+var isReadableNodeStream = (value) => isObject(value) && isFunction(value.read) && isFunction(value.pipe) && isBoolean(value.readable);
+var isReadableStream = (value) => isReadableDOMStream(value) || isReadableNodeStream(value);
+var isWritableStream = (value) => isWritableDOMStream(value) || isWritableNodeStream(value);
+
+// ../loader-utils/src/lib/option-utils/merge-options.ts
+function mergeOptions(baseOptions, newOptions) {
+  return mergeOptionsRecursively(baseOptions || {}, newOptions);
+}
+function mergeOptionsRecursively(baseOptions, newOptions, level = 0) {
+  if (level > 3) {
+    return newOptions;
+  }
+  const options = { ...baseOptions };
+  for (const [key, newValue] of Object.entries(newOptions)) {
+    if (isPureObject(newValue)) {
+      options[key] = mergeOptionsRecursively(
+        options[key] || {},
+        newOptions[key],
+        level + 1
+      );
+    } else {
+      options[key] = newOptions[key];
+    }
+  }
+  return options;
+}
+
+// ../loader-utils/src/lib/module-utils/js-module-utils.ts
+function registerJSModules(modules) {
+  globalThis.loaders ||= {};
+  globalThis.loaders.modules ||= {};
+  Object.assign(globalThis.loaders.modules, modules);
+}
+
+// ../worker-utils/src/lib/npm-tag.ts
+var NPM_TAG = "latest";
+
+// ../worker-utils/src/lib/env-utils/version.ts
+function getVersion() {
+  var _a;
+  if (!((_a = globalThis._loadersgl_) == null ? void 0 : _a.version)) {
+    globalThis._loadersgl_ = globalThis._loadersgl_ || {};
+    if (typeof __VERSION__ === "undefined") {
+      globalThis._loadersgl_.version = NPM_TAG;
+    } else {
+      globalThis._loadersgl_.version = __VERSION__;
+    }
+  }
+  return globalThis._loadersgl_.version;
+}
+var VERSION2 = getVersion();
+
+// ../worker-utils/src/lib/env-utils/assert.ts
+function assert2(condition, message) {
+  if (!condition) {
+    throw new Error(message || "loaders.gl assertion failed.");
+  }
+}
+
+// ../worker-utils/src/lib/env-utils/globals.ts
+var globals2 = {
+  self: typeof self !== "undefined" && self,
+  window: typeof window !== "undefined" && window,
+  global: typeof global !== "undefined" && global,
+  document: typeof document !== "undefined" && document
+};
+var self_2 = globals2.self || globals2.window || globals2.global || {};
+var window_2 = globals2.window || globals2.self || globals2.global || {};
+var global_2 = globals2.global || globals2.self || globals2.window || {};
+var document_2 = globals2.document || {};
+var isBrowser2 = (
+  // @ts-ignore process.browser
+  typeof process !== "object" || String(process) !== "[object process]" || process.browser
+);
+var isMobile = typeof window !== "undefined" && typeof window.orientation !== "undefined";
+var matches2 = typeof process !== "undefined" && process.version && /v([0-9]*)/.exec(process.version);
+var nodeVersion2 = matches2 && parseFloat(matches2[1]) || 0;
+
+// ../worker-utils/src/lib/worker-farm/worker-job.ts
+var WorkerJob = class {
+  name;
+  workerThread;
+  isRunning = true;
+  /** Promise that resolves when Job is done */
+  result;
+  _resolve = () => {
+  };
+  _reject = () => {
+  };
+  constructor(jobName, workerThread) {
+    this.name = jobName;
+    this.workerThread = workerThread;
+    this.result = new Promise((resolve2, reject) => {
+      this._resolve = resolve2;
+      this._reject = reject;
+    });
+  }
+  /**
+   * Send a message to the job's worker thread
+   * @param data any data structure, ideally consisting mostly of transferrable objects
+   */
+  postMessage(type, payload) {
+    this.workerThread.postMessage({
+      source: "loaders.gl",
+      // Lets worker ignore unrelated messages
+      type,
+      payload
+    });
+  }
+  /**
+   * Call to resolve the `result` Promise with the supplied value
+   */
+  done(value) {
+    if (!this.isRunning) {
+      return;
+    }
+    this.isRunning = false;
+    this._resolve(value);
+  }
+  /**
+   * Call to reject the `result` Promise with the supplied error
+   */
+  error(error) {
+    if (!this.isRunning) {
+      return;
+    }
+    this.isRunning = false;
+    this._reject(error);
+  }
+  /** Terminates the worker executing this job and rejects its result with an abort error. */
+  abort() {
+    if (!this.isRunning) {
+      return;
+    }
+    const error = new Error(`Worker job "${this.name}" was aborted`);
+    error.name = "AbortError";
+    this.workerThread.destroy();
+    this.error(error);
+  }
+};
+
+// ../worker-utils/src/lib/node/worker_threads-browser.ts
+var NodeWorker = class {
+  /** Restores the native worker constructor when this browser shim is embedded in a Node bundle. */
+  constructor(...arguments_) {
+    var _a;
+    const runtimeProcess = globalThis.process;
+    const WorkerConstructor = (_a = runtimeProcess == null ? void 0 : runtimeProcess.getBuiltinModule) == null ? void 0 : _a.call(runtimeProcess, "node:worker_threads").Worker;
+    if (WorkerConstructor) {
+      return new WorkerConstructor(...arguments_);
+    }
+  }
+  /** No-op browser fallback matching the native Worker API. */
+  terminate() {
+  }
+};
+
+// ../worker-utils/src/lib/worker-utils/get-loadable-worker-url.ts
+var workerURLCache = /* @__PURE__ */ new Map();
+function getLoadableWorkerURL(props) {
+  assert2(props.source && !props.url || !props.source && props.url);
+  let workerURL = workerURLCache.get(props.source || props.url);
+  if (!workerURL) {
+    if (props.url) {
+      workerURL = getLoadableWorkerURLFromURL(props.url);
+      workerURLCache.set(props.url, workerURL);
+    }
+    if (props.source) {
+      workerURL = getLoadableWorkerURLFromSource(props.source);
+      workerURLCache.set(props.source, workerURL);
+    }
+  }
+  assert2(workerURL);
+  return workerURL;
+}
+function getLoadableWorkerURLFromURL(url) {
+  if (!url.startsWith("http")) {
+    return url;
+  }
+  const workerSource = buildScriptSource(url);
+  return getLoadableWorkerURLFromSource(workerSource);
+}
+function getLoadableWorkerURLFromSource(workerSource) {
+  const blob = new Blob([workerSource], { type: "application/javascript" });
+  return URL.createObjectURL(blob);
+}
+function buildScriptSource(workerUrl) {
+  return `try {
+  importScripts('${workerUrl}');
+} catch (error) {
+  console.error(error);
+  throw error;
+}`;
+}
+
+// ../worker-utils/src/lib/worker-utils/get-transfer-list.ts
+function getTransferList(object, recursive = true, transfers) {
+  const transfersSet = transfers || /* @__PURE__ */ new Set();
+  if (!object) {
+  } else if (isTransferable(object)) {
+    transfersSet.add(object);
+  } else if (isTransferable(object.buffer)) {
+    transfersSet.add(object.buffer);
+  } else if (ArrayBuffer.isView(object)) {
+  } else if (recursive && typeof object === "object") {
+    for (const key in object) {
+      getTransferList(object[key], recursive, transfersSet);
+    }
+  }
+  return transfers === void 0 ? Array.from(transfersSet) : [];
+}
+function isTransferable(object) {
+  if (!object) {
+    return false;
+  }
+  if (object instanceof ArrayBuffer) {
+    return true;
+  }
+  if (typeof MessagePort !== "undefined" && object instanceof MessagePort) {
+    return true;
+  }
+  if (typeof ImageBitmap !== "undefined" && object instanceof ImageBitmap) {
+    return true;
+  }
+  if (typeof OffscreenCanvas !== "undefined" && object instanceof OffscreenCanvas) {
+    return true;
+  }
+  return false;
+}
+function getTransferListForWriter(object) {
+  if (object === null) {
+    return {};
+  }
+  const clone = Object.assign({}, object);
+  Object.keys(clone).forEach((key) => {
+    if (typeof object[key] === "object" && !ArrayBuffer.isView(object[key]) && !(object[key] instanceof Array)) {
+      clone[key] = getTransferListForWriter(object[key]);
+    } else if (typeof clone[key] === "function" || clone[key] instanceof RegExp) {
+      clone[key] = {};
+    } else {
+      clone[key] = object[key];
+    }
+  });
+  return clone;
+}
+
+// ../worker-utils/src/lib/worker-farm/worker-thread.ts
+var NOOP = () => {
+};
+var WorkerThread = class {
+  name;
+  source;
+  url;
+  terminated = false;
+  worker;
+  onMessage;
+  onError;
+  _loadableURL = "";
+  /** Checks if workers are supported on this platform */
+  static isSupported() {
+    return typeof Worker !== "undefined" && isBrowser2 || typeof NodeWorker !== "undefined" && !isBrowser2;
+  }
+  constructor(props) {
+    const { name, source, url } = props;
+    assert2(source || url);
+    this.name = name;
+    this.source = source;
+    this.url = url;
+    this.onMessage = NOOP;
+    this.onError = (error) => console.log(error);
+    this.worker = isBrowser2 ? this._createBrowserWorker() : this._createNodeWorker();
+  }
+  /**
+   * Terminate this worker thread
+   * @note Can free up significant memory
+   */
+  destroy() {
+    this.onMessage = NOOP;
+    this.onError = NOOP;
+    this.worker.terminate();
+    this.terminated = true;
+  }
+  /** Keeps this worker from preventing Node.js process exit while idle. */
+  unref() {
+    if (!isBrowser2 && typeof this.worker.unref === "function") {
+      this.worker.unref();
+    }
+  }
+  /** Keeps this worker alive while it is actively processing a job. */
+  ref() {
+    if (!isBrowser2 && typeof this.worker.ref === "function") {
+      this.worker.ref();
+    }
+  }
+  get isRunning() {
+    return Boolean(this.onMessage);
+  }
+  /**
+   * Send a message to this worker thread
+   * @param data any data structure, ideally consisting mostly of transferrable objects
+   * @param transferList If not supplied, calculated automatically by traversing data
+   */
+  postMessage(data, transferList) {
+    transferList = transferList || getTransferList(data);
+    this.worker.postMessage(data, transferList);
+  }
+  // PRIVATE
+  /**
+   * Generate a standard Error from an ErrorEvent
+   * @param event
+   */
+  _getErrorFromErrorEvent(event) {
+    let message = "Failed to load ";
+    message += `worker ${this.name} from ${this.url}. `;
+    if (event.message) {
+      message += `${event.message} in `;
+    }
+    if (event.lineno) {
+      message += `:${event.lineno}:${event.colno}`;
+    }
+    return new Error(message);
+  }
+  /**
+   * Creates a worker thread on the browser
+   */
+  _createBrowserWorker() {
+    this._loadableURL = getLoadableWorkerURL({ source: this.source, url: this.url });
+    const worker = new Worker(this._loadableURL, { name: this.name });
+    worker.onmessage = (event) => {
+      if (!event.data) {
+        this.onError(new Error("No data received"));
+      } else {
+        this.onMessage(event.data);
+      }
+    };
+    worker.onerror = (error) => {
+      this.onError(this._getErrorFromErrorEvent(error));
+      this.terminated = true;
+    };
+    worker.onmessageerror = (event) => console.error(event);
+    return worker;
+  }
+  /**
+   * Creates a worker thread in node.js
+   * @todo https://nodejs.org/api/async_hooks.html#async-resource-worker-pool
+   */
+  _createNodeWorker() {
+    let worker;
+    if (this.url) {
+      const absolute = this.url.includes(":/") || this.url.startsWith("/");
+      const url = absolute ? this.url : `./${this.url}`;
+      const workerUrl = url.startsWith("file:") ? new URL(url) : url;
+      const type = this.url.endsWith(".ts") || this.url.endsWith(".mjs") ? "module" : "commonjs";
+      worker = new NodeWorker(workerUrl, { eval: false, type });
+    } else if (this.source) {
+      worker = new NodeWorker(this.source, { eval: true });
+    } else {
+      throw new Error("no worker");
+    }
+    worker.on("message", (data) => {
+      this.onMessage(data);
+    });
+    worker.on("error", (error) => {
+      this.onError(error);
+    });
+    worker.on("exit", (_code) => {
+    });
+    return worker;
+  }
+};
+
+// ../worker-utils/src/lib/worker-farm/worker-pool.ts
+var WorkerPool = class {
+  name = "unnamed";
+  source;
+  // | Function;
+  url;
+  maxConcurrency = 1;
+  maxMobileConcurrency = 1;
+  onDebug = () => {
+  };
+  reuseWorkers = true;
+  props = {};
+  jobQueue = [];
+  idleQueue = [];
+  count = 0;
+  isDestroyed = false;
+  /** Checks if workers are supported on this platform */
+  static isSupported() {
+    return WorkerThread.isSupported();
+  }
+  /**
+   * @param processor - worker function
+   * @param maxConcurrency - max count of workers
+   */
+  constructor(props) {
+    this.source = props.source;
+    this.url = props.url;
+    this.setProps(props);
+  }
+  /**
+   * Terminates all workers in the pool
+   * @note Can free up significant memory
+   */
+  destroy() {
+    this.idleQueue.forEach((worker) => worker.destroy());
+    this.isDestroyed = true;
+  }
+  setProps(props) {
+    this.props = { ...this.props, ...props };
+    if (props.name !== void 0) {
+      this.name = props.name;
+    }
+    if (props.maxConcurrency !== void 0) {
+      this.maxConcurrency = props.maxConcurrency;
+    }
+    if (props.maxMobileConcurrency !== void 0) {
+      this.maxMobileConcurrency = props.maxMobileConcurrency;
+    }
+    if (props.reuseWorkers !== void 0) {
+      this.reuseWorkers = props.reuseWorkers;
+    }
+    if (props.onDebug !== void 0) {
+      this.onDebug = props.onDebug;
+    }
+  }
+  async startJob(name, onMessage2 = (job, type, data) => job.done(data), onError = (job, error) => job.error(error)) {
+    const startPromise = new Promise((onStart) => {
+      this.jobQueue.push({ name, onMessage: onMessage2, onError, onStart });
+      return this;
+    });
+    this._startQueuedJob();
+    return await startPromise;
+  }
+  // PRIVATE
+  /**
+   * Starts first queued job if worker is available or can be created
+   * Called when job is started and whenever a worker returns to the idleQueue
+   */
+  async _startQueuedJob() {
+    if (!this.jobQueue.length) {
+      return;
+    }
+    const workerThread = this._getAvailableWorker();
+    if (!workerThread) {
+      return;
+    }
+    const queuedJob = this.jobQueue.shift();
+    if (queuedJob) {
+      this.onDebug({
+        message: "Starting job",
+        name: queuedJob.name,
+        workerThread,
+        backlog: this.jobQueue.length
+      });
+      const job = new WorkerJob(queuedJob.name, workerThread);
+      workerThread.ref();
+      workerThread.onMessage = (data) => queuedJob.onMessage(job, data.type, data.payload);
+      workerThread.onError = (error) => queuedJob.onError(job, error);
+      queuedJob.onStart(job);
+      try {
+        await job.result;
+      } catch {
+      } finally {
+        this.returnWorkerToQueue(workerThread);
+      }
+    }
+  }
+  /**
+   * Returns a worker to the idle queue
+   * Destroys the worker if
+   *  - pool is destroyed
+   *  - if this pool doesn't reuse workers
+   *  - if maxConcurrency has been lowered
+   * @param worker
+   */
+  returnWorkerToQueue(worker) {
+    const shouldDestroyWorker = (
+      // Aborted jobs terminate their worker immediately.
+      worker.terminated || // If the pool is destroyed, there is no reason to keep the worker around
+      this.isDestroyed || // If the app has disabled worker reuse, any completed workers should be destroyed
+      !this.reuseWorkers || // If concurrency has been lowered, this worker might be surplus to requirements
+      this.count > this._getMaxConcurrency()
+    );
+    if (shouldDestroyWorker) {
+      if (!worker.terminated) {
+        worker.destroy();
+      }
+      this.count--;
+    } else {
+      worker.unref();
+      this.idleQueue.push(worker);
+    }
+    if (!this.isDestroyed) {
+      this._startQueuedJob();
+    }
+  }
+  /**
+   * Returns idle worker or creates new worker if maxConcurrency has not been reached
+   */
+  _getAvailableWorker() {
+    if (this.idleQueue.length > 0) {
+      return this.idleQueue.shift() || null;
+    }
+    if (this.count < this._getMaxConcurrency()) {
+      this.count++;
+      const name = `${this.name.toLowerCase()} (#${this.count} of ${this.maxConcurrency})`;
+      return new WorkerThread({ name, source: this.source, url: this.url });
+    }
+    return null;
+  }
+  _getMaxConcurrency() {
+    return isMobile ? this.maxMobileConcurrency : this.maxConcurrency;
+  }
+};
+
+// ../worker-utils/src/lib/worker-farm/worker-farm.ts
+var DEFAULT_PROPS = {
+  maxConcurrency: 3,
+  maxMobileConcurrency: 1,
+  reuseWorkers: true,
+  onDebug: () => {
+  }
+};
+var WorkerFarm = class _WorkerFarm {
+  props;
+  workerPools = /* @__PURE__ */ new Map();
+  // singleton
+  static _workerFarm;
+  /** Checks if workers are supported on this platform */
+  static isSupported() {
+    return WorkerThread.isSupported();
+  }
+  /** Get the singleton instance of the global worker farm */
+  static getWorkerFarm(props = {}) {
+    _WorkerFarm._workerFarm = _WorkerFarm._workerFarm || new _WorkerFarm({});
+    _WorkerFarm._workerFarm.setProps(props);
+    return _WorkerFarm._workerFarm;
+  }
+  /** get global instance with WorkerFarm.getWorkerFarm() */
+  constructor(props) {
+    this.props = { ...DEFAULT_PROPS };
+    this.setProps(props);
+    this.workerPools = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Terminate all workers in the farm
+   * @note Can free up significant memory
+   */
+  destroy() {
+    for (const workerPool of this.workerPools.values()) {
+      workerPool.destroy();
+    }
+    this.workerPools = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Set props used when initializing worker pools
+   * @param props
+   */
+  setProps(props) {
+    this.props = { ...this.props, ...props };
+    for (const workerPool of this.workerPools.values()) {
+      workerPool.setProps(this._getWorkerPoolProps());
+    }
+  }
+  /**
+   * Returns a worker pool for the specified worker
+   * @param options - only used first time for a specific worker name
+   * @param options.name - the name of the worker - used to identify worker pool
+   * @param options.url -
+   * @param options.source -
+   * @example
+   *   const job = WorkerFarm.getWorkerFarm().getWorkerPool({name, url}).startJob(...);
+   */
+  getWorkerPool(options) {
+    const { name, source, url } = options;
+    let workerPool = this.workerPools.get(name);
+    if (!workerPool) {
+      workerPool = new WorkerPool({
+        name,
+        source,
+        url
+      });
+      workerPool.setProps(this._getWorkerPoolProps());
+      this.workerPools.set(name, workerPool);
+    }
+    return workerPool;
+  }
+  _getWorkerPoolProps() {
+    return {
+      maxConcurrency: this.props.maxConcurrency,
+      maxMobileConcurrency: this.props.maxMobileConcurrency,
+      reuseWorkers: this.props.reuseWorkers,
+      onDebug: this.props.onDebug
+    };
+  }
+};
+
+// ../worker-utils/src/lib/worker-api/get-worker-url.ts
+var warnedWorkerVersionFallbacks = /* @__PURE__ */ new Set();
+function getWorkerName(worker) {
+  const warning = worker.version !== VERSION2 ? ` (worker-utils@${VERSION2})` : "";
+  return `${worker.name}@${worker.version}${warning}`;
+}
+function getWorkerURL(worker, options = {}) {
+  var _a;
+  const workerOptions = options[worker.id] || {};
+  const workerFile = isBrowser2 ? `${worker.id}-worker.js` : `${worker.id}-worker-node.js`;
+  let url = workerOptions.workerUrl;
+  if (!url && typeof worker.worker === "string") {
+    url = worker.worker;
+  }
+  if (!url && worker.id === "compression") {
+    url = options.workerUrl;
+  }
+  const workerType = options._workerType || ((_a = options == null ? void 0 : options.core) == null ? void 0 : _a._workerType);
+  if (workerType === "test") {
+    if (isBrowser2) {
+      url = `modules/${worker.module}/dist/${workerFile}`;
+    } else {
+      url = `modules/${worker.module}/src/workers/${worker.id}-worker-node.ts`;
+    }
+  }
+  if (!url) {
+    let version2 = worker.version;
+    if (version2 === "latest") {
+      version2 = NPM_TAG;
+    }
+    const versionTag = version2 ? `@${version2}` : "";
+    url = `https://unpkg.com/@loaders.gl/${worker.module}${versionTag}/dist/${workerFile}`;
+    warnIfUsingNpmTagFallback(worker, url);
+  }
+  assert2(url);
+  return url;
+}
+function warnIfUsingNpmTagFallback(worker, url) {
+  if (worker.version !== "latest") {
+    return;
+  }
+  const workerId = `${worker.module}:${worker.id}`;
+  if (warnedWorkerVersionFallbacks.has(workerId)) {
+    return;
+  }
+  warnedWorkerVersionFallbacks.add(workerId);
+  console.warn(
+    `loaders.gl: ${worker.name} loader worker version is "latest" because __VERSION__ was not injected. Fetching ${url} from CDN.`
+  );
+}
+
+// ../worker-utils/src/lib/worker-api/process-on-worker.ts
+function canProcessOnWorker(worker, options) {
+  if (!WorkerFarm.isSupported()) {
+    return false;
+  }
+  const workerOptions = options == null ? void 0 : options[worker.id];
+  return Boolean((worker.worker || (workerOptions == null ? void 0 : workerOptions.workerUrl)) && (options == null ? void 0 : options.worker));
+}
+async function processOnWorker(worker, data, options = {}, context = {}, jobContext = {}) {
+  var _a, _b, _c;
+  throwIfAborted(options.signal);
+  const name = getWorkerName(worker);
+  const workerFarm = WorkerFarm.getWorkerFarm(options);
+  const { source } = options;
+  const workerPoolProps = { name, source };
+  if (!source) {
+    workerPoolProps.url = getWorkerURL(worker, options);
+  }
+  const workerPool = workerFarm.getWorkerPool(workerPoolProps);
+  const jobName = options.jobName || worker.name;
+  const job = await workerPool.startJob(
+    jobName,
+    // eslint-disable-next-line
+    onMessage.bind(null, context)
+  );
+  const abortJob = () => job.abort();
+  (_a = options.signal) == null ? void 0 : _a.addEventListener("abort", abortJob, { once: true });
+  if ((_b = options.signal) == null ? void 0 : _b.aborted) {
+    abortJob();
+  }
+  try {
+    const { signal: _signal, ...workerOptions } = options;
+    const transferableOptions = getTransferListForWriter(workerOptions);
+    const transferableContext = getTransferListForWriter(jobContext);
+    if (job.isRunning) {
+      job.postMessage("process", {
+        input: data,
+        options: transferableOptions,
+        context: transferableContext
+      });
+    }
+    const result = await job.result;
+    return result.result;
+  } finally {
+    (_c = options.signal) == null ? void 0 : _c.removeEventListener("abort", abortJob);
+  }
+}
+function throwIfAborted(signal) {
+  if (!(signal == null ? void 0 : signal.aborted)) {
+    return;
+  }
+  const error = new Error("Worker job was aborted");
+  error.name = "AbortError";
+  throw error;
+}
+async function onMessage(context, job, type, payload) {
+  switch (type) {
+    case "done":
+      job.done(payload);
+      break;
+    case "error":
+      job.error(new Error(payload.error));
+      break;
+    case "process":
+      const { id, input, options } = payload;
+      try {
+        if (!context.process) {
+          job.postMessage("error", { id, error: "Worker not set up to process on main thread" });
+          return;
+        }
+        const result = await context.process(input, options, void 0, payload.context || {});
+        job.postMessage("done", { id, result });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "unknown error";
+        job.postMessage("error", { id, error: message });
+      }
+      break;
+    default:
+      console.warn(`process-on-worker: unknown message ${type}`);
+  }
+}
+
+// ../worker-utils/src/lib/worker-api/validate-worker-version.ts
+function validateWorkerVersion(worker, coreVersion = VERSION2) {
+  assert2(worker, "no worker provided");
+  const workerVersion = worker.version;
+  if (!coreVersion || !workerVersion) {
+    return false;
+  }
+  return true;
+}
+
+// ../loader-utils/src/lib/worker-loader-utils/parse-with-worker.ts
+function canParseWithWorker(loader, options) {
+  var _a, _b;
+  const workerOptions = getWorkerOptions(options);
+  const nodeWorkers = workerOptions._nodeWorkers;
+  if (!isBrowser2 && !nodeWorkers) {
+    return false;
+  }
+  if (loader.id === "excel" && ((_a = options == null ? void 0 : options.excel) == null ? void 0 : _a.shape) === "arrow-table" || loader.id === "ply" && ((_b = options == null ? void 0 : options.ply) == null ? void 0 : _b.shape) === "arrow-table") {
+    return false;
+  }
+  if (loader.id === "csv" && !shouldParseCSVWithWorker(options)) {
+    return false;
+  }
+  return Boolean(canProcessOnWorker(loader, workerOptions));
+}
+async function parseWithWorker(loader, data, options, context, parseOnMainThread) {
+  const signal = getWorkerAbortSignal(options);
+  const result = await processOnWorker(
+    loader,
+    data,
+    { ...getWorkerOptions(options), signal },
+    {
+      process: async (input, processOptions, _workerContext, parseContext) => {
+        if (!parseOnMainThread) {
+          throw new Error("Worker not set up to parse on main thread");
+        }
+        const mainThreadContext = context ? { ...context, ...parseContext || {} } : void 0;
+        return await callParseOnMainThread(
+          parseOnMainThread,
+          input,
+          processOptions,
+          mainThreadContext
+        );
+      }
+    },
+    getSerializableLoaderContext(context)
+  );
+  return isLoaderWithWorkerResultDeserializer(loader) ? loader.deserializeWorkerResult(result, options, context) : result;
+}
+function getWorkerAbortSignal(options) {
+  var _a;
+  const parquetSignal = (_a = options == null ? void 0 : options.parquet) == null ? void 0 : _a.signal;
+  if (typeof AbortSignal !== "undefined" && parquetSignal instanceof AbortSignal) {
+    return parquetSignal;
+  }
+  return void 0;
+}
+function callParseOnMainThread(parseOnMainThread, input, options, context) {
+  if (parseOnMainThread.length <= 2) {
+    return parseOnMainThread(input, options);
+  }
+  return parseOnMainThread(input, void 0, options, context);
+}
+function getWorkerOptions(options = {}) {
+  const serializedOptions = JSON.parse(JSON.stringify(options));
+  return {
+    ...serializedOptions.core,
+    ...serializedOptions
+  };
+}
+function getSerializableLoaderContext(context) {
+  if (!context) {
+    return {};
+  }
+  const { fetch: fetch2, loaders, coreApi: coreApi2, _parse, _parseSync, _parseInBatches, ...serializableContext } = context;
+  return JSON.parse(JSON.stringify(serializableContext));
+}
+function shouldParseCSVWithWorker(options) {
+  var _a, _b;
+  const csvOptions = options;
+  return (((_a = csvOptions == null ? void 0 : csvOptions.csv) == null ? void 0 : _a.shape) ?? ((_b = csvOptions == null ? void 0 : csvOptions.core) == null ? void 0 : _b.shape)) === "arrow-table";
+}
+function isLoaderWithWorkerResultDeserializer(loader) {
+  return typeof loader.deserializeWorkerResult === "function";
+}
+
+// ../loader-utils/src/lib/worker-loader-utils/encode-with-worker.ts
+function canEncodeWithWorker(writer, options) {
+  var _a, _b;
+  if (!WorkerFarm.isSupported()) {
+    return false;
+  }
+  const nodeWorkers = (options == null ? void 0 : options._nodeWorkers) ?? ((_a = options == null ? void 0 : options.core) == null ? void 0 : _a._nodeWorkers);
+  const useWorkers = (options == null ? void 0 : options.worker) ?? ((_b = options == null ? void 0 : options.core) == null ? void 0 : _b.worker);
+  if (!isBrowser && !nodeWorkers) {
+    return false;
+  }
+  return Boolean(writer.worker && useWorkers);
+}
+
+// ../loader-utils/src/lib/binary-utils/array-buffer-utils.ts
+function compareArrayBuffers(arrayBuffer1, arrayBuffer2, byteLength) {
+  byteLength = byteLength || arrayBuffer1.byteLength;
+  if (arrayBuffer1.byteLength < byteLength || arrayBuffer2.byteLength < byteLength) {
+    return false;
+  }
+  const array1 = new Uint8Array(arrayBuffer1);
+  const array2 = new Uint8Array(arrayBuffer2);
+  for (let i = 0; i < array1.length; ++i) {
+    if (array1[i] !== array2[i]) {
+      return false;
+    }
+  }
+  return true;
+}
+function concatenateArrayBuffers(...sources) {
+  return concatenateArrayBuffersFromArray(sources);
+}
+function concatenateArrayBuffersFromArray(sources) {
+  const sourceArrays = sources.map(
+    (source2) => source2 instanceof ArrayBuffer ? new Uint8Array(source2) : source2
+  );
+  const byteLength = sourceArrays.reduce((length, typedArray) => length + typedArray.byteLength, 0);
+  const result = new Uint8Array(byteLength);
+  let offset = 0;
+  for (const sourceArray of sourceArrays) {
+    result.set(sourceArray, offset);
+    offset += sourceArray.byteLength;
+  }
+  return result.buffer;
+}
+
+// ../loader-utils/src/lib/iterators/text-iterators.ts
+async function* makeTextDecoderIterator(arrayBufferIterator, options = {}) {
+  const textDecoder = new TextDecoder(void 0, options);
+  for await (const arrayBuffer of arrayBufferIterator) {
+    yield typeof arrayBuffer === "string" ? arrayBuffer : textDecoder.decode(arrayBuffer, { stream: true });
+  }
+}
+async function* makeTextEncoderIterator(textIterator) {
+  const textEncoder = new TextEncoder();
+  for await (const text of textIterator) {
+    yield typeof text === "string" ? textEncoder.encode(text).buffer : text;
+  }
+}
+async function* makeLineIterator(textIterator) {
+  let previous = "";
+  for await (const textChunk of textIterator) {
+    previous += textChunk;
+    let eolIndex;
+    eolIndex = previous.indexOf("\n");
+    while (eolIndex >= 0) {
+      const line = previous.slice(0, eolIndex + 1);
+      previous = previous.slice(eolIndex + 1);
+      yield line;
+      eolIndex = previous.indexOf("\n");
+    }
+  }
+  if (previous.length > 0) {
+    yield previous;
+  }
+}
+async function* makeNumberedLineIterator(lineIterator) {
+  let counter = 1;
+  for await (const line of lineIterator) {
+    yield { counter, line };
+    counter++;
+  }
+}
+
+// ../loader-utils/src/lib/iterators/async-iteration.ts
+async function forEach(iterable, visitor) {
+  const iterator = toAsyncIterator(iterable);
+  while (true) {
+    const { done, value } = await iterator.next();
+    if (done) {
+      if (iterator.return) {
+        iterator.return();
+      }
+      return;
+    }
+    const cancel = visitor(value);
+    if (cancel) {
+      return;
+    }
+  }
+}
+async function concatenateArrayBuffersAsync(asyncIterator) {
+  const arrayBuffers = [];
+  for await (const chunk of asyncIterator) {
+    arrayBuffers.push(copyToArrayBuffer(chunk));
+  }
+  return concatenateArrayBuffers(...arrayBuffers);
+}
+function copyToArrayBuffer(chunk) {
+  if (chunk instanceof ArrayBuffer) {
+    return chunk;
+  }
+  if (ArrayBuffer.isView(chunk)) {
+    const { buffer, byteOffset, byteLength } = chunk;
+    return copyFromBuffer(buffer, byteOffset, byteLength);
+  }
+  return copyFromBuffer(chunk);
+}
+function copyFromBuffer(buffer, byteOffset = 0, byteLength = buffer.byteLength - byteOffset) {
+  const view = new Uint8Array(buffer, byteOffset, byteLength);
+  const copy = new Uint8Array(view.length);
+  copy.set(view);
+  return copy.buffer;
+}
+function toAsyncIterator(iterable) {
+  if (typeof iterable[Symbol.asyncIterator] === "function") {
+    return iterable[Symbol.asyncIterator]();
+  }
+  if (typeof iterable[Symbol.iterator] === "function") {
+    const iterator = iterable[Symbol.iterator]();
+    return iteratorToAsyncIterator(iterator);
+  }
+  return iterable;
+}
+function iteratorToAsyncIterator(iterator) {
+  return {
+    next(value) {
+      return Promise.resolve(iterator.next(value));
+    },
+    return(value) {
+      if (typeof iterator.return === "function") {
+        return Promise.resolve(iterator.return(value));
+      }
+      return Promise.resolve({ done: true, value });
+    },
+    throw(error) {
+      if (typeof iterator.throw === "function") {
+        return Promise.resolve(iterator.throw(error));
+      }
+      return Promise.reject(error);
+    }
+  };
+}
+
+// ../loader-utils/src/lib/request-utils/request-scheduler.ts
+var import_stats = require("@probe.gl/stats");
+var STAT_QUEUED_REQUESTS = "Queued Requests";
+var STAT_ACTIVE_REQUESTS = "Active Requests";
+var STAT_CANCELLED_REQUESTS = "Cancelled Requests";
+var STAT_QUEUED_REQUESTS_EVER = "Queued Requests Ever";
+var STAT_ACTIVE_REQUESTS_EVER = "Active Requests Ever";
+var DEFAULT_PROPS2 = {
+  id: "request-scheduler",
+  /** Specifies if the request scheduler should throttle incoming requests, mainly for comparative testing. */
+  throttleRequests: true,
+  /** The maximum number of simultaneous active requests. Un-throttled requests do not observe this limit. */
+  maxRequests: 6,
+  /**
+   * Specifies a debounce time, in milliseconds. All requests are queued, until no new requests have
+   * been added to the queue for this amount of time.
+   */
+  debounceTime: 0
+};
+var RequestScheduler = class {
+  props;
+  stats;
+  activeRequestCount = 0;
+  /** Tracks the number of active requests and prioritizes/cancels queued requests. */
+  requestQueue = [];
+  requestMap = /* @__PURE__ */ new Map();
+  updateTimer = null;
+  constructor(props = {}) {
+    this.props = { ...DEFAULT_PROPS2, ...props };
+    this.stats = new import_stats.Stats({ id: this.props.id });
+    this.stats.get(STAT_QUEUED_REQUESTS);
+    this.stats.get(STAT_ACTIVE_REQUESTS);
+    this.stats.get(STAT_CANCELLED_REQUESTS);
+    this.stats.get(STAT_QUEUED_REQUESTS_EVER);
+    this.stats.get(STAT_ACTIVE_REQUESTS_EVER);
+  }
+  /**
+   * Update scheduler props. Preserves active and queued requests.
+   */
+  setProps(props) {
+    if (props.throttleRequests !== void 0) {
+      this.props.throttleRequests = props.throttleRequests;
+    }
+    if (props.maxRequests !== void 0) {
+      this.props.maxRequests = props.maxRequests;
+    }
+    if (props.debounceTime !== void 0) {
+      this.props.debounceTime = props.debounceTime;
+    }
+  }
+  /**
+   * Called by an application that wants to issue a request, without having it deeply queued by the browser
+   *
+   * When the returned promise resolved, it is OK for the application to issue a request.
+   * The promise resolves to an object that contains a `done` method.
+   * When the application's request has completed (or failed), the application must call the `done` function
+   *
+   * @param handle
+   * @param getPriority will be called when request "slots" open up,
+   *    allowing the caller to update priority or cancel the request
+   *    Highest priority executes first, priority < 0 cancels the request
+   * @returns a promise
+   *   - resolves to a object (with a `done` field) when the request can be issued without queueing,
+   *   - resolves to `null` if the request has been cancelled (by the callback return < 0).
+   *     In this case the application should not issue the request
+   */
+  scheduleRequest(handle, getPriority = () => 0) {
+    if (!this.props.throttleRequests) {
+      return Promise.resolve({ done: () => {
+      } });
+    }
+    if (this.requestMap.has(handle)) {
+      return this.requestMap.get(handle);
+    }
+    const request = { handle, priority: 0, getPriority };
+    const promise = new Promise((resolve2) => {
+      request.resolve = resolve2;
+      return request;
+    });
+    this.requestQueue.push(request);
+    this.requestMap.set(handle, promise);
+    this._issueNewRequests();
+    return promise;
+  }
+  // PRIVATE
+  _issueRequest(request) {
+    const { handle, resolve: resolve2 } = request;
+    let isDone = false;
+    const done = () => {
+      if (!isDone) {
+        isDone = true;
+        this.requestMap.delete(handle);
+        this.activeRequestCount--;
+        this._issueNewRequests();
+      }
+    };
+    this.activeRequestCount++;
+    return resolve2 ? resolve2({ done }) : Promise.resolve({ done });
+  }
+  /** We check requests asynchronously, to prevent multiple updates */
+  _issueNewRequests() {
+    if (this.updateTimer !== null) {
+      clearTimeout(this.updateTimer);
+    }
+    this.updateTimer = setTimeout(() => this._issueNewRequestsAsync(), this.props.debounceTime);
+  }
+  /** Refresh all requests  */
+  _issueNewRequestsAsync() {
+    if (this.updateTimer !== null) {
+      clearTimeout(this.updateTimer);
+    }
+    this.updateTimer = null;
+    const freeSlots = Math.max(this.props.maxRequests - this.activeRequestCount, 0);
+    if (freeSlots === 0) {
+      return;
+    }
+    this._updateAllRequests();
+    for (let i = 0; i < freeSlots; ++i) {
+      const request = this.requestQueue.shift();
+      if (request) {
+        this._issueRequest(request);
+      }
+    }
+  }
+  /** Ensure all requests have updated priorities, and that no longer valid requests are cancelled */
+  _updateAllRequests() {
+    const requestQueue = this.requestQueue;
+    for (let i = 0; i < requestQueue.length; ++i) {
+      const request = requestQueue[i];
+      if (!this._updateRequest(request)) {
+        requestQueue.splice(i, 1);
+        this.requestMap.delete(request.handle);
+        i--;
+      }
+    }
+    requestQueue.sort((a, b) => a.priority - b.priority);
+  }
+  /** Update a single request by calling the callback */
+  _updateRequest(request) {
+    request.priority = request.getPriority(request.handle);
+    if (request.priority < 0) {
+      request.resolve(null);
+      return false;
+    }
+    return true;
+  }
+};
+
+// ../loader-utils/src/lib/path-utils/file-aliases.ts
+var pathPrefix = "";
+var fileAliases = {};
+function setPathPrefix(prefix) {
+  pathPrefix = prefix;
+}
+function getPathPrefix() {
+  return pathPrefix;
+}
+function resolvePath(filename2) {
+  for (const alias in fileAliases) {
+    if (filename2.startsWith(alias)) {
+      const replacement = fileAliases[alias];
+      filename2 = filename2.replace(alias, replacement);
+    }
+  }
+  if (!filename2.startsWith("http://") && !filename2.startsWith("https://")) {
+    filename2 = `${pathPrefix}${filename2}`;
+  }
+  return filename2;
+}
+
+// ../loader-utils/src/lib/path-utils/path.ts
+var path_exports = {};
+__export(path_exports, {
+  dirname: () => dirname,
+  filename: () => filename,
+  join: () => join,
+  resolve: () => resolve
+});
+
+// ../loader-utils/src/lib/path-utils/get-cwd.ts
+function getCWD() {
+  var _a;
+  if (typeof process !== "undefined" && typeof process.cwd !== "undefined") {
+    return process.cwd();
+  }
+  const pathname = (_a = window.location) == null ? void 0 : _a.pathname;
+  return (pathname == null ? void 0 : pathname.slice(0, pathname.lastIndexOf("/") + 1)) || "";
+}
+
+// ../loader-utils/src/lib/path-utils/path.ts
+function filename(url) {
+  const slashIndex = url ? url.lastIndexOf("/") : -1;
+  return slashIndex >= 0 ? url.substr(slashIndex + 1) : url;
+}
+function dirname(url) {
+  const slashIndex = url ? url.lastIndexOf("/") : -1;
+  return slashIndex >= 0 ? url.substr(0, slashIndex) : "";
+}
+function join(...parts) {
+  const separator = "/";
+  parts = parts.map((part, index) => {
+    if (index) {
+      part = part.replace(new RegExp(`^${separator}`), "");
+    }
+    if (index !== parts.length - 1) {
+      part = part.replace(new RegExp(`${separator}$`), "");
+    }
+    return part;
+  });
+  return parts.join(separator);
+}
+function resolve(...components) {
+  const paths = [];
+  for (let _i = 0; _i < components.length; _i++) {
+    paths[_i] = components[_i];
+  }
+  let resolvedPath = "";
+  let resolvedAbsolute = false;
+  let cwd;
+  for (let i = paths.length - 1; i >= -1 && !resolvedAbsolute; i--) {
+    let path;
+    if (i >= 0) {
+      path = paths[i];
+    } else {
+      if (cwd === void 0) {
+        cwd = getCWD();
+      }
+      path = cwd;
+    }
+    if (path.length === 0) {
+      continue;
+    }
+    resolvedPath = `${path}/${resolvedPath}`;
+    resolvedAbsolute = path.charCodeAt(0) === SLASH;
+  }
+  resolvedPath = normalizeStringPosix(resolvedPath, !resolvedAbsolute);
+  if (resolvedAbsolute) {
+    return `/${resolvedPath}`;
+  } else if (resolvedPath.length > 0) {
+    return resolvedPath;
+  }
+  return ".";
+}
+var SLASH = 47;
+var DOT = 46;
+function normalizeStringPosix(path, allowAboveRoot) {
+  let res = "";
+  let lastSlash = -1;
+  let dots = 0;
+  let code;
+  let isAboveRoot = false;
+  for (let i = 0; i <= path.length; ++i) {
+    if (i < path.length) {
+      code = path.charCodeAt(i);
+    } else if (code === SLASH) {
+      break;
+    } else {
+      code = SLASH;
+    }
+    if (code === SLASH) {
+      if (lastSlash === i - 1 || dots === 1) {
+      } else if (lastSlash !== i - 1 && dots === 2) {
+        if (res.length < 2 || !isAboveRoot || res.charCodeAt(res.length - 1) !== DOT || res.charCodeAt(res.length - 2) !== DOT) {
+          if (res.length > 2) {
+            const start = res.length - 1;
+            let j = start;
+            for (; j >= 0; --j) {
+              if (res.charCodeAt(j) === SLASH) {
+                break;
+              }
+            }
+            if (j !== start) {
+              res = j === -1 ? "" : res.slice(0, j);
+              lastSlash = i;
+              dots = 0;
+              isAboveRoot = false;
+              continue;
+            }
+          } else if (res.length === 2 || res.length === 1) {
+            res = "";
+            lastSlash = i;
+            dots = 0;
+            isAboveRoot = false;
+            continue;
+          }
+        }
+        if (allowAboveRoot) {
+          if (res.length > 0) {
+            res += "/..";
+          } else {
+            res = "..";
+          }
+          isAboveRoot = true;
+        }
+      } else {
+        const slice = path.slice(lastSlash + 1, i);
+        if (res.length > 0) {
+          res += `/${slice}`;
+        } else {
+          res = slice;
+        }
+        isAboveRoot = false;
+      }
+      lastSlash = i;
+      dots = 0;
+    } else if (code === DOT && dots !== -1) {
+      ++dots;
+    } else {
+      dots = -1;
+    }
+  }
+  return res;
+}
+
+// ../loader-utils/src/json-loader.ts
+var VERSION3 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+var JSONLoader = {
+  dataType: null,
+  batchType: null,
+  name: "JSON",
+  id: "json",
+  module: "json",
+  version: VERSION3,
+  encoding: "json",
+  format: "json",
+  extensions: ["json", "geojson"],
+  mimeTypes: ["application/json"],
+  category: "json",
+  text: true,
+  parseTextSync,
+  parse: async (arrayBuffer) => parseTextSync(new TextDecoder().decode(arrayBuffer)),
+  options: {}
+};
+function parseTextSync(text) {
+  return JSON.parse(text);
+}
+
+// ../loader-utils/src/lib/node/buffer.browser.ts
+function toArrayBuffer(buffer) {
+  return buffer;
+}
+
+// ../loader-utils/src/lib/binary-utils/memory-conversion-utils.ts
+function isBuffer(value) {
+  return value && typeof value === "object" && value.isBuffer;
+}
+function toArrayBuffer2(data) {
+  if (isBuffer(data)) {
+    return toArrayBuffer(data);
+  }
+  if (data instanceof ArrayBuffer) {
+    return data;
+  }
+  if (isSharedArrayBuffer(data)) {
+    return copyToArrayBuffer2(data);
+  }
+  if (ArrayBuffer.isView(data)) {
+    const buffer = data.buffer;
+    if (data.byteOffset === 0 && data.byteLength === data.buffer.byteLength) {
+      return buffer;
+    }
+    return buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
+  }
+  if (typeof data === "string") {
+    const text = data;
+    const uint8Array = new TextEncoder().encode(text);
+    return uint8Array.buffer;
+  }
+  if (data && typeof data === "object" && data._toArrayBuffer) {
+    return data._toArrayBuffer();
+  }
+  throw new Error("toArrayBuffer");
+}
+function ensureArrayBuffer(bufferSource) {
+  if (bufferSource instanceof ArrayBuffer) {
+    return bufferSource;
+  }
+  if (isSharedArrayBuffer(bufferSource)) {
+    return copyToArrayBuffer2(bufferSource);
+  }
+  const { buffer, byteOffset, byteLength } = bufferSource;
+  if (buffer instanceof ArrayBuffer && byteOffset === 0 && byteLength === buffer.byteLength) {
+    return buffer;
+  }
+  return copyToArrayBuffer2(buffer, byteOffset, byteLength);
+}
+function copyToArrayBuffer2(buffer, byteOffset = 0, byteLength = buffer.byteLength - byteOffset) {
+  const view = new Uint8Array(buffer, byteOffset, byteLength);
+  const copy = new Uint8Array(view.length);
+  copy.set(view);
+  return copy.buffer;
+}
+function toArrayBufferView(data) {
+  if (ArrayBuffer.isView(data)) {
+    return data;
+  }
+  return new Uint8Array(data);
+}
+
+// ../loader-utils/src/lib/files/blob-file.ts
+var BlobFile = class {
+  handle;
+  size;
+  bigsize;
+  url;
+  constructor(blob) {
+    this.handle = blob instanceof ArrayBuffer ? new Blob([blob]) : blob;
+    this.size = blob instanceof ArrayBuffer ? blob.byteLength : blob.size;
+    this.bigsize = BigInt(this.size);
+    this.url = blob instanceof File ? blob.name : "";
+  }
+  async close() {
+  }
+  async stat() {
+    return {
+      size: this.handle.size,
+      bigsize: BigInt(this.handle.size),
+      isDirectory: false
+    };
+  }
+  async read(start, length, signal) {
+    if (signal == null ? void 0 : signal.aborted) {
+      throw new Error("Request aborted");
+    }
+    const arrayBuffer = await this.handle.slice(Number(start), Number(start) + Number(length)).arrayBuffer();
+    if (signal == null ? void 0 : signal.aborted) {
+      throw new Error("Request aborted");
+    }
+    return arrayBuffer;
+  }
+};
+
+// ../loader-utils/src/lib/files/node-file-facade.ts
+var NOT_IMPLEMENTED = new Error("Not implemented");
+var NodeFileFacade = class {
+  handle;
+  size = 0;
+  bigsize = 0n;
+  url = "";
+  constructor(url, flags, mode) {
+    var _a;
+    if ((_a = globalThis.loaders) == null ? void 0 : _a.NodeFile) {
+      return new globalThis.loaders.NodeFile(url, flags, mode);
+    }
+    if (isBrowser) {
+      throw new Error("Can't instantiate NodeFile in browser.");
+    }
+    throw new Error("Can't instantiate NodeFile. Make sure to import @loaders.gl/polyfills first.");
+  }
+  /** Read data */
+  async read(start, length) {
+    throw NOT_IMPLEMENTED;
+  }
+  /** Write to file. The number of bytes written will be returned */
+  async write(arrayBuffer, offset, length) {
+    throw NOT_IMPLEMENTED;
+  }
+  /** Get information about file */
+  async stat() {
+    throw NOT_IMPLEMENTED;
+  }
+  /** Truncates the file descriptor. Only available on NodeFile. */
+  async truncate(length) {
+    throw NOT_IMPLEMENTED;
+  }
+  /** Append data to a file. Only available on NodeFile. */
+  async append(data) {
+    throw NOT_IMPLEMENTED;
+  }
+  /** Close the file */
+  async close() {
+  }
+};
+
+// ../loader-utils/src/source-types.ts
+function isSourceLoader(loader) {
+  return Boolean(loader && typeof loader === "object" && "createDataSource" in loader);
+}
 
 // dist/lib/fetch/fetch-error.js
 var FetchError = class extends Error {
@@ -102,9 +1608,6 @@ var FetchError = class extends Error {
   response;
 };
 
-// dist/lib/utils/resource-utils.js
-var import_loader_utils = require("@loaders.gl/loader-utils");
-
 // dist/lib/utils/mime-type-utils.js
 var DATA_URL_PATTERN = /^data:([-\w.]+\/[-\w.+]+)(;|,)/;
 var MIME_TYPE_PATTERN = /^([-\w.]+\/[-\w.+]+)/;
@@ -115,16 +1618,16 @@ function compareMIMETypes(mimeType1, mimeType2) {
   return false;
 }
 function parseMIMEType(mimeString) {
-  const matches = MIME_TYPE_PATTERN.exec(mimeString);
-  if (matches) {
-    return matches[1];
+  const matches3 = MIME_TYPE_PATTERN.exec(mimeString);
+  if (matches3) {
+    return matches3[1];
   }
   return mimeString;
 }
 function parseMIMETypeFromURL(url) {
-  const matches = DATA_URL_PATTERN.exec(url);
-  if (matches) {
-    return matches[1];
+  const matches3 = DATA_URL_PATTERN.exec(url);
+  if (matches3) {
+    return matches3[1];
   }
   return "";
 }
@@ -132,8 +1635,8 @@ function parseMIMETypeFromURL(url) {
 // dist/lib/utils/url-utils.js
 var QUERY_STRING_PATTERN = /\?.*/;
 function extractQueryString(url) {
-  const matches = url.match(QUERY_STRING_PATTERN);
-  return matches && matches[0];
+  const matches3 = url.match(QUERY_STRING_PATTERN);
+  return matches3 && matches3[0];
 }
 function stripQueryString(url) {
   return url.replace(QUERY_STRING_PATTERN, "");
@@ -149,10 +1652,10 @@ function shortenUrlForDisplay(url) {
 
 // dist/lib/utils/resource-utils.js
 function getResourceUrl(resource) {
-  if ((0, import_loader_utils.isResponse)(resource)) {
+  if (isResponse(resource)) {
     return resource.url;
   }
-  if ((0, import_loader_utils.isBlob)(resource)) {
+  if (isBlob(resource)) {
     const fileName = "name" in resource ? resource.name : "";
     return fileName || "";
   }
@@ -162,12 +1665,12 @@ function getResourceUrl(resource) {
   return "";
 }
 function getResourceMIMEType(resource) {
-  if ((0, import_loader_utils.isResponse)(resource)) {
+  if (isResponse(resource)) {
     const contentTypeHeader = resource.headers.get("content-type") || "";
     const noQueryUrl = stripQueryString(resource.url);
     return parseMIMEType(contentTypeHeader) || parseMIMETypeFromURL(noQueryUrl);
   }
-  if ((0, import_loader_utils.isBlob)(resource)) {
+  if (isBlob(resource)) {
     return resource.type || "";
   }
   if (typeof resource === "string") {
@@ -176,11 +1679,11 @@ function getResourceMIMEType(resource) {
   return "";
 }
 function getResourceContentLength(resource) {
-  if ((0, import_loader_utils.isResponse)(resource)) {
+  if (isResponse(resource)) {
     const response = resource;
     return response.headers["content-length"] || -1;
   }
-  if ((0, import_loader_utils.isBlob)(resource)) {
+  if (isBlob(resource)) {
     const blob = resource;
     return blob.size;
   }
@@ -198,7 +1701,7 @@ function getResourceContentLength(resource) {
 
 // dist/lib/utils/response-utils.js
 async function makeResponse(resource) {
-  if ((0, import_loader_utils2.isResponse)(resource)) {
+  if (isResponse(resource)) {
     return resource;
   }
   const headers = {};
@@ -240,7 +1743,7 @@ async function getResponseError(response) {
   try {
     const contentType = response.headers.get("Content-Type");
     info.reason = !response.bodyUsed && (contentType == null ? void 0 : contentType.includes("application/json")) ? await response.json() : await response.text();
-  } catch (error) {
+  } catch (_error) {
   }
   return new FetchError(message, info);
 }
@@ -251,11 +1754,11 @@ async function getInitialDataUrl(resource) {
   }
   if (resource instanceof Blob) {
     const blobSlice = resource.slice(0, 5);
-    return await new Promise((resolve) => {
+    return await new Promise((resolve2) => {
       const reader = new FileReader();
       reader.onload = (event) => {
         var _a;
-        return resolve((_a = event == null ? void 0 : event.target) == null ? void 0 : _a.result);
+        return resolve2((_a = event == null ? void 0 : event.target) == null ? void 0 : _a.result);
       };
       reader.readAsDataURL(blobSlice);
     });
@@ -289,7 +1792,7 @@ function isDataURL(url) {
 async function fetchFile(urlOrData, fetchOptions) {
   var _a, _b;
   if (typeof urlOrData === "string") {
-    const url = (0, import_loader_utils3.resolvePath)(urlOrData);
+    const url = resolvePath(urlOrData);
     if (isNodePath(url)) {
       if ((_a = globalThis.loaders) == null ? void 0 : _a.fetchNode) {
         return (_b = globalThis.loaders) == null ? void 0 : _b.fetchNode(url, fetchOptions);
@@ -309,62 +1812,85 @@ async function readArrayBuffer(file, start, length) {
   return await readBlob(slice);
 }
 async function readBlob(blob) {
-  return await new Promise((resolve, reject) => {
+  return await new Promise((resolve2, reject) => {
     const fileReader = new FileReader();
     fileReader.onload = (event) => {
       var _a;
-      return resolve((_a = event == null ? void 0 : event.target) == null ? void 0 : _a.result);
+      return resolve2((_a = event == null ? void 0 : event.target) == null ? void 0 : _a.result);
     };
     fileReader.onerror = (error) => reject(error);
     fileReader.readAsArrayBuffer(blob);
   });
 }
 
-// dist/lib/loader-utils/option-utils.js
-var import_loader_utils5 = require("@loaders.gl/loader-utils");
-
 // dist/lib/loader-utils/loggers.js
-var import_log = require("@probe.gl/log");
-var probeLog = new import_log.Log({ id: "loaders.gl" });
+var import_log3 = require("@probe.gl/log");
+var probeLog = new import_log3.Log({ id: "loaders.gl" });
 var NullLog = class {
+  /** Drops a log message. */
   log() {
     return () => {
     };
   }
+  /** Drops an info message. */
   info() {
     return () => {
     };
   }
+  /** Logs one message once; no-op for the null logger. */
+  once() {
+    return () => {
+    };
+  }
+  /** Drops a warning message. */
   warn() {
     return () => {
     };
   }
+  /** Drops an error message. */
   error() {
     return () => {
     };
   }
 };
 var ConsoleLog = class {
+  /** Console-like object used for message output. */
   console;
+  /** Messages already emitted through `once`. */
+  onceMessages = /* @__PURE__ */ new Set();
+  /** Creates a console-backed logger. */
   constructor() {
     this.console = console;
   }
+  /** Logs a message to the console. */
   log(...args) {
     return this.console.log.bind(this.console, ...args);
   }
+  /** Logs an informational message to the console. */
   info(...args) {
     return this.console.info.bind(this.console, ...args);
   }
+  /** Logs one message once to the console. */
+  once(...args) {
+    const message = String(args[0]);
+    if (this.onceMessages.has(message)) {
+      return () => {
+      };
+    }
+    this.onceMessages.add(message);
+    return this.console.info.bind(this.console, ...args);
+  }
+  /** Logs a warning message to the console. */
   warn(...args) {
     return this.console.warn.bind(this.console, ...args);
   }
+  /** Logs an error message to the console. */
   error(...args) {
     return this.console.error.bind(this.console, ...args);
   }
 };
 
 // dist/lib/loader-utils/option-defaults.js
-var import_loader_utils4 = require("@loaders.gl/loader-utils");
 var DEFAULT_LOADER_OPTIONS = {
   core: {
     baseUrl: void 0,
@@ -374,6 +1900,7 @@ var DEFAULT_LOADER_OPTIONS = {
     fallbackMimeType: void 0,
     ignoreRegisteredLoaders: void 0,
     nothrow: false,
+    shape: void 0,
     log: new ConsoleLog(),
     // A probe.gl compatible (`log.log()()` syntax) that just logs to console
     useLocalLibraries: false,
@@ -384,7 +1911,7 @@ var DEFAULT_LOADER_OPTIONS = {
     // How many worker instances should be created for each loader.
     maxMobileConcurrency: 1,
     // How many worker instances should be created for each loader on mobile devices.
-    reuseWorkers: import_loader_utils4.isBrowser,
+    reuseWorkers: isBrowser,
     // By default reuse workers in browser (Node.js refuses to terminate if browsers are running)
     _nodeWorkers: false,
     // By default do not support node workers
@@ -419,6 +1946,7 @@ var REMOVED_LOADER_OPTIONS = {
   _worker: "core._workerType",
   limit: "core.limit",
   _limitMB: "core._limitMB",
+  shape: "core.shape",
   batchSize: "core.batchSize",
   batchDebounceMs: "core.batchDebounceMs",
   metadata: "core.metadata",
@@ -457,10 +1985,12 @@ var CORE_LOADER_OPTION_KEYS = [
   "maxConcurrency",
   "maxMobileConcurrency",
   "reuseWorkers",
+  "workerTransferBufferCopy",
   "_nodeWorkers",
   "_workerType",
   "limit",
   "_limitMB",
+  "shape",
   "batchSize",
   "batchDebounceMs",
   "metadata",
@@ -486,7 +2016,7 @@ function setGlobalOptions(options) {
   const state = getGlobalLoaderState();
   const globalOptions = getGlobalLoaderOptions();
   state.globalOptions = normalizeOptionsInternal(globalOptions, options);
-  (0, import_loader_utils5.registerJSModules)(options.modules);
+  registerJSModules(options.modules);
 }
 function normalizeOptions(options, loader, loaders, url) {
   loaders = loaders || [];
@@ -520,7 +2050,7 @@ function validateOptionsObject(options, id, defaultOptions, deprecatedOptions, l
   const loaderName = id || "Top level";
   const prefix = id ? `${id}.` : "";
   for (const key in options) {
-    const isSubOptions = !id && (0, import_loader_utils5.isObject)(options[key]);
+    const isSubOptions = !id && isObject(options[key]);
     const isBaseUriOption = key === "baseUri" && !id;
     const isWorkerUrlOption = key === "workerUrl" && id;
     if (!(key in defaultOptions) && !isBaseUriOption && !isWorkerUrlOption) {
@@ -568,15 +2098,40 @@ function normalizeOptionsInternal(loader, options, url) {
   mergeNestedFields(mergedOptions, normalizeLoaderOptions(getGlobalLoaderOptions()));
   const userOptions = normalizeLoaderOptions(options);
   mergeNestedFields(mergedOptions, userOptions);
+  applyCoreShapeDefault(mergedOptions, userOptions, loader);
   addUrlOptions(mergedOptions, url);
   addDeprecatedTopLevelOptions(mergedOptions);
   return mergedOptions;
 }
+function applyCoreShapeDefault(mergedOptions, userOptions, loader) {
+  var _a, _b;
+  const coreShape = (_a = mergedOptions.core) == null ? void 0 : _a.shape;
+  if (coreShape === void 0) {
+    return;
+  }
+  const loaderScopedDefaults = (_b = loader.options) == null ? void 0 : _b[loader.id];
+  if (!isPureObject(loaderScopedDefaults) || !("shape" in loaderScopedDefaults)) {
+    return;
+  }
+  const globalLoaderScopedOptions = getGlobalLoaderOptions()[loader.id];
+  if (isPureObject(globalLoaderScopedOptions) && "shape" in globalLoaderScopedOptions) {
+    return;
+  }
+  const userLoaderScopedOptions = userOptions[loader.id];
+  if (isPureObject(userLoaderScopedOptions) && "shape" in userLoaderScopedOptions) {
+    return;
+  }
+  const loaderScopedOptions = mergedOptions[loader.id];
+  mergedOptions[loader.id] = {
+    ...isPureObject(loaderScopedOptions) ? loaderScopedOptions : {},
+    shape: coreShape
+  };
+}
 function mergeNestedFields(mergedOptions, options) {
   for (const key in options) {
     if (key in options) {
       const value = options[key];
-      if ((0, import_loader_utils5.isPureObject)(value) && (0, import_loader_utils5.isPureObject)(mergedOptions[key])) {
+      if (isPureObject(value) && isPureObject(mergedOptions[key])) {
         mergedOptions[key] = {
           ...mergedOptions[key],
           ...options[key]
@@ -595,7 +2150,7 @@ function addUrlOptions(options, url) {
   const hasCoreBaseUrl = ((_a = options.core) == null ? void 0 : _a.baseUrl) !== void 0;
   if (!hasCoreBaseUrl) {
     options.core ||= {};
-    options.core.baseUrl = import_loader_utils5.path.dirname(stripQueryString(url));
+    options.core.baseUrl = path_exports.dirname(stripQueryString(url));
   }
 }
 function cloneLoaderOptions(options) {
@@ -614,7 +2169,8 @@ function moveDeprecatedTopLevelOptionsToCore(options) {
   }
   for (const key of CORE_LOADER_OPTION_KEYS) {
     if (options[key] !== void 0) {
-      const coreOptions = options.core = options.core || {};
+      options.core ||= {};
+      const coreOptions = options.core;
       const coreRecord = coreOptions;
       if (coreRecord[key] === void 0) {
         coreRecord[key] = options[key];
@@ -642,7 +2198,6 @@ function addDeprecatedTopLevelOptions(options) {
 }
 
 // dist/lib/loader-utils/normalize-loader.js
-var import_loader_utils6 = require("@loaders.gl/loader-utils");
 function isLoaderObject(loader) {
   if (!loader) {
     return false;
@@ -654,8 +2209,8 @@ function isLoaderObject(loader) {
   return hasExtensions;
 }
 function normalizeLoader(loader) {
-  (0, import_loader_utils6.assert)(loader, "null loader");
-  (0, import_loader_utils6.assert)(isLoaderObject(loader), "invalid loader");
+  assert(loader, "null loader");
+  assert(isLoaderObject(loader), "invalid loader");
   let options;
   if (Array.isArray(loader)) {
     options = loader[1];
@@ -699,7 +2254,6 @@ function _unregisterLoaders() {
 }
 
 // dist/lib/api/select-loader.js
-var import_loader_utils7 = require("@loaders.gl/loader-utils");
 var EXT_PATTERN = /\.([^.]+)$/;
 async function selectLoader(data, loaders = [], options, context) {
   if (!validHTTPResponse(data)) {
@@ -718,7 +2272,7 @@ async function selectLoader(data, loaders = [], options, context) {
   if (loader) {
     return loader;
   }
-  if ((0, import_loader_utils7.isBlob)(data)) {
+  if (isBlob(data)) {
     data = await data.slice(0, 10).arrayBuffer();
     loader = selectLoaderSync(data, loaders, normalizedOptions, context);
   }
@@ -765,22 +2319,33 @@ function selectLoaderInternal(data, loaders, options, context) {
   const testUrl = stripQueryString(url) || (context == null ? void 0 : context.url);
   let loader = null;
   let reason = "";
+  const sourceType = (options == null ? void 0 : options.core) && "type" in options.core ? options.core.type : void 0;
+  if (sourceType && sourceType !== "auto") {
+    loader = findSourceLoaderByType(loaders, sourceType);
+    reason = loader ? `match forced by supplied source type ${sourceType}` : "";
+  }
   if ((_a = options == null ? void 0 : options.core) == null ? void 0 : _a.mimeType) {
     loader = findLoaderByMIMEType(loaders, (_b = options == null ? void 0 : options.core) == null ? void 0 : _b.mimeType);
     reason = `match forced by supplied MIME type ${(_c = options == null ? void 0 : options.core) == null ? void 0 : _c.mimeType}`;
   }
+  loader = loader || findSourceLoaderByTestURL(loaders, testUrl);
+  reason = reason || (loader ? `matched source url ${testUrl}` : "");
   loader = loader || findLoaderByUrl(loaders, testUrl);
   reason = reason || (loader ? `matched url ${testUrl}` : "");
   loader = loader || findLoaderByMIMEType(loaders, type);
   reason = reason || (loader ? `matched MIME type ${type}` : "");
   loader = loader || findLoaderByInitialBytes(loaders, data);
   reason = reason || (loader ? `matched initial data ${getFirstCharacters(data)}` : "");
+  if (!loader && isBlob(data)) {
+    loader = findSourceLoaderByTestData(loaders, data);
+    reason = reason || (loader ? "matched source testData" : "");
+  }
   if ((_d = options == null ? void 0 : options.core) == null ? void 0 : _d.fallbackMimeType) {
     loader = loader || findLoaderByMIMEType(loaders, (_e = options == null ? void 0 : options.core) == null ? void 0 : _e.fallbackMimeType);
     reason = reason || (loader ? `matched fallback MIME type ${type}` : "");
   }
   if (reason) {
-    import_loader_utils7.log.log(1, `selectLoader selected ${loader == null ? void 0 : loader.name}: ${reason}.`);
+    log.log(1, `selectLoader selected ${loader == null ? void 0 : loader.name}: ${reason}.`);
   }
   return loader;
 }
@@ -796,7 +2361,7 @@ function getNoValidLoaderMessage(data) {
   const url = getResourceUrl(data);
   const type = getResourceMIMEType(data);
   let message = "No valid loader found (";
-  message += url ? `${import_loader_utils7.path.filename(url)}, ` : "no url provided, ";
+  message += url ? `${path_exports.filename(url)}, ` : "no url provided, ";
   message += `MIME type: ${type ? `"${type}"` : "not provided"}, `;
   const firstCharacters = data ? getFirstCharacters(data) : "";
   message += firstCharacters ? ` first bytes: "${firstCharacters}"` : "first bytes: not available";
@@ -808,16 +2373,46 @@ function normalizeLoaders(loaders) {
     normalizeLoader(loader);
   }
 }
-function findLoaderByUrl(loaders, url) {
-  const match = url && EXT_PATTERN.exec(url);
-  const extension = match && match[1];
-  return extension ? findLoaderByExtension(loaders, extension) : null;
-}
-function findLoaderByExtension(loaders, extension) {
-  extension = extension.toLowerCase();
+function findLoaderByUrl(loaders, url) {
+  const match = url && EXT_PATTERN.exec(url);
+  const extension = match && match[1];
+  return extension ? findLoaderByExtension(loaders, extension) : null;
+}
+function findLoaderByExtension(loaders, extension) {
+  extension = extension.toLowerCase();
+  for (const loader of loaders) {
+    for (const loaderExtension of loader.extensions) {
+      if (loaderExtension.toLowerCase() === extension) {
+        return loader;
+      }
+    }
+  }
+  return null;
+}
+function findSourceLoaderByType(loaders, type) {
+  for (const loader of loaders) {
+    if (isSourceLoader(loader) && loader.type === type) {
+      return loader;
+    }
+  }
+  return null;
+}
+function findSourceLoaderByTestURL(loaders, url) {
+  if (!url) {
+    return null;
+  }
+  for (const loader of loaders) {
+    if (isSourceLoader(loader) && loader.testURL(url)) {
+      return loader;
+    }
+  }
+  return null;
+}
+function findSourceLoaderByTestData(loaders, data) {
+  var _a;
   for (const loader of loaders) {
-    for (const loaderExtension of loader.extensions) {
-      if (loaderExtension.toLowerCase() === extension) {
+    if (isSourceLoader(loader)) {
+      if ((_a = loader.testData) == null ? void 0 : _a.call(loader, data)) {
         return loader;
       }
     }
@@ -870,12 +2465,12 @@ function testDataAgainstBinary(data, byteOffset, loader) {
   return tests.some((test) => testBinary(data, byteOffset, loader, test));
 }
 function testBinary(data, byteOffset, loader, test) {
-  if ((0, import_loader_utils7.isArrayBufferLike)(test)) {
-    return (0, import_loader_utils7.compareArrayBuffers)(test, data, test.byteLength);
+  if (isArrayBufferLike(test)) {
+    return compareArrayBuffers(test, data, test.byteLength);
   }
   switch (typeof test) {
     case "function":
-      return test((0, import_loader_utils7.ensureArrayBuffer)(data));
+      return test(ensureArrayBuffer(data));
     case "string":
       const magic = getMagicString(data, byteOffset, test.length);
       return test === magic;
@@ -906,15 +2501,7 @@ function getMagicString(arrayBuffer, byteOffset, length) {
   return magic;
 }
 
-// dist/lib/api/parse.js
-var import_loader_utils14 = require("@loaders.gl/loader-utils");
-var import_worker_utils = require("@loaders.gl/worker-utils");
-
-// dist/lib/loader-utils/get-data.js
-var import_loader_utils11 = require("@loaders.gl/loader-utils");
-
 // dist/iterators/make-iterator/make-string-iterator.js
-var import_loader_utils8 = require("@loaders.gl/loader-utils");
 var DEFAULT_CHUNK_SIZE = 256 * 1024;
 function* makeStringIterator(string, options) {
   const chunkSize = (options == null ? void 0 : options.chunkSize) || DEFAULT_CHUNK_SIZE;
@@ -924,7 +2511,7 @@ function* makeStringIterator(string, options) {
     const chunkLength = Math.min(string.length - offset, chunkSize);
     const chunk = string.slice(offset, offset + chunkLength);
     offset += chunkLength;
-    yield (0, import_loader_utils8.ensureArrayBuffer)(textEncoder.encode(chunk));
+    yield ensureArrayBuffer(textEncoder.encode(chunk));
   }
 }
 
@@ -958,37 +2545,72 @@ async function* makeBlobIterator(blob, options) {
 }
 
 // dist/iterators/make-iterator/make-stream-iterator.js
-var import_loader_utils9 = require("@loaders.gl/loader-utils");
 function makeStreamIterator(stream, options) {
-  return import_loader_utils9.isBrowser ? makeBrowserStreamIterator(stream, options) : makeNodeStreamIterator(stream, options);
+  return isBrowser ? makeBrowserStreamIterator(stream, options) : makeNodeStreamIterator(stream, options);
 }
 async function* makeBrowserStreamIterator(stream, options) {
   const reader = stream.getReader();
   let nextBatchPromise;
+  let streamFinished = false;
+  let streamReadFailed = false;
+  let iteratorFailed = false;
   try {
     while (true) {
       const currentBatchPromise = nextBatchPromise || reader.read();
-      if (options == null ? void 0 : options._streamReadAhead) {
-        nextBatchPromise = reader.read();
+      nextBatchPromise = void 0;
+      let batch;
+      try {
+        batch = await currentBatchPromise;
+      } catch (error) {
+        streamReadFailed = true;
+        throw error;
       }
-      const { done, value } = await currentBatchPromise;
+      const { done, value } = batch;
       if (done) {
+        streamFinished = true;
         return;
       }
-      yield (0, import_loader_utils9.toArrayBuffer)(value);
+      if (options == null ? void 0 : options._streamReadAhead) {
+        nextBatchPromise = reader.read();
+        void nextBatchPromise.catch(() => {
+        });
+      }
+      yield toArrayBuffer2(value);
     }
   } catch (error) {
-    reader.releaseLock();
+    iteratorFailed = true;
+    throw error;
+  } finally {
+    let cleanupFailed = false;
+    let cleanupError;
+    if (!streamFinished && !streamReadFailed) {
+      try {
+        await reader.cancel();
+      } catch (error) {
+        cleanupFailed = true;
+        cleanupError = error;
+      }
+    }
+    try {
+      reader.releaseLock();
+    } catch (error) {
+      if (!cleanupFailed) {
+        cleanupFailed = true;
+        cleanupError = error;
+      }
+    }
+    if (!iteratorFailed && cleanupFailed) {
+      throw cleanupError;
+    }
   }
 }
 async function* makeNodeStreamIterator(stream, options) {
   for await (const chunk of stream) {
-    yield (0, import_loader_utils9.toArrayBuffer)(chunk);
+    yield toArrayBuffer2(chunk);
   }
 }
 
 // dist/iterators/make-iterator/make-iterator.js
-var import_loader_utils10 = require("@loaders.gl/loader-utils");
 function makeIterator(data, options) {
   if (typeof data === "string") {
     return makeStringIterator(data, options);
@@ -996,13 +2618,13 @@ function makeIterator(data, options) {
   if (data instanceof ArrayBuffer) {
     return makeArrayBufferIterator(data, options);
   }
-  if ((0, import_loader_utils10.isBlob)(data)) {
+  if (isBlob(data)) {
     return makeBlobIterator(data, options);
   }
-  if ((0, import_loader_utils10.isReadableStream)(data)) {
+  if (isReadableStream(data)) {
     return makeStreamIterator(data, options);
   }
-  if ((0, import_loader_utils10.isResponse)(data)) {
+  if (isResponse(data)) {
     const responseBody = data.body;
     if (!responseBody) {
       throw new Error("Readable stream not available on Response");
@@ -1018,46 +2640,68 @@ function getArrayBufferOrStringFromDataSync(data, loader, options) {
   if (loader.text && typeof data === "string") {
     return data;
   }
-  if ((0, import_loader_utils11.isBuffer)(data)) {
+  if (isBuffer(data)) {
     data = data.buffer;
   }
-  if ((0, import_loader_utils11.isArrayBufferLike)(data)) {
-    const bufferSource = (0, import_loader_utils11.toArrayBufferView)(data);
+  if (isArrayBufferLike(data)) {
+    const bufferSource = toArrayBufferView(data);
     if (loader.text && !loader.binary) {
       const textDecoder = new TextDecoder("utf8");
       return textDecoder.decode(bufferSource);
     }
-    return (0, import_loader_utils11.toArrayBuffer)(bufferSource);
+    return toArrayBuffer2(bufferSource);
   }
   throw new Error(ERR_DATA);
 }
 async function getArrayBufferOrStringFromData(data, loader, options) {
-  if (typeof data === "string" || (0, import_loader_utils11.isArrayBufferLike)(data)) {
+  if (typeof data === "string" || isArrayBufferLike(data)) {
     return getArrayBufferOrStringFromDataSync(data, loader, options);
   }
-  if ((0, import_loader_utils11.isBlob)(data)) {
+  if (isBlob(data)) {
     data = await makeResponse(data);
   }
-  if ((0, import_loader_utils11.isResponse)(data)) {
+  if (isResponse(data)) {
     await checkResponse(data);
     return loader.binary ? await data.arrayBuffer() : await data.text();
   }
-  if ((0, import_loader_utils11.isReadableStream)(data)) {
+  if (isReadableStream(data)) {
+    data = makeIterator(data, options);
+  }
+  if (isIterable(data) || isAsyncIterable(data)) {
+    return concatenateArrayBuffersAsync(data);
+  }
+  throw new Error(ERR_DATA);
+}
+async function getArrayBufferFromData(data, options) {
+  if (typeof data === "string") {
+    return new TextEncoder().encode(data).buffer;
+  }
+  if (isArrayBufferLike(data)) {
+    return toArrayBuffer2(toArrayBufferView(data));
+  }
+  if (isBlob(data)) {
+    data = await makeResponse(data);
+  }
+  if (isResponse(data)) {
+    await checkResponse(data);
+    return await data.arrayBuffer();
+  }
+  if (isReadableStream(data)) {
     data = makeIterator(data, options);
   }
-  if ((0, import_loader_utils11.isIterable)(data) || (0, import_loader_utils11.isAsyncIterable)(data)) {
-    return (0, import_loader_utils11.concatenateArrayBuffersAsync)(data);
+  if (isIterable(data) || isAsyncIterable(data)) {
+    return concatenateArrayBuffersAsync(data);
   }
   throw new Error(ERR_DATA);
 }
 async function getAsyncIterableFromData(data, options) {
-  if ((0, import_loader_utils11.isPromise)(data)) {
+  if (isPromise(data)) {
     data = await data;
   }
-  if ((0, import_loader_utils11.isIterator)(data)) {
+  if (isIterator(data)) {
     return data;
   }
-  if ((0, import_loader_utils11.isResponse)(data)) {
+  if (isResponse(data)) {
     await checkResponse(data);
     const body = await data.body;
     if (!body) {
@@ -1065,39 +2709,38 @@ async function getAsyncIterableFromData(data, options) {
     }
     return makeIterator(body, options);
   }
-  if ((0, import_loader_utils11.isBlob)(data) || (0, import_loader_utils11.isReadableStream)(data)) {
+  if (isBlob(data) || isReadableStream(data)) {
     return makeIterator(data, options);
   }
-  if ((0, import_loader_utils11.isAsyncIterable)(data)) {
+  if (isAsyncIterable(data)) {
     return data;
   }
-  if ((0, import_loader_utils11.isIterable)(data)) {
+  if (isIterable(data)) {
     return data;
   }
   return getIterableFromData(data);
 }
 function getIterableFromData(data) {
   if (ArrayBuffer.isView(data)) {
-    return function* oneChunk() {
-      yield (0, import_loader_utils11.toArrayBuffer)(data);
-    }();
+    return (function* oneChunk() {
+      yield toArrayBuffer2(data);
+    })();
   }
-  if ((0, import_loader_utils11.isArrayBufferLike)(data)) {
-    return function* oneChunk() {
-      yield (0, import_loader_utils11.toArrayBuffer)(data);
-    }();
+  if (isArrayBufferLike(data)) {
+    return (function* oneChunk() {
+      yield toArrayBuffer2(data);
+    })();
   }
-  if ((0, import_loader_utils11.isIterator)(data)) {
+  if (isIterator(data)) {
     return data;
   }
-  if ((0, import_loader_utils11.isIterable)(data)) {
+  if (isIterable(data)) {
     return data[Symbol.iterator]();
   }
   throw new Error(ERR_DATA);
 }
 
 // dist/lib/loader-utils/get-fetch-function.js
-var import_loader_utils12 = require("@loaders.gl/loader-utils");
 function getFetchFunction(options, context) {
   var _a;
   const globalOptions = getGlobalLoaderOptions();
@@ -1106,7 +2749,7 @@ function getFetchFunction(options, context) {
   if (typeof fetchOption === "function") {
     return fetchOption;
   }
-  if ((0, import_loader_utils12.isObject)(fetchOption)) {
+  if (isObject(fetchOption)) {
     return (url) => fetchFile(url, fetchOption);
   }
   if (context == null ? void 0 : context.fetch) {
@@ -1115,92 +2758,147 @@ function getFetchFunction(options, context) {
   return fetchFile;
 }
 
-// dist/lib/loader-utils/loader-context.js
-var import_loader_utils13 = require("@loaders.gl/loader-utils");
-function getLoaderContext(context, options, parentContext) {
-  if (parentContext) {
-    return parentContext;
+// dist/lib/api/load-loader.js
+var loaderImplementationPromises = /* @__PURE__ */ new Map();
+var loaderImplementations = /* @__PURE__ */ new Map();
+async function getLoaderImplementation(loader, options, url) {
+  var _a;
+  if (isLoaderWithParser(loader)) {
+    return loader;
   }
-  const newContext = {
-    fetch: getFetchFunction(options, context),
-    ...context
-  };
-  if (newContext.url) {
-    const baseUrl = stripQueryString(newContext.url);
-    newContext.baseUrl = baseUrl;
-    newContext.queryString = extractQueryString(newContext.url);
-    newContext.filename = import_loader_utils13.path.filename(baseUrl);
-    newContext.baseUrl = import_loader_utils13.path.dirname(baseUrl);
+  const implementationCacheKey = getLoaderImplementationCacheKey(loader, options);
+  const loaderImplementation = (_a = loaderImplementations.get(loader)) == null ? void 0 : _a.get(implementationCacheKey);
+  if (loaderImplementation) {
+    return loaderImplementation;
+  }
+  let loaderImplementationPromisesForLoader = loaderImplementationPromises.get(loader);
+  if (!loaderImplementationPromisesForLoader) {
+    loaderImplementationPromisesForLoader = /* @__PURE__ */ new Map();
+    loaderImplementationPromises.set(loader, loaderImplementationPromisesForLoader);
+  }
+  let loaderImplementationPromise = loaderImplementationPromisesForLoader.get(implementationCacheKey);
+  if (!loaderImplementationPromise) {
+    loaderImplementationPromise = resolveLoaderImplementation(loader, options, url).then((implementation) => {
+      let loaderImplementationsForLoader = loaderImplementations.get(loader);
+      if (!loaderImplementationsForLoader) {
+        loaderImplementationsForLoader = /* @__PURE__ */ new Map();
+        loaderImplementations.set(loader, loaderImplementationsForLoader);
+      }
+      loaderImplementationsForLoader.set(implementationCacheKey, implementation);
+      return implementation;
+    }).catch((error) => {
+      loaderImplementationPromisesForLoader.delete(implementationCacheKey);
+      if (loaderImplementationPromisesForLoader.size === 0) {
+        loaderImplementationPromises.delete(loader);
+      }
+      throw error;
+    });
+    loaderImplementationPromisesForLoader.set(implementationCacheKey, loaderImplementationPromise);
   }
-  if (!Array.isArray(newContext.loaders)) {
-    newContext.loaders = null;
+  return await loaderImplementationPromise;
+}
+function getLoaderImplementationSync(loader) {
+  var _a;
+  if (isLoaderWithParser(loader)) {
+    return loader;
   }
-  return newContext;
+  const implementationCacheKey = getLoaderImplementationCacheKey(loader);
+  return ((_a = loaderImplementations.get(loader)) == null ? void 0 : _a.get(implementationCacheKey)) || null;
 }
-function getLoadersFromContext(loaders, context) {
-  if (loaders && !Array.isArray(loaders)) {
-    return loaders;
+function isLoaderWithParser(loader) {
+  const candidate = loader;
+  return Boolean(candidate.parse || candidate.parseSync || candidate.parseInBatches || candidate.parseText || candidate.parseTextSync || candidate.parseFile || candidate.parseFileInBatches);
+}
+async function resolveLoaderImplementation(loader, options, url) {
+  if (loader.preload) {
+    const preloadedLoader = await loader.preload(url || "", options);
+    if (isLoaderWithParser(preloadedLoader)) {
+      return preloadedLoader;
+    }
+    throw new Error(`${loader.id} loader preload() did not return a parser-bearing loader`);
   }
-  let candidateLoaders;
-  if (loaders) {
-    candidateLoaders = Array.isArray(loaders) ? loaders : [loaders];
+  const implementationSpecifier = getLoaderImplementationSpecifier(loader, options);
+  return await importLoaderImplementation(implementationSpecifier, loader.id);
+}
+function getLoaderImplementationSpecifier(loader, options) {
+  var _a;
+  const workerType = (options == null ? void 0 : options._workerType) || ((_a = options == null ? void 0 : options.core) == null ? void 0 : _a._workerType);
+  if (workerType === "test") {
+    const sourcePath = `modules/${loader.module}/src/${loader.id}-loader.ts`;
+    if (typeof window !== "undefined") {
+      return `/${sourcePath}`;
+    }
+    if (typeof process !== "undefined" && process.cwd) {
+      return new URL(sourcePath, `file://${process.cwd()}/`).toString();
+    }
+    return sourcePath;
   }
-  if (context && context.loaders) {
-    const contextLoaders = Array.isArray(context.loaders) ? context.loaders : [context.loaders];
-    candidateLoaders = candidateLoaders ? [...candidateLoaders, ...contextLoaders] : contextLoaders;
+  throw new Error(`${loader.id} loader does not provide a parser implementation. Import a parser-bearing loader directly, or use preload() before parse/load.`);
+}
+function getLoaderImplementationCacheKey(loader, options) {
+  var _a;
+  const loaderOptions = options == null ? void 0 : options[loader.id];
+  const defaultLoaderOptions = (_a = loader.options) == null ? void 0 : _a[loader.id];
+  return String((loaderOptions == null ? void 0 : loaderOptions.backend) || (defaultLoaderOptions == null ? void 0 : defaultLoaderOptions.backend) || "");
+}
+async function importLoaderImplementation(implementationSpecifier, loaderId) {
+  const moduleExports = await import(
+    /* webpackIgnore: true */
+    /* @vite-ignore */
+    implementationSpecifier
+  );
+  for (const exportValue of Object.values(moduleExports)) {
+    if (exportValue && typeof exportValue === "object" && exportValue.id === loaderId && isLoaderWithParser(exportValue)) {
+      return exportValue;
+    }
   }
-  return candidateLoaders && candidateLoaders.length ? candidateLoaders : void 0;
+  throw new Error(`Could not find parser implementation for ${loaderId} in ${implementationSpecifier}`);
 }
 
-// dist/lib/api/parse.js
-async function parse(data, loaders, options, context) {
+// dist/lib/api/parse-file.js
+async function parseFile(file, loaders, options, context) {
   if (loaders && !Array.isArray(loaders) && !isLoaderObject(loaders)) {
     context = void 0;
     options = loaders;
     loaders = void 0;
   }
-  data = await data;
   options = options || {};
-  const url = getResourceUrl(data);
+  const url = file.url || "";
   const typedLoaders = loaders;
   const candidateLoaders = getLoadersFromContext(typedLoaders, context);
-  const loader = await selectLoader(data, candidateLoaders, options);
+  const loader = await selectLoader(url, candidateLoaders, options);
   if (!loader) {
     return null;
   }
+  if (isSourceLoader(loader)) {
+    throw new Error(`${loader.id} is a SourceLoader. Use load() to create a runtime source object instead of parseFile().`);
+  }
   const strictOptions = normalizeOptions(options, loader, candidateLoaders, url);
   context = getLoaderContext(
-    // @ts-expect-error
+    // @ts-expect-error candidateLoaders may be a single forced loader
     { url, _parse: parse, loaders: candidateLoaders },
     strictOptions,
     context || null
   );
-  return await parseWithLoader(loader, data, strictOptions, context);
-}
-async function parseWithLoader(loader, data, options, context) {
-  (0, import_worker_utils.validateWorkerVersion)(loader);
-  options = (0, import_loader_utils14.mergeOptions)(loader.options, options);
-  if ((0, import_loader_utils14.isResponse)(data)) {
-    const { ok, redirected, status, statusText, type, url } = data;
-    const headers = Object.fromEntries(data.headers.entries());
-    context.response = { headers, ok, redirected, status, statusText, type, url };
-  }
-  data = await getArrayBufferOrStringFromData(data, loader, options);
-  const loaderWithParser = loader;
-  if (loaderWithParser.parseTextSync && typeof data === "string") {
-    return loaderWithParser.parseTextSync(data, options, context);
-  }
-  if ((0, import_loader_utils14.canParseWithWorker)(loader, options)) {
-    return await (0, import_loader_utils14.parseWithWorker)(loader, data, options, context, parse);
-  }
-  if (loaderWithParser.parseText && typeof data === "string") {
-    return await loaderWithParser.parseText(data, options, context);
-  }
-  if (loaderWithParser.parse) {
-    return await loaderWithParser.parse(data, options, context);
+  return await parseFileWithLoader(loader, file, strictOptions, context);
+}
+async function parseFileWithLoader(loader, file, options, context) {
+  validateWorkerVersion(loader);
+  options = mergeOptions(loader.options, options);
+  const loaderWithParser = await getLoaderImplementation(loader, options, context.url);
+  if (loaderWithParser.parseFile) {
+    return await loaderWithParser.parseFile(file, options, context);
+  }
+  const parseFunction = loaderWithParser.parse;
+  if (parseFunction) {
+    const length = file.bigsize > 0n ? Number(file.bigsize) : file.size;
+    if (!length) {
+      throw new Error(`${loader.id} loader - cannot fall back to parse without a file size`);
+    }
+    const data = await file.read(0n, length);
+    return await parse(data, loaderWithParser, options, context);
   }
-  (0, import_worker_utils.assert)(!loaderWithParser.parseSync);
-  throw new Error(`${loader.id} loader - no parser found and worker is disabled`);
+  throw new Error(`${loader.id} loader - no file parser found`);
 }
 
 // dist/lib/api/parse-sync.js
@@ -1217,13 +2915,17 @@ function parseSync(data, loaders, options, context) {
   if (!loader) {
     return null;
   }
+  if (isSourceLoader(loader)) {
+    throw new Error(`${loader.id} is a SourceLoader. Use load() to create a runtime source object instead of parseSync().`);
+  }
   const strictOptions = normalizeOptions(options, loader, candidateLoaders);
   const url = getResourceUrl(data);
   const parse2 = () => {
     throw new Error("parseSync called parse (which is async");
   };
   context = getLoaderContext({ url, _parseSync: parse2, _parse: parse2, loaders }, strictOptions, context || null);
-  return parseWithLoaderSync(loader, data, strictOptions, context);
+  const loaderWithParser = getLoaderImplementationSync(loader);
+  return parseWithLoaderSync(loaderWithParser || loader, data, strictOptions, context);
 }
 function parseWithLoaderSync(loader, data, options, context) {
   data = getArrayBufferOrStringFromDataSync(data, loader, options);
@@ -1233,12 +2935,56 @@ function parseWithLoaderSync(loader, data, options, context) {
   if (loader.parseSync && data instanceof ArrayBuffer) {
     return loader.parseSync(data, options, context);
   }
+  if (loader.preload) {
+    throw new Error(`${loader.name} loader: 'parseSync' requires a parser-bearing loader. Import the loader implementation directly, or call preload(loader) before parseSync(). ${context.url || ""}`);
+  }
   throw new Error(`${loader.name} loader: 'parseSync' not supported by this loader, use 'parse' instead. ${context.url || ""}`);
 }
 
+// ../schema-utils/src/lib/table/tables/table-accessors.ts
+function isTable(table) {
+  var _a;
+  const shape = typeof table === "object" && (table == null ? void 0 : table.shape);
+  switch (shape) {
+    case "array-row-table":
+    case "object-row-table":
+      return Array.isArray(table.data);
+    case "geojson-table":
+      return Array.isArray(table.features);
+    case "columnar-table":
+      return table.data && typeof table.data === "object";
+    case "arrow-table":
+      return Boolean(((_a = table == null ? void 0 : table.data) == null ? void 0 : _a.numRows) !== void 0);
+    default:
+      return false;
+  }
+}
+function getTableLength(table) {
+  switch (table.shape) {
+    case "array-row-table":
+    case "object-row-table":
+      return table.data.length;
+    case "geojson-table":
+      return table.features.length;
+    case "arrow-table":
+      const arrowTable = table.data;
+      return arrowTable.numRows;
+    case "columnar-table":
+      for (const column of Object.values(table.data)) {
+        return column.length || 0;
+      }
+      return 0;
+    default:
+      throw new Error("table");
+  }
+}
+
+// ../schema-utils/src/lib/table/batches/make-table-batch-iterator.ts
+function makeBatchFromTable(table) {
+  return { ...table, length: getTableLength(table), batchType: "data" };
+}
+
 // dist/lib/api/parse-in-batches.js
-var import_schema_utils = require("@loaders.gl/schema-utils");
-var import_loader_utils15 = require("@loaders.gl/loader-utils");
 async function parseInBatches(data, loaders, options, context) {
   const loaderArray = Array.isArray(loaders) ? loaders : void 0;
   if (!Array.isArray(loaders) && !isLoaderObject(loaders)) {
@@ -1255,9 +3001,10 @@ async function parseInBatches(data, loaders, options, context) {
   }
   const strictOptions = normalizeOptions(options, loader, loaderArray, url);
   context = getLoaderContext({ url, _parseInBatches: parseInBatches, _parse: parse, loaders: loaderArray }, strictOptions, context || null);
-  return await parseWithLoaderInBatches(loader, data, strictOptions, context);
+  const loaderWithParser = await getLoaderImplementation(loader, strictOptions, context.url);
+  return await parseWithLoaderInBatches(loader, loaderWithParser, data, strictOptions, context);
 }
-async function parseWithLoaderInBatches(loader, data, options, context) {
+async function parseWithLoaderInBatches(originalLoader, loader, data, options, context) {
   var _a;
   const outputIterator = await parseToOutputIterator(loader, data, options, context);
   if (!((_a = options == null ? void 0 : options.core) == null ? void 0 : _a.metadata)) {
@@ -1267,7 +3014,7 @@ async function parseWithLoaderInBatches(loader, data, options, context) {
     shape: "metadata",
     batchType: "metadata",
     metadata: {
-      _loader: loader,
+      _loader: originalLoader,
       _context: context
     },
     // Populate with some default fields to avoid crashing
@@ -1290,7 +3037,7 @@ async function parseToOutputIterator(loader, data, options, context) {
   return parseChunkInBatches(transformedIterator, loader, options, context);
 }
 async function* parseChunkInBatches(transformedIterator, loader, options, context) {
-  const arrayBuffer = await (0, import_loader_utils15.concatenateArrayBuffersAsync)(transformedIterator);
+  const arrayBuffer = await concatenateArrayBuffersAsync(transformedIterator);
   const parsedData = await parse(
     arrayBuffer,
     loader,
@@ -1302,7 +3049,7 @@ async function* parseChunkInBatches(transformedIterator, loader, options, contex
   yield batch;
 }
 function convertDataToBatch(parsedData, loader) {
-  const batch = (0, import_schema_utils.isTable)(parsedData) ? (0, import_schema_utils.makeBatchFromTable)(parsedData) : {
+  const batch = isTable(parsedData) ? makeBatchFromTable(parsedData) : {
     shape: "unknown",
     batchType: "data",
     data: parsedData,
@@ -1319,8 +3066,33 @@ async function applyInputTransforms(inputIterator, transforms = []) {
   return iteratorChain;
 }
 
+// dist/lib/api/load-in-batches.js
+function loadInBatches(files, loaders, options, context) {
+  let loadersArray;
+  if (!Array.isArray(loaders) && !isLoaderObject(loaders)) {
+    context = void 0;
+    options = loaders;
+    loadersArray = void 0;
+  } else {
+    loadersArray = loaders;
+  }
+  const fetch2 = getFetchFunction(options || {});
+  if (!Array.isArray(files)) {
+    return loadOneFileInBatches(files, loadersArray, options || {}, fetch2);
+  }
+  const promises = files.map((file) => loadOneFileInBatches(file, loadersArray, options || {}, fetch2));
+  return promises;
+}
+async function loadOneFileInBatches(file, loaders, options, fetch2) {
+  if (typeof file === "string") {
+    const url = file;
+    const response = await fetch2(url);
+    return Array.isArray(loaders) ? await parseInBatches(response, loaders, options) : await parseInBatches(response, loaders, options);
+  }
+  return Array.isArray(loaders) ? await parseInBatches(file, loaders, options) : await parseInBatches(file, loaders, options);
+}
+
 // dist/lib/api/load.js
-var import_loader_utils16 = require("@loaders.gl/loader-utils");
 async function load(url, loaders, options, context) {
   var _a;
   let resolvedLoaders;
@@ -1333,12 +3105,56 @@ async function load(url, loaders, options, context) {
     resolvedLoaders = loaders;
     resolvedOptions = options;
   }
+  if (!Array.isArray(resolvedLoaders) && isSourceLoader(resolvedLoaders)) {
+    const sourceLoader = await resolveSourceLoader(resolvedLoaders, url, resolvedOptions);
+    const runtimeCoreApi = {
+      fetchFile,
+      parse,
+      parseFile,
+      parseSync,
+      parseInBatches,
+      load,
+      loadInBatches
+    };
+    return sourceLoader.createDataSource(url, resolvedOptions || {}, runtimeCoreApi);
+  }
+  if (Array.isArray(resolvedLoaders) && resolvedLoaders.length === 1 && isSourceLoader(resolvedLoaders[0])) {
+    const sourceLoader = await resolveSourceLoader(resolvedLoaders[0], url, resolvedOptions);
+    const runtimeCoreApi = {
+      fetchFile,
+      parse,
+      parseFile,
+      parseSync,
+      parseInBatches,
+      load,
+      loadInBatches
+    };
+    return sourceLoader.createDataSource(url, resolvedOptions || {}, runtimeCoreApi);
+  }
+  if (typeof url === "string" || isBlob(url)) {
+    const selectedLoader = await selectLoader(url, resolvedLoaders, {
+      ...resolvedOptions,
+      core: { ...resolvedOptions == null ? void 0 : resolvedOptions.core, nothrow: true }
+    });
+    if (selectedLoader && isSourceLoader(selectedLoader)) {
+      const sourceLoader = await resolveSourceLoader(selectedLoader, url, resolvedOptions);
+      return sourceLoader.createDataSource(url, resolvedOptions || {}, {
+        fetchFile,
+        parse,
+        parseFile,
+        parseSync,
+        parseInBatches,
+        load,
+        loadInBatches
+      });
+    }
+  }
   const fetch2 = getFetchFunction(resolvedOptions);
   let data = url;
   if (typeof url === "string") {
     data = await fetch2(url);
   }
-  if ((0, import_loader_utils16.isBlob)(url)) {
+  if (isBlob(url)) {
     data = await fetch2(url);
   }
   if (typeof url === "string") {
@@ -1353,44 +3169,146 @@ async function load(url, loaders, options, context) {
       };
     }
   }
-  return Array.isArray(resolvedLoaders) ? await parse(data, resolvedLoaders, resolvedOptions) : await parse(data, resolvedLoaders, resolvedOptions);
+  return Array.isArray(resolvedLoaders) ? await parse(data, resolvedLoaders, resolvedOptions, context) : await parse(data, resolvedLoaders, resolvedOptions, context);
+}
+async function resolveSourceLoader(loader, url, options) {
+  if (!loader.preload) {
+    return loader;
+  }
+  const sourceLoader = await loader.preload(typeof url === "string" ? url : "", options);
+  if (!isSourceLoader(sourceLoader)) {
+    throw new Error(`${loader.id} source loader preload() did not return a runtime source loader`);
+  }
+  return sourceLoader;
 }
 
-// dist/lib/api/load-in-batches.js
-function loadInBatches(files, loaders, options, context) {
-  let loadersArray;
-  if (!Array.isArray(loaders) && !isLoaderObject(loaders)) {
+// dist/lib/api/core-api.js
+var coreApi = Object.freeze({
+  fetchFile,
+  parse,
+  parseFile,
+  parseSync,
+  parseInBatches,
+  load,
+  loadInBatches
+});
+
+// dist/lib/loader-utils/loader-context.js
+function getLoaderContext(context, options, parentContext) {
+  if (parentContext) {
+    return parentContext;
+  }
+  const newContext = {
+    ...context,
+    fetch: getFetchFunction(options, context),
+    coreApi: context.coreApi || coreApi
+  };
+  if (newContext.url) {
+    const baseUrl = stripQueryString(newContext.url);
+    newContext.baseUrl = baseUrl;
+    newContext.queryString = extractQueryString(newContext.url);
+    newContext.filename = path_exports.filename(baseUrl);
+    newContext.baseUrl = path_exports.dirname(baseUrl);
+  }
+  if (!Array.isArray(newContext.loaders)) {
+    newContext.loaders = null;
+  }
+  return newContext;
+}
+function getLoadersFromContext(loaders, context) {
+  if (loaders && !Array.isArray(loaders)) {
+    return loaders;
+  }
+  let candidateLoaders;
+  if (loaders) {
+    candidateLoaders = Array.isArray(loaders) ? loaders : [loaders];
+  }
+  if (context && context.loaders) {
+    const contextLoaders = Array.isArray(context.loaders) ? context.loaders : [context.loaders];
+    candidateLoaders = candidateLoaders ? [...candidateLoaders, ...contextLoaders] : contextLoaders;
+  }
+  return candidateLoaders && candidateLoaders.length ? candidateLoaders : void 0;
+}
+
+// dist/lib/api/parse.js
+async function parse(data, loaders, options, context) {
+  if (loaders && !Array.isArray(loaders) && !isLoaderObject(loaders)) {
     context = void 0;
     options = loaders;
-    loadersArray = void 0;
-  } else {
-    loadersArray = loaders;
+    loaders = void 0;
   }
-  const fetch2 = getFetchFunction(options || {});
-  if (!Array.isArray(files)) {
-    return loadOneFileInBatches(files, loadersArray, options || {}, fetch2);
+  data = await data;
+  options = options || {};
+  const url = getResourceUrl(data);
+  const typedLoaders = loaders;
+  const candidateLoaders = getLoadersFromContext(typedLoaders, context);
+  const loader = await selectLoader(data, candidateLoaders, options);
+  if (!loader) {
+    return null;
   }
-  const promises = files.map((file) => loadOneFileInBatches(file, loadersArray, options || {}, fetch2));
-  return promises;
+  if (isSourceLoader(loader)) {
+    throw new Error(`${loader.id} is a SourceLoader. Use load() to create a runtime source object instead of parse().`);
+  }
+  const strictOptions = normalizeOptions(options, loader, candidateLoaders, url);
+  context = getLoaderContext(
+    // @ts-expect-error
+    { url, _parse: parse, loaders: candidateLoaders },
+    strictOptions,
+    context || null
+  );
+  return await parseWithLoader(loader, data, strictOptions, context);
 }
-async function loadOneFileInBatches(file, loaders, options, fetch2) {
-  if (typeof file === "string") {
-    const url = file;
-    const response = await fetch2(url);
-    return Array.isArray(loaders) ? await parseInBatches(response, loaders, options) : await parseInBatches(response, loaders, options);
+async function parseWithLoader(loader, data, options, context) {
+  validateWorkerVersion(loader);
+  options = mergeOptions(loader.options, options);
+  if (isResponse(data)) {
+    const { ok, redirected, status, statusText, type, url } = data;
+    const headers = Object.fromEntries(data.headers.entries());
+    context.response = { headers, ok, redirected, status, statusText, type, url };
   }
-  return Array.isArray(loaders) ? await parseInBatches(file, loaders, options) : await parseInBatches(file, loaders, options);
+  const loaderWithParser = await getLoaderImplementation(loader, options, context.url);
+  if (canParseWithWorker(loaderWithParser, options)) {
+    data = await getArrayBufferFromData(data, options);
+    return await parseWithWorker(loaderWithParser, data, options, context, parse);
+  }
+  if (isBlob(data) && loaderWithParser.parseBlob) {
+    return await loaderWithParser.parseBlob(data, options, context);
+  }
+  data = await getArrayBufferOrStringFromData(data, loader, options);
+  return await parseWithLoaderImplementation(loaderWithParser, data, options, context);
+}
+async function parseWithLoaderImplementation(loader, data, options, context) {
+  if (loader.parseText && typeof data === "string") {
+    return await loader.parseText(data, options, context);
+  }
+  if (loader.parseTextSync && typeof data === "string") {
+    return loader.parseTextSync(data, options, context);
+  }
+  if (loader.parse) {
+    return await loader.parse(data, options, context);
+  }
+  if (loader.parseSync) {
+    throw new Error(`${loader.name} loader: 'parse' not available on parser-bearing sync loader. Add an async 'parse' function to this loader, or call preload(loader) before parseSync(). ${context.url || ""}`);
+  }
+  throw new Error(`${loader.id} loader - no parser found and worker is disabled`);
+}
+
+// dist/lib/api/preload.js
+async function preload(loader, options, url) {
+  return await getLoaderImplementation(loader, options, url);
+}
+function preloadSync(loader) {
+  return getLoaderImplementationSync(loader);
 }
 
 // dist/lib/api/encode-table.js
-var import_loader_utils17 = require("@loaders.gl/loader-utils");
 async function encodeTable(data, writer, options) {
   if (writer.encode) {
     return await writer.encode(data, options);
   }
   if (writer.encodeText) {
     const text = await writer.encodeText(data, options);
-    return (0, import_loader_utils17.ensureArrayBuffer)(new TextEncoder().encode(text));
+    return ensureArrayBuffer(new TextEncoder().encode(text));
   }
   if (writer.encodeInBatches) {
     const batches = encodeTableInBatches(data, writer, options);
@@ -1398,7 +3316,7 @@ async function encodeTable(data, writer, options) {
     for await (const batch of batches) {
       chunks.push(batch);
     }
-    return (0, import_loader_utils17.concatenateArrayBuffers)(...chunks);
+    return concatenateArrayBuffers(...chunks);
   }
   throw new Error("Writer could not encode data");
 }
@@ -1425,16 +3343,14 @@ function getIterator(data) {
 }
 
 // dist/lib/api/encode.js
-var import_loader_utils18 = require("@loaders.gl/loader-utils");
-var import_worker_utils2 = require("@loaders.gl/worker-utils");
 async function encode(data, writer, options_) {
   const globalOptions = getGlobalLoaderOptions();
   const options = { ...globalOptions, ...options_ };
   if (writer.encodeURLtoURL) {
     return encodeWithCommandLineTool(writer, data, options);
   }
-  if ((0, import_loader_utils18.canEncodeWithWorker)(writer, options)) {
-    return await (0, import_worker_utils2.processOnWorker)(writer, data, options);
+  if (canEncodeWithWorker(writer, options)) {
+    return await processOnWorker(writer, data, options);
   }
   return await writer.encode(data, options);
 }
@@ -1443,7 +3359,7 @@ function encodeSync(data, writer, options) {
     return writer.encodeSync(data, options);
   }
   if (writer.encodeTextSync) {
-    return (0, import_loader_utils18.ensureArrayBuffer)(new TextEncoder().encode(writer.encodeTextSync(data, options)));
+    return ensureArrayBuffer(new TextEncoder().encode(writer.encodeTextSync(data, options)));
   }
   throw new Error(`Writer ${writer.name} could not synchronously encode data`);
 }
@@ -1478,20 +3394,20 @@ function encodeInBatches(data, writer, options) {
   throw new Error(`Writer ${writer.name} could not encode in batches`);
 }
 async function encodeURLtoURL(inputUrl, outputUrl, writer, options) {
-  inputUrl = (0, import_loader_utils18.resolvePath)(inputUrl);
-  outputUrl = (0, import_loader_utils18.resolvePath)(outputUrl);
-  if (import_loader_utils18.isBrowser || !writer.encodeURLtoURL) {
+  inputUrl = resolvePath(inputUrl);
+  outputUrl = resolvePath(outputUrl);
+  if (isBrowser || !writer.encodeURLtoURL) {
     throw new Error();
   }
   const outputFilename = await writer.encodeURLtoURL(inputUrl, outputUrl, options);
   return outputFilename;
 }
 async function encodeWithCommandLineTool(writer, data, options) {
-  if (import_loader_utils18.isBrowser) {
+  if (isBrowser) {
     throw new Error(`Writer ${writer.name} not supported in browser`);
   }
   const tmpInputFilename = getTemporaryFilename("input");
-  const file = new import_loader_utils18.NodeFile(tmpInputFilename, "w");
+  const file = new NodeFileFacade(tmpInputFilename, "w");
   await file.write(data);
   const tmpOutputFilename = getTemporaryFilename("output");
   const outputFilename = await encodeURLtoURL(tmpInputFilename, tmpOutputFilename, writer, options);
@@ -1502,27 +3418,25 @@ function getIterator2(data) {
   const dataIterator = [{ ...data, start: 0, end: data.length }];
   return dataIterator;
 }
-function getTemporaryFilename(filename) {
-  return `/tmp/${filename}`;
+function getTemporaryFilename(filename2) {
+  return `/tmp/${filename2}`;
 }
 
 // dist/lib/api/create-data-source.js
 function createDataSource(data, sources, options) {
   var _a;
-  const type = ((_a = options == null ? void 0 : options.core) == null ? void 0 : _a.type) || options.type || "auto";
-  const source = type === "auto" ? selectSource(data, sources) : getSourceOfType(type, sources);
+  const resolvedOptions = options || {};
+  const type = ((_a = resolvedOptions == null ? void 0 : resolvedOptions.core) == null ? void 0 : _a.type) || resolvedOptions.type || "auto";
+  const source = sources.length === 1 ? sources[0] : type === "auto" ? selectLoaderSync(data, sources, {
+    // `createDataSource` supports non-fetch inputs such as in-memory tables.
+    // Selection remains best-effort for those cases.
+    ...resolvedOptions,
+    core: { ...resolvedOptions == null ? void 0 : resolvedOptions.core, type: "auto" }
+  }) : getSourceOfType(type, sources);
   if (!source) {
     throw new Error("Not a valid source type");
   }
-  return source.createDataSource(data, options);
-}
-function selectSource(url, sources) {
-  for (const service of sources) {
-    if (service.testURL && service.testURL(url)) {
-      return service;
-    }
-  }
-  return null;
+  return source.createDataSource(data, resolvedOptions, coreApi);
 }
 function getSourceOfType(type, sources) {
   for (const service of sources) {
@@ -1534,15 +3448,11 @@ function getSourceOfType(type, sources) {
 }
 
 // dist/lib/api/select-source.js
-function selectSource2(url, sources, options) {
+function selectSource(url, sources, options) {
   const type = (options == null ? void 0 : options.type) || "auto";
   let selectedSource = null;
   if (type === "auto") {
-    for (const source of sources) {
-      if (typeof url === "string" && source.testURL && source.testURL(url)) {
-        return source;
-      }
-    }
+    selectedSource = selectLoaderSync(url, sources, { core: { nothrow: true } });
   } else {
     selectedSource = getSourceOfType2(type, sources);
   }
@@ -1560,10 +3470,6 @@ function getSourceOfType2(type, sources) {
   return null;
 }
 
-// dist/index.js
-var import_loader_utils20 = require("@loaders.gl/loader-utils");
-var import_loader_utils21 = require("@loaders.gl/loader-utils");
-
 // dist/iterators/make-stream/make-stream.js
 function makeStream(source, options) {
   if (globalThis.loaders.makeNodeStream) {
@@ -1604,14 +3510,14 @@ function makeStream(source, options) {
 }
 
 // dist/null-loader.js
-var VERSION = true ? "4.4.5" : "latest";
+var VERSION4 = true ? "5.0.0-alpha.2" : "latest";
 var NullWorkerLoader = {
   dataType: null,
   batchType: null,
   name: "Null loader",
   id: "null",
   module: "core",
-  version: VERSION,
+  version: VERSION4,
   worker: true,
   mimeTypes: ["application/x.empty"],
   extensions: ["null"],
@@ -1626,7 +3532,7 @@ var NullLoader = {
   name: "Null loader",
   id: "null",
   module: "core",
-  version: VERSION,
+  version: VERSION4,
   mimeTypes: ["application/x.empty"],
   extensions: ["null"],
   parse: async (arrayBuffer, options, context) => parseSync2(arrayBuffer, options || {}, context),
@@ -1645,9 +3551,6 @@ function parseSync2(arrayBuffer, options, context) {
   return null;
 }
 
-// dist/index.js
-var import_loader_utils22 = require("@loaders.gl/loader-utils");
-
 // dist/lib/progress/fetch-progress.js
 async function fetchProgress(response, onProgress, onDone = () => {
 }, onError = () => {
@@ -1696,7 +3599,6 @@ async function read(controller, reader, loadedBytes, totalBytes, onProgress, onD
 }
 
 // dist/lib/filesystems/browser-filesystem.js
-var import_loader_utils19 = require("@loaders.gl/loader-utils");
 var BrowserFileSystem = class {
   _fetch;
   files = {};
@@ -1722,13 +3624,13 @@ var BrowserFileSystem = class {
    * Implementation of fetch against this file system
    * Delegates to global fetch for http{s}:// or data://
    */
-  async fetch(path4, options) {
-    if (path4.includes("://")) {
-      return this._fetch(path4, options);
+  async fetch(path, options) {
+    if (path.includes("://")) {
+      return this._fetch(path, options);
     }
-    const file = this.files[path4];
+    const file = this.files[path];
     if (!file) {
-      return new Response(path4, { status: 400, statusText: "NOT FOUND" });
+      return new Response(path, { status: 400, statusText: "NOT FOUND" });
     }
     const headers = new Headers(options == null ? void 0 : options.headers);
     const range = headers.get("Range");
@@ -1738,11 +3640,11 @@ var BrowserFileSystem = class {
       const end = parseInt(bytes[2]);
       const data = await file.slice(start, end).arrayBuffer();
       const response2 = new Response(data);
-      Object.defineProperty(response2, "url", { value: path4 });
+      Object.defineProperty(response2, "url", { value: path });
       return response2;
     }
     const response = new Response(file);
-    Object.defineProperty(response, "url", { value: path4 });
+    Object.defineProperty(response, "url", { value: path });
     return response;
   }
   /**
@@ -1750,51 +3652,44 @@ var BrowserFileSystem = class {
    * @param dirname
    * @returns
    */
-  async readdir(dirname) {
+  async readdir(dirname2) {
     const files = [];
-    for (const path4 in this.files) {
-      files.push(path4);
+    for (const path in this.files) {
+      files.push(path);
     }
     return files;
   }
   /**
    * Return information (size) about files in this file system
    */
-  async stat(path4, options) {
-    const file = this.files[path4];
+  async stat(path, options) {
+    const file = this.files[path];
     if (!file) {
-      throw new Error(path4);
+      throw new Error(path);
     }
     return { size: file.size };
   }
   /**
    * Just removes the file from the list
    */
-  async unlink(path4) {
-    delete this.files[path4];
-    delete this.lowerCaseFiles[path4];
-    this.usedFiles[path4] = true;
+  async unlink(path) {
+    delete this.files[path];
+    delete this.lowerCaseFiles[path];
+    this.usedFiles[path] = true;
   }
   // implements IRandomAccessFileSystem
   // RANDOM ACCESS
   async openReadableFile(pathname, flags) {
-    return new import_loader_utils19.BlobFile(this.files[pathname]);
+    return new BlobFile(this.files[pathname]);
   }
   // PRIVATE
   // Supports case independent paths, and file usage tracking
-  _getFile(path4, used) {
-    const file = this.files[path4] || this.lowerCaseFiles[path4];
+  _getFile(path, used) {
+    const file = this.files[path] || this.lowerCaseFiles[path];
     if (file && used) {
-      this.usedFiles[path4] = true;
+      this.usedFiles[path] = true;
     }
     return file;
   }
 };
-
-// dist/index.js
-var import_loader_utils23 = require("@loaders.gl/loader-utils");
-var import_loader_utils24 = require("@loaders.gl/loader-utils");
-var import_loader_utils25 = require("@loaders.gl/loader-utils");
-var import_loader_utils26 = require("@loaders.gl/loader-utils");
-var import_loader_utils27 = require("@loaders.gl/loader-utils");
 //# sourceMappingURL=index.cjs.map