@loaders.gl/core 4.0.0-beta.2 → 4.0.0-beta.3

package/dist/{dist.min.js → dist.dev.js}

@@ -1,33 +1,87 @@
-(() => {
-  var __create = Object.create;
+(function webpackUniversalModuleDefinition(root, factory) {
+  if (typeof exports === 'object' && typeof module === 'object')
+    module.exports = factory();
+  else if (typeof define === 'function' && define.amd) define([], factory);
+        else if (typeof exports === 'object') exports['loader'] = factory();
+  else root['loader'] = factory();})(globalThis, function () {
+"use strict";
+var __exports__ = (() => {
   var __defProp = Object.defineProperty;
   var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
   var __getOwnPropNames = Object.getOwnPropertyNames;
-  var __getProtoOf = Object.getPrototypeOf;
   var __hasOwnProp = Object.prototype.hasOwnProperty;
-  var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
-  var __esm = (fn, res) => function __init() {
-    return fn && (res = (0, fn[Object.keys(fn)[0]])(fn = 0)), res;
-  };
-  var __commonJS = (cb, mod) => function __require() {
-    return mod || (0, cb[Object.keys(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
-  };
   var __export = (target, all) => {
-    __markAsModule(target);
     for (var name in all)
       __defProp(target, name, { get: all[name], enumerable: true });
   };
-  var __reExport = (target, module, desc) => {
-    if (module && typeof module === "object" || typeof module === "function") {
-      for (let key of __getOwnPropNames(module))
-        if (!__hasOwnProp.call(target, key) && key !== "default")
-          __defProp(target, key, { get: () => module[key], enumerable: !(desc = __getOwnPropDesc(module, key)) || desc.enumerable });
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
     }
-    return target;
-  };
-  var __toModule = (module) => {
-    return __reExport(__markAsModule(__defProp(module != null ? __create(__getProtoOf(module)) : {}, "default", module && module.__esModule && "default" in module ? { get: () => module.default, enumerable: true } : { value: module, enumerable: true })), module);
+    return to;
   };
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // src/index.ts
+  var src_exports = {};
+  __export(src_exports, {
+    JSONLoader: () => JSONLoader,
+    NullLoader: () => NullLoader,
+    NullWorkerLoader: () => NullWorkerLoader,
+    RequestScheduler: () => RequestScheduler,
+    _BrowserFileSystem: () => BrowserFileSystem,
+    _fetchProgress: () => fetchProgress,
+    _unregisterLoaders: () => _unregisterLoaders,
+    assert: () => assert,
+    concatenateArrayBuffersAsync: () => concatenateArrayBuffersAsync,
+    document: () => document_,
+    encode: () => encode,
+    encodeInBatches: () => encodeInBatches,
+    encodeSync: () => encodeSync,
+    encodeTable: () => encodeTable,
+    encodeTableAsText: () => encodeTableAsText,
+    encodeTableInBatches: () => encodeTableInBatches,
+    encodeText: () => encodeText,
+    encodeTextSync: () => encodeTextSync,
+    encodeURLtoURL: () => encodeURLtoURL,
+    fetchFile: () => fetchFile,
+    forEach: () => forEach,
+    getLoaderOptions: () => getGlobalLoaderOptions,
+    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: () => makeLineIterator,
+    makeNumberedLineIterator: () => makeNumberedLineIterator,
+    makeStream: () => makeStream,
+    makeTextDecoderIterator: () => makeTextDecoderIterator,
+    makeTextEncoderIterator: () => makeTextEncoderIterator,
+    parse: () => parse,
+    parseInBatches: () => parseInBatches,
+    parseSync: () => parseSync,
+    readArrayBuffer: () => readArrayBuffer,
+    registerLoaders: () => registerLoaders,
+    resolvePath: () => resolvePath,
+    selectLoader: () => selectLoader,
+    selectLoaderSync: () => selectLoaderSync,
+    self: () => self_,
+    setLoaderOptions: () => setGlobalOptions,
+    setPathPrefix: () => setPathPrefix,
+    window: () => window_
+  });
 
   // ../loader-utils/src/lib/env-utils/assert.ts
   function assert(condition, message) {
@@ -35,38 +89,34 @@
       throw new Error(message || "loader assertion failed.");
     }
   }
-  var init_assert = __esm({
-    "../loader-utils/src/lib/env-utils/assert.ts"() {
-    }
-  });
 
   // ../loader-utils/src/lib/env-utils/globals.ts
-  var globals, self_, window_, global_, document_, isBrowser, isWorker, matches, nodeVersion;
-  var init_globals = __esm({
-    "../loader-utils/src/lib/env-utils/globals.ts"() {
-      globals = {
-        self: typeof self !== "undefined" && self,
-        window: typeof window !== "undefined" && window,
-        global: typeof global !== "undefined" && global,
-        document: typeof document !== "undefined" && document
-      };
-      self_ = globals.self || globals.window || globals.global || {};
-      window_ = globals.window || globals.self || globals.global || {};
-      global_ = globals.global || globals.self || globals.window || {};
-      document_ = globals.document || {};
-      isBrowser = Boolean(typeof process !== "object" || String(process) !== "[object process]" || process.browser);
-      isWorker = typeof importScripts === "function";
-      matches = typeof process !== "undefined" && process.version && /v([0-9]*)/.exec(process.version);
-      nodeVersion = matches && parseFloat(matches[1]) || 0;
-    }
-  });
+  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/option-utils/merge-loader-options.ts
   function mergeLoaderOptions(baseOptions, newOptions) {
     return mergeOptionsRecursively(baseOptions || {}, newOptions);
   }
   function mergeOptionsRecursively(baseOptions, newOptions) {
-    const options = { ...baseOptions };
+    const options = {
+      ...baseOptions
+    };
     for (const [key, newValue] of Object.entries(newOptions)) {
       if (newValue && typeof newValue === "object" && !Array.isArray(newValue)) {
         options[key] = mergeOptionsRecursively(options[key] || {}, newOptions[key]);
@@ -76,12 +126,9 @@
     }
     return options;
   }
-  var init_merge_loader_options = __esm({
-    "../loader-utils/src/lib/option-utils/merge-loader-options.ts"() {
-    }
-  });
 
   // ../worker-utils/src/lib/env-utils/version.ts
+  var NPM_TAG = "beta";
   function getVersion() {
     if (!globalThis._loadersgl_?.version) {
       globalThis._loadersgl_ = globalThis._loadersgl_ || {};
@@ -94,13 +141,7 @@
     }
     return globalThis._loadersgl_.version;
   }
-  var NPM_TAG, VERSION;
-  var init_version = __esm({
-    "../worker-utils/src/lib/env-utils/version.ts"() {
-      NPM_TAG = "beta";
-      VERSION = getVersion();
-    }
-  });
+  var VERSION = getVersion();
 
   // ../worker-utils/src/lib/env-utils/assert.ts
   function assert2(condition, message) {
@@ -108,84 +149,80 @@
       throw new Error(message || "loaders.gl assertion failed.");
     }
   }
-  var init_assert2 = __esm({
-    "../worker-utils/src/lib/env-utils/assert.ts"() {
-    }
-  });
 
   // ../worker-utils/src/lib/env-utils/globals.ts
-  var globals2, self_2, window_2, global_2, document_2, isBrowser2, isMobile, matches2, nodeVersion2;
-  var init_globals2 = __esm({
-    "../worker-utils/src/lib/env-utils/globals.ts"() {
-      globals2 = {
-        self: typeof self !== "undefined" && self,
-        window: typeof window !== "undefined" && window,
-        global: typeof global !== "undefined" && global,
-        document: typeof document !== "undefined" && document
-      };
-      self_2 = globals2.self || globals2.window || globals2.global || {};
-      window_2 = globals2.window || globals2.self || globals2.global || {};
-      global_2 = globals2.global || globals2.self || globals2.window || {};
-      document_2 = globals2.document || {};
-      isBrowser2 = typeof process !== "object" || String(process) !== "[object process]" || process.browser;
-      isMobile = typeof window !== "undefined" && typeof window.orientation !== "undefined";
-      matches2 = typeof process !== "undefined" && process.version && /v([0-9]*)/.exec(process.version);
-      nodeVersion2 = matches2 && parseFloat(matches2[1]) || 0;
-    }
-  });
+  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;
-  var init_worker_job = __esm({
-    "../worker-utils/src/lib/worker-farm/worker-job.ts"() {
-      init_assert2();
-      WorkerJob = class {
-        constructor(jobName, workerThread) {
-          this.isRunning = true;
-          this._resolve = () => {
-          };
-          this._reject = () => {
-          };
-          this.name = jobName;
-          this.workerThread = workerThread;
-          this.result = new Promise((resolve2, reject) => {
-            this._resolve = resolve2;
-            this._reject = reject;
-          });
-        }
-        postMessage(type, payload) {
-          this.workerThread.postMessage({
-            source: "loaders.gl",
-            type,
-            payload
-          });
-        }
-        done(value) {
-          assert2(this.isRunning);
-          this.isRunning = false;
-          this._resolve(value);
-        }
-        error(error) {
-          assert2(this.isRunning);
-          this.isRunning = false;
-          this._reject(error);
-        }
-      };
+  var WorkerJob = class {
+    isRunning = true;
+    /** Promise that resolves when Job is done */
+    _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) {
+      assert2(this.isRunning);
+      this.isRunning = false;
+      this._resolve(value);
+    }
+    /**
+     * Call to reject the `result` Promise with the supplied error
+     */
+    error(error) {
+      assert2(this.isRunning);
+      this.isRunning = false;
+      this._reject(error);
+    }
+  };
 
   // ../worker-utils/src/lib/node/worker_threads-browser.ts
-  var Worker2;
-  var init_worker_threads_browser = __esm({
-    "../worker-utils/src/lib/node/worker_threads-browser.ts"() {
-      Worker2 = class {
-        terminate() {
-        }
-      };
+  var Worker2 = class {
+    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);
@@ -210,7 +247,9 @@
     return getLoadableWorkerURLFromSource(workerSource);
   }
   function getLoadableWorkerURLFromSource(workerSource) {
-    const blob = new Blob([workerSource], { type: "application/javascript" });
+    const blob = new Blob([workerSource], {
+      type: "application/javascript"
+    });
     return URL.createObjectURL(blob);
   }
   function buildScriptSource(workerUrl) {
@@ -221,17 +260,10 @@
   throw error;
 }`;
   }
-  var workerURLCache;
-  var init_get_loadable_worker_url = __esm({
-    "../worker-utils/src/lib/worker-utils/get-loadable-worker-url.ts"() {
-      init_assert2();
-      workerURLCache = new Map();
-    }
-  });
 
   // ../worker-utils/src/lib/worker-utils/get-transfer-list.ts
   function getTransferList(object, recursive = true, transfers) {
-    const transfersSet = transfers || new Set();
+    const transfersSet = transfers || /* @__PURE__ */ new Set();
     if (!object) {
     } else if (isTransferable(object)) {
       transfersSet.add(object);
@@ -279,283 +311,366 @@
     });
     return clone;
   }
-  var init_get_transfer_list = __esm({
-    "../worker-utils/src/lib/worker-utils/get-transfer-list.ts"() {
-    }
-  });
 
   // ../worker-utils/src/lib/worker-farm/worker-thread.ts
-  var NOOP, WorkerThread;
-  var init_worker_thread = __esm({
-    "../worker-utils/src/lib/worker-farm/worker-thread.ts"() {
-      init_worker_threads_browser();
-      init_globals2();
-      init_assert2();
-      init_get_loadable_worker_url();
-      init_get_transfer_list();
-      NOOP = () => {
-      };
-      WorkerThread = class {
-        constructor(props) {
-          this.terminated = false;
-          this._loadableURL = "";
-          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();
-        }
-        static isSupported() {
-          return typeof Worker !== "undefined" && isBrowser2 || typeof Worker2 !== "undefined" && !isBrowser2;
-        }
-        destroy() {
-          this.onMessage = NOOP;
-          this.onError = NOOP;
-          this.worker.terminate();
-          this.terminated = true;
-        }
-        get isRunning() {
-          return Boolean(this.onMessage);
-        }
-        postMessage(data, transferList) {
-          transferList = transferList || getTransferList(data);
-          this.worker.postMessage(data, transferList);
-        }
-        _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);
-        }
-        _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;
-        }
-        _createNodeWorker() {
-          let worker;
-          if (this.url) {
-            const absolute = this.url.includes(":/") || this.url.startsWith("/");
-            const url = absolute ? this.url : `./${this.url}`;
-            worker = new Worker2(url, { eval: false });
-          } else if (this.source) {
-            worker = new Worker2(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;
+  var NOOP = () => {
+  };
+  var WorkerThread = class {
+    terminated = false;
+    _loadableURL = "";
+    /** Checks if workers are supported on this platform */
+    static isSupported() {
+      return typeof Worker !== "undefined" && isBrowser2 || typeof Worker2 !== "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;
+    }
+    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}`;
+        worker = new Worker2(url, {
+          eval: false
+        });
+      } else if (this.source) {
+        worker = new Worker2(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;
-  var init_worker_pool = __esm({
-    "../worker-utils/src/lib/worker-farm/worker-pool.ts"() {
-      init_globals2();
-      init_worker_thread();
-      init_worker_job();
-      WorkerPool = class {
-        constructor(props) {
-          this.name = "unnamed";
-          this.maxConcurrency = 1;
-          this.maxMobileConcurrency = 1;
-          this.onDebug = () => {
-          };
-          this.reuseWorkers = true;
-          this.props = {};
-          this.jobQueue = [];
-          this.idleQueue = [];
-          this.count = 0;
-          this.isDestroyed = false;
-          this.source = props.source;
-          this.url = props.url;
-          this.setProps(props);
-        }
-        static isSupported() {
-          return WorkerThread.isSupported();
-        }
-        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, onMessage3 = (job, type, data) => job.done(data), onError = (job, error) => job.error(error)) {
-          const startPromise = new Promise((onStart) => {
-            this.jobQueue.push({ name, onMessage: onMessage3, onError, onStart });
-            return this;
-          });
-          this._startQueuedJob();
-          return await startPromise;
-        }
-        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.onMessage = (data) => queuedJob.onMessage(job, data.type, data.payload);
-            workerThread.onError = (error) => queuedJob.onError(job, error);
-            queuedJob.onStart(job);
-            try {
-              await job.result;
-            } finally {
-              this.returnWorkerToQueue(workerThread);
-            }
-          }
-        }
-        returnWorkerToQueue(worker) {
-          const shouldDestroyWorker = !isBrowser2 || this.isDestroyed || !this.reuseWorkers || this.count > this._getMaxConcurrency();
-          if (shouldDestroyWorker) {
-            worker.destroy();
-            this.count--;
-          } else {
-            this.idleQueue.push(worker);
-          }
-          if (!this.isDestroyed) {
-            this._startQueuedJob();
-          }
-        }
-        _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;
-        }
+  var WorkerPool = class {
+    name = "unnamed";
+    // | Function;
+    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, onMessage3 = (job, type, data) => job.done(data), onError = (job, error) => job.error(error)) {
+      const startPromise = new Promise((onStart) => {
+        this.jobQueue.push({
+          name,
+          onMessage: onMessage3,
+          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.onMessage = (data) => queuedJob.onMessage(job, data.type, data.payload);
+        workerThread.onError = (error) => queuedJob.onError(job, error);
+        queuedJob.onStart(job);
+        try {
+          await job.result;
+        } catch (error) {
+          console.error(`Worker exception: ${error}`);
+        } 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 = (
+        // Workers on Node.js prevent the process from exiting.
+        // Until we figure out how to close them before exit, we always destroy them
+        !isBrowser2 || // If the pool is destroyed, there is no reason to keep the worker around
+        this.isDestroyed || // If the app has disabled worker reuse, any completed workers should be destroyed
+        !this.reuseWorkers || // If concurrency has been lowered, this worker might be surplus to requirements
+        this.count > this._getMaxConcurrency()
+      );
+      if (shouldDestroyWorker) {
+        worker.destroy();
+        this.count--;
+      } else {
+        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, WorkerFarm;
-  var init_worker_farm = __esm({
-    "../worker-utils/src/lib/worker-farm/worker-farm.ts"() {
-      init_worker_pool();
-      init_worker_thread();
-      DEFAULT_PROPS = {
-        maxConcurrency: 3,
-        maxMobileConcurrency: 1,
-        reuseWorkers: true,
-        onDebug: () => {
-        }
+  var DEFAULT_PROPS = {
+    maxConcurrency: 3,
+    maxMobileConcurrency: 1,
+    reuseWorkers: true,
+    onDebug: () => {
+    }
+  };
+  var WorkerFarm = class {
+    workerPools = /* @__PURE__ */ new Map();
+    // singleton
+    /** 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
       };
-      WorkerFarm = class {
-        constructor(props) {
-          this.workerPools = new Map();
-          this.props = { ...DEFAULT_PROPS };
-          this.setProps(props);
-          this.workerPools = new Map();
-        }
-        static isSupported() {
-          return WorkerThread.isSupported();
-        }
-        static getWorkerFarm(props = {}) {
-          WorkerFarm._workerFarm = WorkerFarm._workerFarm || new WorkerFarm({});
-          WorkerFarm._workerFarm.setProps(props);
-          return WorkerFarm._workerFarm;
-        }
-        destroy() {
-          for (const workerPool of this.workerPools.values()) {
-            workerPool.destroy();
-          }
-          this.workerPools = new Map();
-        }
-        setProps(props) {
-          this.props = { ...this.props, ...props };
-          for (const workerPool of this.workerPools.values()) {
-            workerPool.setProps(this._getWorkerPoolProps());
-          }
-        }
-        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
-          };
-        }
+      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
   function getWorkerName(worker) {
@@ -583,28 +698,33 @@
     assert2(url);
     return url;
   }
-  var init_get_worker_url = __esm({
-    "../worker-utils/src/lib/worker-api/get-worker-url.ts"() {
-      init_assert2();
-      init_globals2();
-      init_version();
-    }
-  });
 
   // ../worker-utils/src/lib/worker-api/process-on-worker.ts
   async function processOnWorker(worker, data, options = {}, context = {}) {
     const name = getWorkerName(worker);
     const workerFarm = WorkerFarm.getWorkerFarm(options);
-    const { source } = options;
-    const workerPoolProps = { name, source };
+    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, onMessage.bind(null, context));
+    const job = await workerPool.startJob(
+      jobName,
+      // eslint-disable-next-line
+      onMessage.bind(null, context)
+    );
     const transferableOptions = getTransferListForWriter(options);
-    job.postMessage("process", { input: data, options: transferableOptions });
+    job.postMessage("process", {
+      input: data,
+      options: transferableOptions
+    });
     const result = await job.result;
     return result.result;
   }
@@ -617,30 +737,36 @@
         job.error(new Error(payload.error));
         break;
       case "process":
-        const { id, input, options } = payload;
+        const {
+          id,
+          input,
+          options
+        } = payload;
         try {
           if (!context.process) {
-            job.postMessage("error", { id, error: "Worker not set up to process on main thread" });
+            job.postMessage("error", {
+              id,
+              error: "Worker not set up to process on main thread"
+            });
             return;
           }
           const result = await context.process(input, options);
-          job.postMessage("done", { id, result });
+          job.postMessage("done", {
+            id,
+            result
+          });
         } catch (error) {
           const message = error instanceof Error ? error.message : "unknown error";
-          job.postMessage("error", { id, error: message });
+          job.postMessage("error", {
+            id,
+            error: message
+          });
         }
         break;
       default:
         console.warn(`process-on-worker: unknown message ${type}`);
     }
   }
-  var init_process_on_worker = __esm({
-    "../worker-utils/src/lib/worker-api/process-on-worker.ts"() {
-      init_worker_farm();
-      init_get_worker_url();
-      init_get_transfer_list();
-    }
-  });
 
   // ../worker-utils/src/lib/worker-api/validate-worker-version.ts
   function validateWorkerVersion(worker, coreVersion = VERSION) {
@@ -651,24 +777,6 @@
     }
     return true;
   }
-  var init_validate_worker_version = __esm({
-    "../worker-utils/src/lib/worker-api/validate-worker-version.ts"() {
-      init_assert2();
-      init_version();
-    }
-  });
-
-  // ../worker-utils/src/index.ts
-  var init_src = __esm({
-    "../worker-utils/src/index.ts"() {
-      init_assert2();
-      init_globals2();
-      init_worker_farm();
-      init_process_on_worker();
-      init_get_worker_url();
-      init_validate_worker_version();
-    }
-  });
 
   // ../loader-utils/src/lib/worker-loader-utils/parse-with-worker.ts
   function canParseWithWorker(loader, options) {
@@ -684,11 +792,20 @@
     const name = loader.id;
     const url = getWorkerURL(loader, options);
     const workerFarm = WorkerFarm.getWorkerFarm(options);
-    const workerPool = workerFarm.getWorkerPool({ name, url });
+    const workerPool = workerFarm.getWorkerPool({
+      name,
+      url
+    });
     options = JSON.parse(JSON.stringify(options));
     context = JSON.parse(JSON.stringify(context || {}));
-    const job = await workerPool.startJob("process-on-worker", onMessage2.bind(null, parseOnMainThread));
+    const job = await workerPool.startJob(
+      "process-on-worker",
+      // @ts-expect-error
+      onMessage2.bind(null, parseOnMainThread)
+      // eslint-disable-line @typescript-eslint/no-misused-promises
+    );
     job.postMessage("process", {
+      // @ts-ignore
       input: data,
       options,
       context
@@ -705,25 +822,29 @@
         job.error(new Error(payload.error));
         break;
       case "process":
-        const { id, input, options } = payload;
+        const {
+          id,
+          input,
+          options
+        } = payload;
         try {
           const result = await parseOnMainThread(input, options);
-          job.postMessage("done", { id, result });
+          job.postMessage("done", {
+            id,
+            result
+          });
         } catch (error) {
           const message = error instanceof Error ? error.message : "unknown error";
-          job.postMessage("error", { id, error: message });
+          job.postMessage("error", {
+            id,
+            error: message
+          });
         }
         break;
       default:
         console.warn(`parse-with-worker unknown message ${type}`);
     }
   }
-  var init_parse_with_worker = __esm({
-    "../loader-utils/src/lib/worker-loader-utils/parse-with-worker.ts"() {
-      init_src();
-      init_src();
-    }
-  });
 
   // ../loader-utils/src/lib/worker-loader-utils/encode-with-worker.ts
   function canEncodeWithWorker(writer, options) {
@@ -735,12 +856,6 @@
     }
     return writer.worker && options?.worker;
   }
-  var init_encode_with_worker = __esm({
-    "../loader-utils/src/lib/worker-loader-utils/encode-with-worker.ts"() {
-      init_src();
-      init_globals();
-    }
-  });
 
   // ../loader-utils/src/lib/binary-utils/array-buffer-utils.ts
   function compareArrayBuffers(arrayBuffer1, arrayBuffer2, byteLength) {
@@ -768,16 +883,14 @@
     }
     return result.buffer;
   }
-  var init_array_buffer_utils = __esm({
-    "../loader-utils/src/lib/binary-utils/array-buffer-utils.ts"() {
-    }
-  });
 
   // ../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 });
+      yield typeof arrayBuffer === "string" ? arrayBuffer : textDecoder.decode(arrayBuffer, {
+        stream: true
+      });
     }
   }
   async function* makeTextEncoderIterator(textIterator) {
@@ -804,19 +917,21 @@
   async function* makeNumberedLineIterator(lineIterator) {
     let counter = 1;
     for await (const line of lineIterator) {
-      yield { counter, line };
+      yield {
+        counter,
+        line
+      };
       counter++;
     }
   }
-  var init_text_iterators = __esm({
-    "../loader-utils/src/lib/iterators/text-iterators.ts"() {
-    }
-  });
 
   // ../loader-utils/src/lib/iterators/async-iteration.ts
   async function forEach(iterator, visitor) {
     while (true) {
-      const { done, value } = await iterator.next();
+      const {
+        done,
+        value
+      } = await iterator.next();
       if (done) {
         iterator.return();
         return;
@@ -834,25 +949,16 @@
     }
     return concatenateArrayBuffers(...arrayBuffers);
   }
-  var init_async_iteration = __esm({
-    "../loader-utils/src/lib/iterators/async-iteration.ts"() {
-      init_array_buffer_utils();
-    }
-  });
 
   // ../../node_modules/@babel/runtime/helpers/esm/typeof.js
   function _typeof(obj) {
     "@babel/helpers - typeof";
-    return _typeof = typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? function(obj2) {
+    return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(obj2) {
       return typeof obj2;
     } : function(obj2) {
-      return obj2 && typeof Symbol == "function" && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
+      return obj2 && "function" == typeof Symbol && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
     }, _typeof(obj);
   }
-  var init_typeof = __esm({
-    "../../node_modules/@babel/runtime/helpers/esm/typeof.js"() {
-    }
-  });
 
   // ../../node_modules/@babel/runtime/helpers/esm/toPrimitive.js
   function _toPrimitive(input, hint) {
@@ -867,23 +973,12 @@
     }
     return (hint === "string" ? String : Number)(input);
   }
-  var init_toPrimitive = __esm({
-    "../../node_modules/@babel/runtime/helpers/esm/toPrimitive.js"() {
-      init_typeof();
-    }
-  });
 
   // ../../node_modules/@babel/runtime/helpers/esm/toPropertyKey.js
   function _toPropertyKey(arg) {
     var key = _toPrimitive(arg, "string");
     return _typeof(key) === "symbol" ? key : String(key);
   }
-  var init_toPropertyKey = __esm({
-    "../../node_modules/@babel/runtime/helpers/esm/toPropertyKey.js"() {
-      init_typeof();
-      init_toPrimitive();
-    }
-  });
 
   // ../../node_modules/@babel/runtime/helpers/esm/defineProperty.js
   function _defineProperty(obj, key, value) {
@@ -900,11 +995,6 @@
     }
     return obj;
   }
-  var init_defineProperty = __esm({
-    "../../node_modules/@babel/runtime/helpers/esm/defineProperty.js"() {
-      init_toPropertyKey();
-    }
-  });
 
   // ../loader-utils/node_modules/@probe.gl/stats/dist/utils/hi-res-timestamp.js
   function getHiResTimestamp() {
@@ -919,316 +1009,327 @@
     }
     return timestamp;
   }
-  var init_hi_res_timestamp = __esm({
-    "../loader-utils/node_modules/@probe.gl/stats/dist/utils/hi-res-timestamp.js"() {
-    }
-  });
 
   // ../loader-utils/node_modules/@probe.gl/stats/dist/lib/stat.js
-  var Stat;
-  var init_stat = __esm({
-    "../loader-utils/node_modules/@probe.gl/stats/dist/lib/stat.js"() {
-      init_defineProperty();
-      init_hi_res_timestamp();
-      Stat = class {
-        constructor(name, type) {
-          _defineProperty(this, "name", void 0);
-          _defineProperty(this, "type", void 0);
-          _defineProperty(this, "sampleSize", 1);
-          _defineProperty(this, "time", 0);
-          _defineProperty(this, "count", 0);
-          _defineProperty(this, "samples", 0);
-          _defineProperty(this, "lastTiming", 0);
-          _defineProperty(this, "lastSampleTime", 0);
-          _defineProperty(this, "lastSampleCount", 0);
-          _defineProperty(this, "_count", 0);
-          _defineProperty(this, "_time", 0);
-          _defineProperty(this, "_samples", 0);
-          _defineProperty(this, "_startTime", 0);
-          _defineProperty(this, "_timerPending", false);
-          this.name = name;
-          this.type = type;
-          this.reset();
-        }
-        reset() {
-          this.time = 0;
-          this.count = 0;
-          this.samples = 0;
-          this.lastTiming = 0;
-          this.lastSampleTime = 0;
-          this.lastSampleCount = 0;
-          this._count = 0;
-          this._time = 0;
-          this._samples = 0;
-          this._startTime = 0;
-          this._timerPending = false;
-          return this;
-        }
-        setSampleSize(samples) {
-          this.sampleSize = samples;
-          return this;
-        }
-        incrementCount() {
-          this.addCount(1);
-          return this;
-        }
-        decrementCount() {
-          this.subtractCount(1);
-          return this;
-        }
-        addCount(value) {
-          this._count += value;
-          this._samples++;
-          this._checkSampling();
-          return this;
-        }
-        subtractCount(value) {
-          this._count -= value;
-          this._samples++;
-          this._checkSampling();
-          return this;
-        }
-        addTime(time) {
-          this._time += time;
-          this.lastTiming = time;
-          this._samples++;
-          this._checkSampling();
-          return this;
-        }
-        timeStart() {
-          this._startTime = getHiResTimestamp();
-          this._timerPending = true;
-          return this;
-        }
-        timeEnd() {
-          if (!this._timerPending) {
-            return this;
-          }
-          this.addTime(getHiResTimestamp() - this._startTime);
-          this._timerPending = false;
-          this._checkSampling();
-          return this;
-        }
-        getSampleAverageCount() {
-          return this.sampleSize > 0 ? this.lastSampleCount / this.sampleSize : 0;
-        }
-        getSampleAverageTime() {
-          return this.sampleSize > 0 ? this.lastSampleTime / this.sampleSize : 0;
-        }
-        getSampleHz() {
-          return this.lastSampleTime > 0 ? this.sampleSize / (this.lastSampleTime / 1e3) : 0;
-        }
-        getAverageCount() {
-          return this.samples > 0 ? this.count / this.samples : 0;
-        }
-        getAverageTime() {
-          return this.samples > 0 ? this.time / this.samples : 0;
-        }
-        getHz() {
-          return this.time > 0 ? this.samples / (this.time / 1e3) : 0;
-        }
-        _checkSampling() {
-          if (this._samples === this.sampleSize) {
-            this.lastSampleTime = this._time;
-            this.lastSampleCount = this._count;
-            this.count += this._count;
-            this.time += this._time;
-            this.samples += this._samples;
-            this._time = 0;
-            this._count = 0;
-            this._samples = 0;
-          }
-        }
-      };
+  var Stat = class {
+    constructor(name, type) {
+      _defineProperty(this, "name", void 0);
+      _defineProperty(this, "type", void 0);
+      _defineProperty(this, "sampleSize", 1);
+      _defineProperty(this, "time", 0);
+      _defineProperty(this, "count", 0);
+      _defineProperty(this, "samples", 0);
+      _defineProperty(this, "lastTiming", 0);
+      _defineProperty(this, "lastSampleTime", 0);
+      _defineProperty(this, "lastSampleCount", 0);
+      _defineProperty(this, "_count", 0);
+      _defineProperty(this, "_time", 0);
+      _defineProperty(this, "_samples", 0);
+      _defineProperty(this, "_startTime", 0);
+      _defineProperty(this, "_timerPending", false);
+      this.name = name;
+      this.type = type;
+      this.reset();
+    }
+    reset() {
+      this.time = 0;
+      this.count = 0;
+      this.samples = 0;
+      this.lastTiming = 0;
+      this.lastSampleTime = 0;
+      this.lastSampleCount = 0;
+      this._count = 0;
+      this._time = 0;
+      this._samples = 0;
+      this._startTime = 0;
+      this._timerPending = false;
+      return this;
+    }
+    setSampleSize(samples) {
+      this.sampleSize = samples;
+      return this;
+    }
+    incrementCount() {
+      this.addCount(1);
+      return this;
+    }
+    decrementCount() {
+      this.subtractCount(1);
+      return this;
+    }
+    addCount(value) {
+      this._count += value;
+      this._samples++;
+      this._checkSampling();
+      return this;
+    }
+    subtractCount(value) {
+      this._count -= value;
+      this._samples++;
+      this._checkSampling();
+      return this;
+    }
+    addTime(time) {
+      this._time += time;
+      this.lastTiming = time;
+      this._samples++;
+      this._checkSampling();
+      return this;
+    }
+    timeStart() {
+      this._startTime = getHiResTimestamp();
+      this._timerPending = true;
+      return this;
+    }
+    timeEnd() {
+      if (!this._timerPending) {
+        return this;
+      }
+      this.addTime(getHiResTimestamp() - this._startTime);
+      this._timerPending = false;
+      this._checkSampling();
+      return this;
+    }
+    getSampleAverageCount() {
+      return this.sampleSize > 0 ? this.lastSampleCount / this.sampleSize : 0;
+    }
+    getSampleAverageTime() {
+      return this.sampleSize > 0 ? this.lastSampleTime / this.sampleSize : 0;
+    }
+    getSampleHz() {
+      return this.lastSampleTime > 0 ? this.sampleSize / (this.lastSampleTime / 1e3) : 0;
+    }
+    getAverageCount() {
+      return this.samples > 0 ? this.count / this.samples : 0;
+    }
+    getAverageTime() {
+      return this.samples > 0 ? this.time / this.samples : 0;
+    }
+    getHz() {
+      return this.time > 0 ? this.samples / (this.time / 1e3) : 0;
+    }
+    _checkSampling() {
+      if (this._samples === this.sampleSize) {
+        this.lastSampleTime = this._time;
+        this.lastSampleCount = this._count;
+        this.count += this._count;
+        this.time += this._time;
+        this.samples += this._samples;
+        this._time = 0;
+        this._count = 0;
+        this._samples = 0;
+      }
     }
-  });
+  };
 
   // ../loader-utils/node_modules/@probe.gl/stats/dist/lib/stats.js
-  var Stats;
-  var init_stats = __esm({
-    "../loader-utils/node_modules/@probe.gl/stats/dist/lib/stats.js"() {
-      init_defineProperty();
-      init_stat();
-      Stats = class {
-        constructor(options) {
-          _defineProperty(this, "id", void 0);
-          _defineProperty(this, "stats", {});
-          this.id = options.id;
-          this.stats = {};
-          this._initializeStats(options.stats);
-          Object.seal(this);
-        }
-        get(name) {
-          let type = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "count";
-          return this._getOrCreate({
-            name,
-            type
-          });
-        }
-        get size() {
-          return Object.keys(this.stats).length;
-        }
-        reset() {
-          for (const stat of Object.values(this.stats)) {
-            stat.reset();
-          }
-          return this;
-        }
-        forEach(fn) {
-          for (const stat of Object.values(this.stats)) {
-            fn(stat);
-          }
-        }
-        getTable() {
-          const table = {};
-          this.forEach((stat) => {
-            table[stat.name] = {
-              time: stat.time || 0,
-              count: stat.count || 0,
-              average: stat.getAverageTime() || 0,
-              hz: stat.getHz() || 0
-            };
-          });
-          return table;
-        }
-        _initializeStats() {
-          let stats = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : [];
-          stats.forEach((stat) => this._getOrCreate(stat));
-        }
-        _getOrCreate(stat) {
-          const {
-            name,
-            type
-          } = stat;
-          let result = this.stats[name];
-          if (!result) {
-            if (stat instanceof Stat) {
-              result = stat;
-            } else {
-              result = new Stat(name, type);
-            }
-            this.stats[name] = result;
-          }
-          return result;
-        }
-      };
+  var Stats = class {
+    constructor(options) {
+      _defineProperty(this, "id", void 0);
+      _defineProperty(this, "stats", {});
+      this.id = options.id;
+      this.stats = {};
+      this._initializeStats(options.stats);
+      Object.seal(this);
+    }
+    get(name) {
+      let type = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "count";
+      return this._getOrCreate({
+        name,
+        type
+      });
     }
-  });
-
-  // ../loader-utils/node_modules/@probe.gl/stats/dist/index.js
-  var init_dist = __esm({
-    "../loader-utils/node_modules/@probe.gl/stats/dist/index.js"() {
-      init_stats();
-      init_stat();
-      init_hi_res_timestamp();
+    get size() {
+      return Object.keys(this.stats).length;
     }
-  });
+    reset() {
+      for (const stat of Object.values(this.stats)) {
+        stat.reset();
+      }
+      return this;
+    }
+    forEach(fn) {
+      for (const stat of Object.values(this.stats)) {
+        fn(stat);
+      }
+    }
+    getTable() {
+      const table = {};
+      this.forEach((stat) => {
+        table[stat.name] = {
+          time: stat.time || 0,
+          count: stat.count || 0,
+          average: stat.getAverageTime() || 0,
+          hz: stat.getHz() || 0
+        };
+      });
+      return table;
+    }
+    _initializeStats() {
+      let stats = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : [];
+      stats.forEach((stat) => this._getOrCreate(stat));
+    }
+    _getOrCreate(stat) {
+      const {
+        name,
+        type
+      } = stat;
+      let result = this.stats[name];
+      if (!result) {
+        if (stat instanceof Stat) {
+          result = stat;
+        } else {
+          result = new Stat(name, type);
+        }
+        this.stats[name] = result;
+      }
+      return result;
+    }
+  };
 
   // ../loader-utils/src/lib/request-utils/request-scheduler.ts
-  var STAT_QUEUED_REQUESTS, STAT_ACTIVE_REQUESTS, STAT_CANCELLED_REQUESTS, STAT_QUEUED_REQUESTS_EVER, STAT_ACTIVE_REQUESTS_EVER, DEFAULT_PROPS2, RequestScheduler;
-  var init_request_scheduler = __esm({
-    "../loader-utils/src/lib/request-utils/request-scheduler.ts"() {
-      init_dist();
-      STAT_QUEUED_REQUESTS = "Queued Requests";
-      STAT_ACTIVE_REQUESTS = "Active Requests";
-      STAT_CANCELLED_REQUESTS = "Cancelled Requests";
-      STAT_QUEUED_REQUESTS_EVER = "Queued Requests Ever";
-      STAT_ACTIVE_REQUESTS_EVER = "Active Requests Ever";
-      DEFAULT_PROPS2 = {
-        id: "request-scheduler",
-        throttleRequests: true,
-        maxRequests: 6
+  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
+  };
+  var RequestScheduler = class {
+    activeRequestCount = 0;
+    /** Tracks the number of active requests and prioritizes/cancels queued requests. */
+    requestQueue = [];
+    requestMap = /* @__PURE__ */ new Map();
+    deferredUpdate = null;
+    constructor(props = {}) {
+      this.props = {
+        ...DEFAULT_PROPS2,
+        ...props
       };
-      RequestScheduler = class {
-        constructor(props = {}) {
-          this.activeRequestCount = 0;
-          this.requestQueue = [];
-          this.requestMap = new Map();
-          this.deferredUpdate = null;
-          this.props = { ...DEFAULT_PROPS2, ...props };
-          this.stats = new 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);
-        }
-        scheduleRequest(handle, getPriority = () => 0) {
-          if (!this.props.throttleRequests) {
-            return Promise.resolve({ done: () => {
-            } });
-          }
-          if (this.requestMap.has(handle)) {
-            return this.requestMap.get(handle);
+      this.stats = new 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);
+    }
+    /**
+     * 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: () => {
           }
-          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);
+        });
+      }
+      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();
-          return promise;
-        }
-        _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 });
-        }
-        _issueNewRequests() {
-          if (!this.deferredUpdate) {
-            this.deferredUpdate = setTimeout(() => this._issueNewRequestsAsync(), 0);
-          }
-        }
-        _issueNewRequestsAsync() {
-          this.deferredUpdate = 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);
-            }
-          }
         }
-        _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);
+      };
+      this.activeRequestCount++;
+      return resolve2 ? resolve2({
+        done
+      }) : Promise.resolve({
+        done
+      });
+    }
+    /** We check requests asynchronously, to prevent multiple updates */
+    _issueNewRequests() {
+      if (!this.deferredUpdate) {
+        this.deferredUpdate = setTimeout(() => this._issueNewRequestsAsync(), 0);
+      }
+    }
+    /** Refresh all requests  */
+    _issueNewRequestsAsync() {
+      this.deferredUpdate = 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);
         }
-        _updateRequest(request) {
-          request.priority = request.getPriority(request.handle);
-          if (request.priority < 0) {
-            request.resolve(null);
-            return false;
-          }
-          return true;
+      }
+    }
+    /** 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;
   }
@@ -1247,57 +1348,35 @@
     }
     return filename2;
   }
-  var pathPrefix, fileAliases;
-  var init_file_aliases = __esm({
-    "../loader-utils/src/lib/path-utils/file-aliases.ts"() {
-      pathPrefix = "";
-      fileAliases = {};
-    }
-  });
 
   // ../loader-utils/src/json-loader.ts
+  var VERSION2 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+  var JSONLoader = {
+    name: "JSON",
+    id: "json",
+    module: "json",
+    version: VERSION2,
+    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);
   }
-  var VERSION2, JSONLoader;
-  var init_json_loader = __esm({
-    "../loader-utils/src/json-loader.ts"() {
-      VERSION2 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
-      JSONLoader = {
-        name: "JSON",
-        id: "json",
-        module: "json",
-        version: VERSION2,
-        extensions: ["json", "geojson"],
-        mimeTypes: ["application/json"],
-        category: "json",
-        text: true,
-        parseTextSync,
-        parse: async (arrayBuffer) => parseTextSync(new TextDecoder().decode(arrayBuffer)),
-        options: {}
-      };
-    }
-  });
 
   // ../loader-utils/src/lib/node/buffer.browser.ts
   function toArrayBuffer(buffer) {
     return buffer;
-  }
-  function toBuffer(binaryData) {
-    throw new Error("Buffer not supported in browser");
-  }
-  var init_buffer_browser = __esm({
-    "../loader-utils/src/lib/node/buffer.browser.ts"() {
-    }
-  });
+  }
 
   // ../loader-utils/src/lib/binary-utils/memory-conversion-utils.ts
   function isBuffer(value) {
     return value && typeof value === "object" && value.isBuffer;
   }
-  function toBuffer2(data) {
-    return toBuffer ? toBuffer(data) : data;
-  }
   function toArrayBuffer2(data) {
     if (isBuffer(data)) {
       return toArrayBuffer(data);
@@ -1321,10 +1400,14 @@
     }
     throw new Error("toArrayBuffer");
   }
-  var init_memory_conversion_utils = __esm({
-    "../loader-utils/src/lib/binary-utils/memory-conversion-utils.ts"() {
-      init_buffer_browser();
-    }
+
+  // ../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
@@ -1335,19 +1418,8 @@
     const pathname = window.location?.pathname;
     return pathname?.slice(0, pathname.lastIndexOf("/") + 1) || "";
   }
-  var init_get_cwd = __esm({
-    "../loader-utils/src/lib/path-utils/get-cwd.ts"() {
-    }
-  });
 
   // ../loader-utils/src/lib/path-utils/path.ts
-  var path_exports = {};
-  __export(path_exports, {
-    dirname: () => dirname,
-    filename: () => filename,
-    join: () => join,
-    resolve: () => resolve
-  });
   function filename(url) {
     const slashIndex = url ? url.lastIndexOf("/") : -1;
     return slashIndex >= 0 ? url.substr(slashIndex + 1) : "";
@@ -1401,6 +1473,8 @@
     }
     return ".";
   }
+  var SLASH = 47;
+  var DOT = 46;
   function normalizeStringPosix(path, allowAboveRoot) {
     let res = "";
     let lastSlash = -1;
@@ -1469,72 +1543,84 @@
     }
     return res;
   }
-  var SLASH, DOT;
-  var init_path = __esm({
-    "../loader-utils/src/lib/path-utils/path.ts"() {
-      init_get_cwd();
-      SLASH = 47;
-      DOT = 46;
-    }
-  });
 
-  // ../loader-utils/src/lib/node/fs.browser.ts
-  var fs_browser_exports = {};
-  __export(fs_browser_exports, {
-    isSupported: () => isSupported
-  });
-  var isSupported;
-  var init_fs_browser = __esm({
-    "../loader-utils/src/lib/node/fs.browser.ts"() {
-      isSupported = false;
+  // ../loader-utils/src/lib/files/blob-file.ts
+  var BlobFile = class {
+    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) {
+      const arrayBuffer = await this.handle.slice(start, start + length).arrayBuffer();
+      return arrayBuffer;
+    }
+  };
 
-  // ../loader-utils/src/index.ts
-  var init_src2 = __esm({
-    "../loader-utils/src/index.ts"() {
-      init_assert();
-      init_globals();
-      init_merge_loader_options();
-      init_parse_with_worker();
-      init_encode_with_worker();
-      init_array_buffer_utils();
-      init_text_iterators();
-      init_async_iteration();
-      init_request_scheduler();
-      init_file_aliases();
-      init_json_loader();
-      init_memory_conversion_utils();
-      init_path();
-      init_fs_browser();
+  // ../loader-utils/src/lib/files/node-file-facade.ts
+  var NOT_IMPLEMENTED = new Error("Not implemented");
+  var NodeFileFacade = class {
+    size = 0;
+    bigsize = 0n;
+    url = "";
+    constructor(url, flags, mode) {
+      if (globalThis.loaders?.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, end) {
+      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;
+    }
+    /** Close the file */
+    async close() {
+    }
+  };
 
   // src/javascript-utils/is-type.ts
-  var isBoolean, isFunction, isObject, isPureObject, isPromise, isIterable, isAsyncIterable, isIterator, isResponse, isBlob, isBuffer2, isWritableDOMStream, isReadableDOMStream, isWritableNodeStream, isReadableNodeStream, isReadableStream, isWritableStream;
-  var init_is_type = __esm({
-    "src/javascript-utils/is-type.ts"() {
-      isBoolean = (x) => typeof x === "boolean";
-      isFunction = (x) => typeof x === "function";
-      isObject = (x) => x !== null && typeof x === "object";
-      isPureObject = (x) => isObject(x) && x.constructor === {}.constructor;
-      isPromise = (x) => isObject(x) && isFunction(x.then);
-      isIterable = (x) => Boolean(x) && typeof x[Symbol.iterator] === "function";
-      isAsyncIterable = (x) => x && typeof x[Symbol.asyncIterator] === "function";
-      isIterator = (x) => x && isFunction(x.next);
-      isResponse = (x) => typeof Response !== "undefined" && x instanceof Response || x && x.arrayBuffer && x.text && x.json;
-      isBlob = (x) => typeof Blob !== "undefined" && x instanceof Blob;
-      isBuffer2 = (x) => x && typeof x === "object" && x.isBuffer;
-      isWritableDOMStream = (x) => isObject(x) && isFunction(x.abort) && isFunction(x.getWriter);
-      isReadableDOMStream = (x) => typeof ReadableStream !== "undefined" && x instanceof ReadableStream || isObject(x) && isFunction(x.tee) && isFunction(x.cancel) && isFunction(x.getReader);
-      isWritableNodeStream = (x) => isObject(x) && isFunction(x.end) && isFunction(x.write) && isBoolean(x.writable);
-      isReadableNodeStream = (x) => isObject(x) && isFunction(x.read) && isFunction(x.pipe) && isBoolean(x.readable);
-      isReadableStream = (x) => isReadableDOMStream(x) || isReadableNodeStream(x);
-      isWritableStream = (x) => isWritableDOMStream(x) || isWritableNodeStream(x);
-    }
-  });
+  var isBoolean = (x) => typeof x === "boolean";
+  var isFunction = (x) => typeof x === "function";
+  var isObject = (x) => x !== null && typeof x === "object";
+  var isPureObject = (x) => isObject(x) && x.constructor === {}.constructor;
+  var isPromise = (x) => isObject(x) && isFunction(x.then);
+  var isIterable = (x) => Boolean(x) && typeof x[Symbol.iterator] === "function";
+  var isAsyncIterable = (x) => x && typeof x[Symbol.asyncIterator] === "function";
+  var isIterator = (x) => x && isFunction(x.next);
+  var isResponse = (x) => typeof Response !== "undefined" && x instanceof Response || x && x.arrayBuffer && x.text && x.json;
+  var isBlob = (x) => typeof Blob !== "undefined" && x instanceof Blob;
+  var isBuffer2 = (x) => x && typeof x === "object" && x.isBuffer;
+  var isWritableDOMStream = (x) => isObject(x) && isFunction(x.abort) && isFunction(x.getWriter);
+  var isReadableDOMStream = (x) => typeof ReadableStream !== "undefined" && x instanceof ReadableStream || isObject(x) && isFunction(x.tee) && isFunction(x.cancel) && isFunction(x.getReader);
+  var isWritableNodeStream = (x) => isObject(x) && isFunction(x.end) && isFunction(x.write) && isBoolean(x.writable);
+  var isReadableNodeStream = (x) => isObject(x) && isFunction(x.read) && isFunction(x.pipe) && isBoolean(x.readable);
+  var isReadableStream = (x) => isReadableDOMStream(x) || isReadableNodeStream(x);
+  var isWritableStream = (x) => isWritableDOMStream(x) || isWritableNodeStream(x);
 
   // src/lib/utils/mime-type-utils.ts
+  var DATA_URL_PATTERN = /^data:([-\w.]+\/[-\w.+]+)(;|,)/;
+  var MIME_TYPE_PATTERN = /^([-\w.]+\/[-\w.+]+)/;
   function parseMIMEType(mimeString) {
     const matches3 = MIME_TYPE_PATTERN.exec(mimeString);
     if (matches3) {
@@ -1549,15 +1635,9 @@
     }
     return "";
   }
-  var DATA_URL_PATTERN, MIME_TYPE_PATTERN;
-  var init_mime_type_utils = __esm({
-    "src/lib/utils/mime-type-utils.ts"() {
-      DATA_URL_PATTERN = /^data:([-\w.]+\/[-\w.+]+)(;|,)/;
-      MIME_TYPE_PATTERN = /^([-\w.]+\/[-\w.+]+)/;
-    }
-  });
 
   // src/lib/utils/url-utils.ts
+  var QUERY_STRING_PATTERN = /\?.*/;
   function extractQueryString(url) {
     const matches3 = url.match(QUERY_STRING_PATTERN);
     return matches3 && matches3[0];
@@ -1565,12 +1645,6 @@
   function stripQueryString(url) {
     return url.replace(QUERY_STRING_PATTERN, "");
   }
-  var QUERY_STRING_PATTERN;
-  var init_url_utils = __esm({
-    "src/lib/utils/url-utils.ts"() {
-      QUERY_STRING_PATTERN = /\?.*/;
-    }
-  });
 
   // src/lib/utils/resource-utils.ts
   function getResourceUrl(resource) {
@@ -1623,13 +1697,6 @@
     }
     return -1;
   }
-  var init_resource_utils = __esm({
-    "src/lib/utils/resource-utils.ts"() {
-      init_is_type();
-      init_mime_type_utils();
-      init_url_utils();
-    }
-  });
 
   // src/lib/utils/response-utils.ts
   async function makeResponse(resource) {
@@ -1653,8 +1720,12 @@
     if (typeof resource === "string") {
       resource = new TextEncoder().encode(resource);
     }
-    const response = new Response(resource, { headers });
-    Object.defineProperty(response, "url", { value: url });
+    const response = new Response(resource, {
+      headers
+    });
+    Object.defineProperty(response, "url", {
+      value: url
+    });
     return response;
   }
   async function checkResponse(response) {
@@ -1705,18 +1776,6 @@
     }
     return btoa(binary);
   }
-  var init_response_utils = __esm({
-    "src/lib/utils/response-utils.ts"() {
-      init_is_type();
-      init_resource_utils();
-    }
-  });
-
-  // (disabled):src/lib/fetch/fetch-file.node
-  var require_fetch_file = __commonJS({
-    "(disabled):src/lib/fetch/fetch-file.node"() {
-    }
-  });
 
   // src/lib/fetch/fetch-file.ts
   function isNodePath(url) {
@@ -1731,27 +1790,18 @@
   async function fetchFile(urlOrData, fetchOptions) {
     if (typeof urlOrData === "string") {
       const url = resolvePath(urlOrData);
-      if (isNodePath(url) && node2?.fetchFileNode) {
-        return node2.fetchFileNode(url, fetchOptions);
+      if (isNodePath(url)) {
+        if (globalThis.loaders?.fetchNode) {
+          return globalThis.loaders?.fetchNode(url, fetchOptions);
+        }
       }
       return await fetch(url, fetchOptions);
     }
     return await makeResponse(urlOrData);
   }
-  var node2;
-  var init_fetch_file = __esm({
-    "src/lib/fetch/fetch-file.ts"() {
-      init_src2();
-      init_response_utils();
-      node2 = __toModule(require_fetch_file());
-    }
-  });
 
   // src/lib/fetch/read-array-buffer.ts
   async function readArrayBuffer(file, start, length) {
-    if (typeof file === "number") {
-      return await fs_browser_exports._readToArrayBuffer(file, start, length);
-    }
     if (!(file instanceof Blob)) {
       file = new Blob([file]);
     }
@@ -1766,52 +1816,6 @@
       fileReader.readAsArrayBuffer(blob);
     });
   }
-  var init_read_array_buffer = __esm({
-    "src/lib/fetch/read-array-buffer.ts"() {
-      init_src2();
-    }
-  });
-
-  // src/lib/fetch/read-file.ts
-  function readFileSync(url, options = {}) {
-    url = resolvePath(url);
-    if (!isBrowser) {
-      const buffer = fs_browser_exports.readFileSync(url, options);
-      return typeof buffer !== "string" ? toArrayBuffer2(buffer) : buffer;
-    }
-    if (!options.nothrow) {
-      assert(false);
-    }
-    return null;
-  }
-  var init_read_file = __esm({
-    "src/lib/fetch/read-file.ts"() {
-      init_src2();
-      init_src2();
-    }
-  });
-
-  // src/lib/fetch/write-file.ts
-  async function writeFile(filePath, arrayBufferOrString, options) {
-    filePath = resolvePath(filePath);
-    if (!isBrowser) {
-      await fs_browser_exports.writeFile(filePath, toBuffer2(arrayBufferOrString), { flag: "w" });
-    }
-    assert(false);
-  }
-  function writeFileSync(filePath, arrayBufferOrString, options) {
-    filePath = resolvePath(filePath);
-    if (!isBrowser) {
-      fs_browser_exports.writeFileSync(filePath, toBuffer2(arrayBufferOrString), { flag: "w" });
-    }
-    assert(false);
-  }
-  var init_write_file = __esm({
-    "src/lib/fetch/write-file.ts"() {
-      init_src2();
-      init_src2();
-    }
-  });
 
   // ../../node_modules/@probe.gl/log/node_modules/@probe.gl/env/dist/lib/is-electron.js
   function isElectron(mockUserAgent) {
@@ -1828,53 +1832,24 @@
     }
     return false;
   }
-  var init_is_electron = __esm({
-    "../../node_modules/@probe.gl/log/node_modules/@probe.gl/env/dist/lib/is-electron.js"() {
-    }
-  });
 
   // ../../node_modules/@probe.gl/log/node_modules/@probe.gl/env/dist/lib/is-browser.js
   function isBrowser3() {
     const isNode = typeof process === "object" && String(process) === "[object process]" && !process.browser;
     return !isNode || isElectron();
   }
-  var init_is_browser = __esm({
-    "../../node_modules/@probe.gl/log/node_modules/@probe.gl/env/dist/lib/is-browser.js"() {
-      init_is_electron();
-    }
-  });
 
   // ../../node_modules/@probe.gl/log/node_modules/@probe.gl/env/dist/lib/globals.js
-  var self_3, window_3, document_3, process_, console_, navigator_;
-  var init_globals3 = __esm({
-    "../../node_modules/@probe.gl/log/node_modules/@probe.gl/env/dist/lib/globals.js"() {
-      self_3 = globalThis.self || globalThis.window || globalThis.global;
-      window_3 = globalThis.window || globalThis.self || globalThis.global;
-      document_3 = globalThis.document || {};
-      process_ = globalThis.process || {};
-      console_ = globalThis.console;
-      navigator_ = globalThis.navigator || {};
-    }
-  });
+  var self_3 = globalThis.self || globalThis.window || globalThis.global;
+  var window_3 = globalThis.window || globalThis.self || globalThis.global;
+  var document_3 = globalThis.document || {};
+  var process_ = globalThis.process || {};
+  var console_ = globalThis.console;
+  var navigator_ = globalThis.navigator || {};
 
   // ../../node_modules/@probe.gl/log/node_modules/@probe.gl/env/dist/utils/globals.js
-  var VERSION3, isBrowser4;
-  var init_globals4 = __esm({
-    "../../node_modules/@probe.gl/log/node_modules/@probe.gl/env/dist/utils/globals.js"() {
-      init_is_browser();
-      VERSION3 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "untranspiled source";
-      isBrowser4 = isBrowser3();
-    }
-  });
-
-  // ../../node_modules/@probe.gl/log/node_modules/@probe.gl/env/dist/index.js
-  var init_dist2 = __esm({
-    "../../node_modules/@probe.gl/log/node_modules/@probe.gl/env/dist/index.js"() {
-      init_globals4();
-      init_globals3();
-      init_is_browser();
-    }
-  });
+  var VERSION3 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "untranspiled source";
+  var isBrowser4 = isBrowser3();
 
   // ../../node_modules/@probe.gl/log/dist/utils/local-storage.js
   function getStorage(type) {
@@ -1888,43 +1863,37 @@
       return null;
     }
   }
-  var LocalStorage;
-  var init_local_storage = __esm({
-    "../../node_modules/@probe.gl/log/dist/utils/local-storage.js"() {
-      init_defineProperty();
-      LocalStorage = class {
-        constructor(id, defaultConfig) {
-          let type = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : "sessionStorage";
-          _defineProperty(this, "storage", void 0);
-          _defineProperty(this, "id", void 0);
-          _defineProperty(this, "config", void 0);
-          this.storage = getStorage(type);
-          this.id = id;
-          this.config = defaultConfig;
-          this._loadConfiguration();
-        }
-        getConfiguration() {
-          return this.config;
-        }
-        setConfiguration(configuration) {
-          Object.assign(this.config, configuration);
-          if (this.storage) {
-            const serialized = JSON.stringify(this.config);
-            this.storage.setItem(this.id, serialized);
-          }
-        }
-        _loadConfiguration() {
-          let configuration = {};
-          if (this.storage) {
-            const serializedConfiguration = this.storage.getItem(this.id);
-            configuration = serializedConfiguration ? JSON.parse(serializedConfiguration) : {};
-          }
-          Object.assign(this.config, configuration);
-          return this;
-        }
-      };
+  var LocalStorage = class {
+    constructor(id, defaultConfig) {
+      let type = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : "sessionStorage";
+      _defineProperty(this, "storage", void 0);
+      _defineProperty(this, "id", void 0);
+      _defineProperty(this, "config", void 0);
+      this.storage = getStorage(type);
+      this.id = id;
+      this.config = defaultConfig;
+      this._loadConfiguration();
+    }
+    getConfiguration() {
+      return this.config;
+    }
+    setConfiguration(configuration) {
+      Object.assign(this.config, configuration);
+      if (this.storage) {
+        const serialized = JSON.stringify(this.config);
+        this.storage.setItem(this.id, serialized);
+      }
     }
-  });
+    _loadConfiguration() {
+      let configuration = {};
+      if (this.storage) {
+        const serializedConfiguration = this.storage.getItem(this.id);
+        configuration = serializedConfiguration ? JSON.parse(serializedConfiguration) : {};
+      }
+      Object.assign(this.config, configuration);
+      return this;
+    }
+  };
 
   // ../../node_modules/@probe.gl/log/dist/utils/formatters.js
   function formatTime(ms) {
@@ -1956,12 +1925,28 @@
     const style = ["font-size:1px;", "padding:".concat(Math.floor(height / 2), "px ").concat(Math.floor(width / 2), "px;"), "line-height:".concat(height, "px;"), "background:url(".concat(imageUrl, ");"), "background-size:".concat(width, "px ").concat(height, "px;"), "color:transparent;"].join("");
     return ["".concat(message, " %c+"), style];
   }
-  var init_formatters = __esm({
-    "../../node_modules/@probe.gl/log/dist/utils/formatters.js"() {
-    }
-  });
 
   // ../../node_modules/@probe.gl/log/dist/utils/color.js
+  var COLOR;
+  (function(COLOR2) {
+    COLOR2[COLOR2["BLACK"] = 30] = "BLACK";
+    COLOR2[COLOR2["RED"] = 31] = "RED";
+    COLOR2[COLOR2["GREEN"] = 32] = "GREEN";
+    COLOR2[COLOR2["YELLOW"] = 33] = "YELLOW";
+    COLOR2[COLOR2["BLUE"] = 34] = "BLUE";
+    COLOR2[COLOR2["MAGENTA"] = 35] = "MAGENTA";
+    COLOR2[COLOR2["CYAN"] = 36] = "CYAN";
+    COLOR2[COLOR2["WHITE"] = 37] = "WHITE";
+    COLOR2[COLOR2["BRIGHT_BLACK"] = 90] = "BRIGHT_BLACK";
+    COLOR2[COLOR2["BRIGHT_RED"] = 91] = "BRIGHT_RED";
+    COLOR2[COLOR2["BRIGHT_GREEN"] = 92] = "BRIGHT_GREEN";
+    COLOR2[COLOR2["BRIGHT_YELLOW"] = 93] = "BRIGHT_YELLOW";
+    COLOR2[COLOR2["BRIGHT_BLUE"] = 94] = "BRIGHT_BLUE";
+    COLOR2[COLOR2["BRIGHT_MAGENTA"] = 95] = "BRIGHT_MAGENTA";
+    COLOR2[COLOR2["BRIGHT_CYAN"] = 96] = "BRIGHT_CYAN";
+    COLOR2[COLOR2["BRIGHT_WHITE"] = 97] = "BRIGHT_WHITE";
+  })(COLOR || (COLOR = {}));
+  var BACKGROUND_INCREMENT = 10;
   function getColor(color) {
     if (typeof color !== "string") {
       return color;
@@ -1973,40 +1958,15 @@
     if (!isBrowser3 && typeof string === "string") {
       if (color) {
         const colorCode = getColor(color);
-        string = "[".concat(colorCode, "m").concat(string, "");
+        string = "\x1B[".concat(colorCode, "m").concat(string, "\x1B[39m");
       }
       if (background) {
         const colorCode = getColor(background);
-        string = "[".concat(colorCode + BACKGROUND_INCREMENT, "m").concat(string, "");
+        string = "\x1B[".concat(colorCode + BACKGROUND_INCREMENT, "m").concat(string, "\x1B[49m");
       }
     }
     return string;
   }
-  var COLOR, BACKGROUND_INCREMENT;
-  var init_color = __esm({
-    "../../node_modules/@probe.gl/log/dist/utils/color.js"() {
-      init_dist2();
-      (function(COLOR2) {
-        COLOR2[COLOR2["BLACK"] = 30] = "BLACK";
-        COLOR2[COLOR2["RED"] = 31] = "RED";
-        COLOR2[COLOR2["GREEN"] = 32] = "GREEN";
-        COLOR2[COLOR2["YELLOW"] = 33] = "YELLOW";
-        COLOR2[COLOR2["BLUE"] = 34] = "BLUE";
-        COLOR2[COLOR2["MAGENTA"] = 35] = "MAGENTA";
-        COLOR2[COLOR2["CYAN"] = 36] = "CYAN";
-        COLOR2[COLOR2["WHITE"] = 37] = "WHITE";
-        COLOR2[COLOR2["BRIGHT_BLACK"] = 90] = "BRIGHT_BLACK";
-        COLOR2[COLOR2["BRIGHT_RED"] = 91] = "BRIGHT_RED";
-        COLOR2[COLOR2["BRIGHT_GREEN"] = 92] = "BRIGHT_GREEN";
-        COLOR2[COLOR2["BRIGHT_YELLOW"] = 93] = "BRIGHT_YELLOW";
-        COLOR2[COLOR2["BRIGHT_BLUE"] = 94] = "BRIGHT_BLUE";
-        COLOR2[COLOR2["BRIGHT_MAGENTA"] = 95] = "BRIGHT_MAGENTA";
-        COLOR2[COLOR2["BRIGHT_CYAN"] = 96] = "BRIGHT_CYAN";
-        COLOR2[COLOR2["BRIGHT_WHITE"] = 97] = "BRIGHT_WHITE";
-      })(COLOR || (COLOR = {}));
-      BACKGROUND_INCREMENT = 10;
-    }
-  });
 
   // ../../node_modules/@probe.gl/log/dist/utils/autobind.js
   function autobind(obj) {
@@ -2023,10 +1983,6 @@
       }
     }
   }
-  var init_autobind = __esm({
-    "../../node_modules/@probe.gl/log/dist/utils/autobind.js"() {
-    }
-  });
 
   // ../../node_modules/@probe.gl/log/dist/utils/assert.js
   function assert3(condition, message) {
@@ -2034,10 +1990,6 @@
       throw new Error(message || "Assertion failed");
     }
   }
-  var init_assert3 = __esm({
-    "../../node_modules/@probe.gl/log/dist/utils/assert.js"() {
-    }
-  });
 
   // ../../node_modules/@probe.gl/log/dist/utils/hi-res-timestamp.js
   function getHiResTimestamp2() {
@@ -2054,15 +2006,237 @@
     }
     return timestamp;
   }
-  var init_hi_res_timestamp2 = __esm({
-    "../../node_modules/@probe.gl/log/dist/utils/hi-res-timestamp.js"() {
-      init_dist2();
-    }
-  });
 
   // ../../node_modules/@probe.gl/log/dist/log.js
+  var originalConsole = {
+    debug: isBrowser3() ? console.debug || console.log : console.log,
+    log: console.log,
+    info: console.info,
+    warn: console.warn,
+    error: console.error
+  };
+  var DEFAULT_LOG_CONFIGURATION = {
+    enabled: true,
+    level: 0
+  };
   function noop() {
   }
+  var cache = {};
+  var ONCE = {
+    once: true
+  };
+  var Log = class {
+    constructor() {
+      let {
+        id
+      } = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {
+        id: ""
+      };
+      _defineProperty(this, "id", void 0);
+      _defineProperty(this, "VERSION", VERSION3);
+      _defineProperty(this, "_startTs", getHiResTimestamp2());
+      _defineProperty(this, "_deltaTs", getHiResTimestamp2());
+      _defineProperty(this, "_storage", void 0);
+      _defineProperty(this, "userData", {});
+      _defineProperty(this, "LOG_THROTTLE_TIMEOUT", 0);
+      this.id = id;
+      this.userData = {};
+      this._storage = new LocalStorage("__probe-".concat(this.id, "__"), DEFAULT_LOG_CONFIGURATION);
+      this.timeStamp("".concat(this.id, " started"));
+      autobind(this);
+      Object.seal(this);
+    }
+    set level(newLevel) {
+      this.setLevel(newLevel);
+    }
+    get level() {
+      return this.getLevel();
+    }
+    isEnabled() {
+      return this._storage.config.enabled;
+    }
+    getLevel() {
+      return this._storage.config.level;
+    }
+    getTotal() {
+      return Number((getHiResTimestamp2() - this._startTs).toPrecision(10));
+    }
+    getDelta() {
+      return Number((getHiResTimestamp2() - this._deltaTs).toPrecision(10));
+    }
+    set priority(newPriority) {
+      this.level = newPriority;
+    }
+    get priority() {
+      return this.level;
+    }
+    getPriority() {
+      return this.level;
+    }
+    enable() {
+      let enabled = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : true;
+      this._storage.setConfiguration({
+        enabled
+      });
+      return this;
+    }
+    setLevel(level) {
+      this._storage.setConfiguration({
+        level
+      });
+      return this;
+    }
+    get(setting) {
+      return this._storage.config[setting];
+    }
+    set(setting, value) {
+      this._storage.setConfiguration({
+        [setting]: value
+      });
+    }
+    settings() {
+      if (console.table) {
+        console.table(this._storage.config);
+      } else {
+        console.log(this._storage.config);
+      }
+    }
+    assert(condition, message) {
+      assert3(condition, message);
+    }
+    warn(message) {
+      return this._getLogFunction(0, message, originalConsole.warn, arguments, ONCE);
+    }
+    error(message) {
+      return this._getLogFunction(0, message, originalConsole.error, arguments);
+    }
+    deprecated(oldUsage, newUsage) {
+      return this.warn("`".concat(oldUsage, "` is deprecated and will be removed in a later version. Use `").concat(newUsage, "` instead"));
+    }
+    removed(oldUsage, newUsage) {
+      return this.error("`".concat(oldUsage, "` has been removed. Use `").concat(newUsage, "` instead"));
+    }
+    probe(logLevel, message) {
+      return this._getLogFunction(logLevel, message, originalConsole.log, arguments, {
+        time: true,
+        once: true
+      });
+    }
+    log(logLevel, message) {
+      return this._getLogFunction(logLevel, message, originalConsole.debug, arguments);
+    }
+    info(logLevel, message) {
+      return this._getLogFunction(logLevel, message, console.info, arguments);
+    }
+    once(logLevel, message) {
+      return this._getLogFunction(logLevel, message, originalConsole.debug || originalConsole.info, arguments, ONCE);
+    }
+    table(logLevel, table, columns) {
+      if (table) {
+        return this._getLogFunction(logLevel, table, console.table || noop, columns && [columns], {
+          tag: getTableHeader(table)
+        });
+      }
+      return noop;
+    }
+    image(_ref) {
+      let {
+        logLevel,
+        priority,
+        image,
+        message = "",
+        scale = 1
+      } = _ref;
+      if (!this._shouldLog(logLevel || priority)) {
+        return noop;
+      }
+      return isBrowser3() ? logImageInBrowser({
+        image,
+        message,
+        scale
+      }) : logImageInNode({
+        image,
+        message,
+        scale
+      });
+    }
+    time(logLevel, message) {
+      return this._getLogFunction(logLevel, message, console.time ? console.time : console.info);
+    }
+    timeEnd(logLevel, message) {
+      return this._getLogFunction(logLevel, message, console.timeEnd ? console.timeEnd : console.info);
+    }
+    timeStamp(logLevel, message) {
+      return this._getLogFunction(logLevel, message, console.timeStamp || noop);
+    }
+    group(logLevel, message) {
+      let opts = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {
+        collapsed: false
+      };
+      const options = normalizeArguments({
+        logLevel,
+        message,
+        opts
+      });
+      const {
+        collapsed
+      } = opts;
+      options.method = (collapsed ? console.groupCollapsed : console.group) || console.info;
+      return this._getLogFunction(options);
+    }
+    groupCollapsed(logLevel, message) {
+      let opts = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
+      return this.group(logLevel, message, Object.assign({}, opts, {
+        collapsed: true
+      }));
+    }
+    groupEnd(logLevel) {
+      return this._getLogFunction(logLevel, "", console.groupEnd || noop);
+    }
+    withGroup(logLevel, message, func) {
+      this.group(logLevel, message)();
+      try {
+        func();
+      } finally {
+        this.groupEnd(logLevel)();
+      }
+    }
+    trace() {
+      if (console.trace) {
+        console.trace();
+      }
+    }
+    _shouldLog(logLevel) {
+      return this.isEnabled() && this.getLevel() >= normalizeLogLevel(logLevel);
+    }
+    _getLogFunction(logLevel, message, method, args, opts) {
+      if (this._shouldLog(logLevel)) {
+        opts = normalizeArguments({
+          logLevel,
+          message,
+          args,
+          opts
+        });
+        method = method || opts.method;
+        assert3(method);
+        opts.total = this.getTotal();
+        opts.delta = this.getDelta();
+        this._deltaTs = getHiResTimestamp2();
+        const tag = opts.tag || opts.message;
+        if (opts.once && tag) {
+          if (!cache[tag]) {
+            cache[tag] = getHiResTimestamp2();
+          } else {
+            return noop;
+          }
+        }
+        message = decorateMessage(this.id, opts.message, opts);
+        return method.bind(console, message, ...opts.args);
+      }
+      return noop;
+    }
+  };
+  _defineProperty(Log, "VERSION", VERSION3);
   function normalizeLogLevel(logLevel) {
     if (!logLevel) {
       return 0;
@@ -2124,400 +2298,156 @@
     let {
       image,
       message = "",
-      scale = 1
-    } = _ref2;
-    console.warn("removed");
-    return noop;
-  }
-  function logImageInBrowser(_ref3) {
-    let {
-      image,
-      message = "",
-      scale = 1
-    } = _ref3;
-    if (typeof image === "string") {
-      const img = new Image();
-      img.onload = () => {
-        const args = formatImage(img, message, scale);
-        console.log(...args);
-      };
-      img.src = image;
-      return noop;
-    }
-    const element = image.nodeName || "";
-    if (element.toLowerCase() === "img") {
-      console.log(...formatImage(image, message, scale));
-      return noop;
-    }
-    if (element.toLowerCase() === "canvas") {
-      const img = new Image();
-      img.onload = () => console.log(...formatImage(img, message, scale));
-      img.src = image.toDataURL();
-      return noop;
-    }
-    return noop;
-  }
-  function getTableHeader(table) {
-    for (const key in table) {
-      for (const title in table[key]) {
-        return title || "untitled";
-      }
-    }
-    return "empty";
-  }
-  var originalConsole, DEFAULT_LOG_CONFIGURATION, cache, ONCE, Log;
-  var init_log = __esm({
-    "../../node_modules/@probe.gl/log/dist/log.js"() {
-      init_defineProperty();
-      init_dist2();
-      init_local_storage();
-      init_formatters();
-      init_color();
-      init_autobind();
-      init_assert3();
-      init_hi_res_timestamp2();
-      originalConsole = {
-        debug: isBrowser3() ? console.debug || console.log : console.log,
-        log: console.log,
-        info: console.info,
-        warn: console.warn,
-        error: console.error
-      };
-      DEFAULT_LOG_CONFIGURATION = {
-        enabled: true,
-        level: 0
-      };
-      cache = {};
-      ONCE = {
-        once: true
-      };
-      Log = class {
-        constructor() {
-          let {
-            id
-          } = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {
-            id: ""
-          };
-          _defineProperty(this, "id", void 0);
-          _defineProperty(this, "VERSION", VERSION3);
-          _defineProperty(this, "_startTs", getHiResTimestamp2());
-          _defineProperty(this, "_deltaTs", getHiResTimestamp2());
-          _defineProperty(this, "_storage", void 0);
-          _defineProperty(this, "userData", {});
-          _defineProperty(this, "LOG_THROTTLE_TIMEOUT", 0);
-          this.id = id;
-          this.userData = {};
-          this._storage = new LocalStorage("__probe-".concat(this.id, "__"), DEFAULT_LOG_CONFIGURATION);
-          this.timeStamp("".concat(this.id, " started"));
-          autobind(this);
-          Object.seal(this);
-        }
-        set level(newLevel) {
-          this.setLevel(newLevel);
-        }
-        get level() {
-          return this.getLevel();
-        }
-        isEnabled() {
-          return this._storage.config.enabled;
-        }
-        getLevel() {
-          return this._storage.config.level;
-        }
-        getTotal() {
-          return Number((getHiResTimestamp2() - this._startTs).toPrecision(10));
-        }
-        getDelta() {
-          return Number((getHiResTimestamp2() - this._deltaTs).toPrecision(10));
-        }
-        set priority(newPriority) {
-          this.level = newPriority;
-        }
-        get priority() {
-          return this.level;
-        }
-        getPriority() {
-          return this.level;
-        }
-        enable() {
-          let enabled = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : true;
-          this._storage.setConfiguration({
-            enabled
-          });
-          return this;
-        }
-        setLevel(level) {
-          this._storage.setConfiguration({
-            level
-          });
-          return this;
-        }
-        get(setting) {
-          return this._storage.config[setting];
-        }
-        set(setting, value) {
-          this._storage.setConfiguration({
-            [setting]: value
-          });
-        }
-        settings() {
-          if (console.table) {
-            console.table(this._storage.config);
-          } else {
-            console.log(this._storage.config);
-          }
-        }
-        assert(condition, message) {
-          assert3(condition, message);
-        }
-        warn(message) {
-          return this._getLogFunction(0, message, originalConsole.warn, arguments, ONCE);
-        }
-        error(message) {
-          return this._getLogFunction(0, message, originalConsole.error, arguments);
-        }
-        deprecated(oldUsage, newUsage) {
-          return this.warn("`".concat(oldUsage, "` is deprecated and will be removed in a later version. Use `").concat(newUsage, "` instead"));
-        }
-        removed(oldUsage, newUsage) {
-          return this.error("`".concat(oldUsage, "` has been removed. Use `").concat(newUsage, "` instead"));
-        }
-        probe(logLevel, message) {
-          return this._getLogFunction(logLevel, message, originalConsole.log, arguments, {
-            time: true,
-            once: true
-          });
-        }
-        log(logLevel, message) {
-          return this._getLogFunction(logLevel, message, originalConsole.debug, arguments);
-        }
-        info(logLevel, message) {
-          return this._getLogFunction(logLevel, message, console.info, arguments);
-        }
-        once(logLevel, message) {
-          return this._getLogFunction(logLevel, message, originalConsole.debug || originalConsole.info, arguments, ONCE);
-        }
-        table(logLevel, table, columns) {
-          if (table) {
-            return this._getLogFunction(logLevel, table, console.table || noop, columns && [columns], {
-              tag: getTableHeader(table)
-            });
-          }
-          return noop;
-        }
-        image(_ref) {
-          let {
-            logLevel,
-            priority,
-            image,
-            message = "",
-            scale = 1
-          } = _ref;
-          if (!this._shouldLog(logLevel || priority)) {
-            return noop;
-          }
-          return isBrowser3() ? logImageInBrowser({
-            image,
-            message,
-            scale
-          }) : logImageInNode({
-            image,
-            message,
-            scale
-          });
-        }
-        time(logLevel, message) {
-          return this._getLogFunction(logLevel, message, console.time ? console.time : console.info);
-        }
-        timeEnd(logLevel, message) {
-          return this._getLogFunction(logLevel, message, console.timeEnd ? console.timeEnd : console.info);
-        }
-        timeStamp(logLevel, message) {
-          return this._getLogFunction(logLevel, message, console.timeStamp || noop);
-        }
-        group(logLevel, message) {
-          let opts = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {
-            collapsed: false
-          };
-          const options = normalizeArguments({
-            logLevel,
-            message,
-            opts
-          });
-          const {
-            collapsed
-          } = opts;
-          options.method = (collapsed ? console.groupCollapsed : console.group) || console.info;
-          return this._getLogFunction(options);
-        }
-        groupCollapsed(logLevel, message) {
-          let opts = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
-          return this.group(logLevel, message, Object.assign({}, opts, {
-            collapsed: true
-          }));
-        }
-        groupEnd(logLevel) {
-          return this._getLogFunction(logLevel, "", console.groupEnd || noop);
-        }
-        withGroup(logLevel, message, func) {
-          this.group(logLevel, message)();
-          try {
-            func();
-          } finally {
-            this.groupEnd(logLevel)();
-          }
-        }
-        trace() {
-          if (console.trace) {
-            console.trace();
-          }
-        }
-        _shouldLog(logLevel) {
-          return this.isEnabled() && this.getLevel() >= normalizeLogLevel(logLevel);
-        }
-        _getLogFunction(logLevel, message, method, args, opts) {
-          if (this._shouldLog(logLevel)) {
-            opts = normalizeArguments({
-              logLevel,
-              message,
-              args,
-              opts
-            });
-            method = method || opts.method;
-            assert3(method);
-            opts.total = this.getTotal();
-            opts.delta = this.getDelta();
-            this._deltaTs = getHiResTimestamp2();
-            const tag = opts.tag || opts.message;
-            if (opts.once && tag) {
-              if (!cache[tag]) {
-                cache[tag] = getHiResTimestamp2();
-              } else {
-                return noop;
-              }
-            }
-            message = decorateMessage(this.id, opts.message, opts);
-            return method.bind(console, message, ...opts.args);
-          }
-          return noop;
-        }
+      scale = 1
+    } = _ref2;
+    console.warn("removed");
+    return noop;
+  }
+  function logImageInBrowser(_ref3) {
+    let {
+      image,
+      message = "",
+      scale = 1
+    } = _ref3;
+    if (typeof image === "string") {
+      const img = new Image();
+      img.onload = () => {
+        const args = formatImage(img, message, scale);
+        console.log(...args);
       };
-      _defineProperty(Log, "VERSION", VERSION3);
+      img.src = image;
+      return noop;
     }
-  });
+    const element = image.nodeName || "";
+    if (element.toLowerCase() === "img") {
+      console.log(...formatImage(image, message, scale));
+      return noop;
+    }
+    if (element.toLowerCase() === "canvas") {
+      const img = new Image();
+      img.onload = () => console.log(...formatImage(img, message, scale));
+      img.src = image.toDataURL();
+      return noop;
+    }
+    return noop;
+  }
+  function getTableHeader(table) {
+    for (const key in table) {
+      for (const title in table[key]) {
+        return title || "untitled";
+      }
+    }
+    return "empty";
+  }
 
   // ../../node_modules/@probe.gl/log/dist/index.js
-  var dist_default;
-  var init_dist3 = __esm({
-    "../../node_modules/@probe.gl/log/dist/index.js"() {
-      init_log();
-      init_log();
-      dist_default = new Log({
-        id: "@probe.gl/log"
-      });
-    }
+  var dist_default = new Log({
+    id: "@probe.gl/log"
   });
 
   // src/lib/loader-utils/loggers.ts
-  var probeLog, NullLog, ConsoleLog;
-  var init_loggers = __esm({
-    "src/lib/loader-utils/loggers.ts"() {
-      init_dist3();
-      probeLog = new Log({ id: "loaders.gl" });
-      NullLog = class {
-        log() {
-          return () => {
-          };
-        }
-        info() {
-          return () => {
-          };
-        }
-        warn() {
-          return () => {
-          };
-        }
-        error() {
-          return () => {
-          };
-        }
+  var probeLog = new Log({
+    id: "loaders.gl"
+  });
+  var NullLog = class {
+    log() {
+      return () => {
       };
-      ConsoleLog = class {
-        constructor() {
-          this.console = console;
-        }
-        log(...args) {
-          return this.console.log.bind(this.console, ...args);
-        }
-        info(...args) {
-          return this.console.info.bind(this.console, ...args);
-        }
-        warn(...args) {
-          return this.console.warn.bind(this.console, ...args);
-        }
-        error(...args) {
-          return this.console.error.bind(this.console, ...args);
-        }
+    }
+    info() {
+      return () => {
       };
     }
-  });
-
-  // src/lib/loader-utils/option-defaults.ts
-  var DEFAULT_LOADER_OPTIONS, REMOVED_LOADER_OPTIONS;
-  var init_option_defaults = __esm({
-    "src/lib/loader-utils/option-defaults.ts"() {
-      init_src2();
-      init_loggers();
-      DEFAULT_LOADER_OPTIONS = {
-        fetch: null,
-        mimeType: void 0,
-        nothrow: false,
-        log: new ConsoleLog(),
-        useLocalLibraries: false,
-        CDN: "https://unpkg.com/@loaders.gl",
-        worker: true,
-        maxConcurrency: 3,
-        maxMobileConcurrency: 1,
-        reuseWorkers: isBrowser,
-        _nodeWorkers: false,
-        _workerType: "",
-        limit: 0,
-        _limitMB: 0,
-        batchSize: "auto",
-        batchDebounceMs: 0,
-        metadata: false,
-        transforms: []
+    warn() {
+      return () => {
       };
-      REMOVED_LOADER_OPTIONS = {
-        throws: "nothrow",
-        dataType: "(no longer used)",
-        uri: "baseUri",
-        method: "fetch.method",
-        headers: "fetch.headers",
-        body: "fetch.body",
-        mode: "fetch.mode",
-        credentials: "fetch.credentials",
-        cache: "fetch.cache",
-        redirect: "fetch.redirect",
-        referrer: "fetch.referrer",
-        referrerPolicy: "fetch.referrerPolicy",
-        integrity: "fetch.integrity",
-        keepalive: "fetch.keepalive",
-        signal: "fetch.signal"
+    }
+    error() {
+      return () => {
       };
     }
-  });
+  };
+  var ConsoleLog = class {
+    constructor() {
+      this.console = console;
+    }
+    log(...args) {
+      return this.console.log.bind(this.console, ...args);
+    }
+    info(...args) {
+      return this.console.info.bind(this.console, ...args);
+    }
+    warn(...args) {
+      return this.console.warn.bind(this.console, ...args);
+    }
+    error(...args) {
+      return this.console.error.bind(this.console, ...args);
+    }
+  };
+
+  // src/lib/loader-utils/option-defaults.ts
+  var DEFAULT_LOADER_OPTIONS = {
+    // baseUri
+    fetch: null,
+    mimeType: void 0,
+    nothrow: false,
+    log: new ConsoleLog(),
+    // A probe.gl compatible (`log.log()()` syntax) that just logs to console
+    useLocalLibraries: false,
+    CDN: "https://unpkg.com/@loaders.gl",
+    worker: true,
+    // By default, use worker if provided by loader.
+    maxConcurrency: 3,
+    // How many worker instances should be created for each loader.
+    maxMobileConcurrency: 1,
+    // How many worker instances should be created for each loader on mobile devices.
+    reuseWorkers: 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
+    _workerType: "",
+    // 'test' to use locally generated workers
+    limit: 0,
+    _limitMB: 0,
+    batchSize: "auto",
+    batchDebounceMs: 0,
+    metadata: false,
+    // TODO - currently only implemented for parseInBatches, adds initial metadata batch,
+    transforms: []
+  };
+  var REMOVED_LOADER_OPTIONS = {
+    throws: "nothrow",
+    dataType: "(no longer used)",
+    uri: "baseUri",
+    // Warn if fetch options are used on top-level
+    method: "fetch.method",
+    headers: "fetch.headers",
+    body: "fetch.body",
+    mode: "fetch.mode",
+    credentials: "fetch.credentials",
+    cache: "fetch.cache",
+    redirect: "fetch.redirect",
+    referrer: "fetch.referrer",
+    referrerPolicy: "fetch.referrerPolicy",
+    integrity: "fetch.integrity",
+    keepalive: "fetch.keepalive",
+    signal: "fetch.signal"
+  };
 
   // src/lib/loader-utils/option-utils.ts
   function getGlobalLoaderState() {
     globalThis.loaders = globalThis.loaders || {};
-    const { loaders } = globalThis;
+    const {
+      loaders
+    } = globalThis;
     loaders._state = loaders._state || {};
     return loaders._state;
   }
   function getGlobalLoaderOptions() {
     const state = getGlobalLoaderState();
-    state.globalOptions = state.globalOptions || { ...DEFAULT_LOADER_OPTIONS };
+    state.globalOptions = state.globalOptions || {
+      ...DEFAULT_LOADER_OPTIONS
+    };
     return state.globalOptions;
   }
   function setGlobalOptions(options) {
@@ -2576,7 +2506,9 @@
   }
   function normalizeOptionsInternal(loader, options, url) {
     const loaderDefaultOptions = loader.options || {};
-    const mergedOptions = { ...loaderDefaultOptions };
+    const mergedOptions = {
+      ...loaderDefaultOptions
+    };
     addUrlOptions(mergedOptions, url);
     if (mergedOptions.log === null) {
       mergedOptions.log = new NullLog();
@@ -2605,21 +2537,6 @@
       options.baseUri = url;
     }
   }
-  var init_option_utils = __esm({
-    "src/lib/loader-utils/option-utils.ts"() {
-      init_is_type();
-      init_loggers();
-      init_option_defaults();
-    }
-  });
-
-  // src/lib/api/loader-options.ts
-  var init_loader_options = __esm({
-    "src/lib/api/loader-options.ts"() {
-      init_option_utils();
-      init_option_utils();
-    }
-  });
 
   // src/lib/loader-utils/normalize-loader.ts
   function isLoaderObject(loader) {
@@ -2641,7 +2558,10 @@
       loader = loader[0];
       loader = {
         ...loader,
-        options: { ...loader.options, ...options }
+        options: {
+          ...loader.options,
+          ...options
+        }
       };
     }
     if (loader?.parseTextSync || loader?.parseText) {
@@ -2652,13 +2572,13 @@
     }
     return loader;
   }
-  var init_normalize_loader = __esm({
-    "src/lib/loader-utils/normalize-loader.ts"() {
-      init_src2();
-    }
-  });
 
   // src/lib/api/register-loaders.ts
+  var getGlobalLoaderRegistry = () => {
+    const state = getGlobalLoaderState();
+    state.loaderRegistry = state.loaderRegistry || [];
+    return state.loaderRegistry;
+  };
   function registerLoaders(loaders) {
     const loaderRegistry = getGlobalLoaderRegistry();
     loaders = Array.isArray(loaders) ? loaders : [loaders];
@@ -2676,34 +2596,22 @@
     const state = getGlobalLoaderState();
     state.loaderRegistry = [];
   }
-  var getGlobalLoaderRegistry;
-  var init_register_loaders = __esm({
-    "src/lib/api/register-loaders.ts"() {
-      init_normalize_loader();
-      init_option_utils();
-      getGlobalLoaderRegistry = () => {
-        const state = getGlobalLoaderState();
-        state.loaderRegistry = state.loaderRegistry || [];
-        return state.loaderRegistry;
-      };
-    }
-  });
 
   // src/lib/utils/log.ts
-  var log;
-  var init_log2 = __esm({
-    "src/lib/utils/log.ts"() {
-      init_dist3();
-      log = new Log({ id: "loaders.gl" });
-    }
+  var log = new Log({
+    id: "loaders.gl"
   });
 
   // src/lib/api/select-loader.ts
+  var EXT_PATTERN = /\.([^.]+)$/;
   async function selectLoader(data, loaders = [], options, context) {
     if (!validHTTPResponse(data)) {
       return null;
     }
-    let loader = selectLoaderSync(data, loaders, { ...options, nothrow: true }, context);
+    let loader = selectLoaderSync(data, loaders, {
+      ...options,
+      nothrow: true
+    }, context);
     if (loader) {
       return loader;
     }
@@ -2882,21 +2790,9 @@
     }
     return magic;
   }
-  var EXT_PATTERN;
-  var init_select_loader = __esm({
-    "src/lib/api/select-loader.ts"() {
-      init_src2();
-      init_normalize_loader();
-      init_log2();
-      init_resource_utils();
-      init_register_loaders();
-      init_is_type();
-      init_url_utils();
-      EXT_PATTERN = /\.([^.]+)$/;
-    }
-  });
 
   // src/iterators/make-iterator/make-string-iterator.ts
+  var DEFAULT_CHUNK_SIZE = 256 * 1024;
   function* makeStringIterator(string, options) {
     const chunkSize = options?.chunkSize || DEFAULT_CHUNK_SIZE;
     let offset = 0;
@@ -2908,16 +2804,13 @@
       yield textEncoder.encode(chunk);
     }
   }
-  var DEFAULT_CHUNK_SIZE;
-  var init_make_string_iterator = __esm({
-    "src/iterators/make-iterator/make-string-iterator.ts"() {
-      DEFAULT_CHUNK_SIZE = 256 * 1024;
-    }
-  });
 
   // src/iterators/make-iterator/make-array-buffer-iterator.ts
+  var DEFAULT_CHUNK_SIZE2 = 256 * 1024;
   function* makeArrayBufferIterator(arrayBuffer, options = {}) {
-    const { chunkSize = DEFAULT_CHUNK_SIZE2 } = options;
+    const {
+      chunkSize = DEFAULT_CHUNK_SIZE2
+    } = options;
     let byteOffset = 0;
     while (byteOffset < arrayBuffer.byteLength) {
       const chunkByteLength = Math.min(arrayBuffer.byteLength - byteOffset, chunkSize);
@@ -2929,14 +2822,9 @@
       yield chunk;
     }
   }
-  var DEFAULT_CHUNK_SIZE2;
-  var init_make_array_buffer_iterator = __esm({
-    "src/iterators/make-iterator/make-array-buffer-iterator.ts"() {
-      DEFAULT_CHUNK_SIZE2 = 256 * 1024;
-    }
-  });
 
   // src/iterators/make-iterator/make-blob-iterator.ts
+  var DEFAULT_CHUNK_SIZE3 = 1024 * 1024;
   async function* makeBlobIterator(blob, options) {
     const chunkSize = options?.chunkSize || DEFAULT_CHUNK_SIZE3;
     let offset = 0;
@@ -2947,12 +2835,6 @@
       yield chunk;
     }
   }
-  var DEFAULT_CHUNK_SIZE3;
-  var init_make_blob_iterator = __esm({
-    "src/iterators/make-iterator/make-blob-iterator.ts"() {
-      DEFAULT_CHUNK_SIZE3 = 1024 * 1024;
-    }
-  });
 
   // src/iterators/make-iterator/make-stream-iterator.ts
   function makeStreamIterator(stream, options) {
@@ -2967,7 +2849,10 @@
         if (options?._streamReadAhead) {
           nextBatchPromise = reader.read();
         }
-        const { done, value } = await currentBatchPromise;
+        const {
+          done,
+          value
+        } = await currentBatchPromise;
         if (done) {
           return;
         }
@@ -2982,11 +2867,6 @@
       yield toArrayBuffer2(chunk);
     }
   }
-  var init_make_stream_iterator = __esm({
-    "src/iterators/make-iterator/make-stream-iterator.ts"() {
-      init_src2();
-    }
-  });
 
   // src/iterators/make-iterator/make-iterator.ts
   function makeIterator(data, options) {
@@ -3008,17 +2888,9 @@
     }
     throw new Error("makeIterator");
   }
-  var init_make_iterator = __esm({
-    "src/iterators/make-iterator/make-iterator.ts"() {
-      init_make_string_iterator();
-      init_make_array_buffer_iterator();
-      init_make_blob_iterator();
-      init_make_stream_iterator();
-      init_is_type();
-    }
-  });
 
   // src/lib/loader-utils/get-data.ts
+  var ERR_DATA = "Cannot convert supplied data type";
   function getArrayBufferOrStringFromDataSync(data, loader, options) {
     if (loader.text && typeof data === "string") {
       return data;
@@ -3106,16 +2978,6 @@
     }
     throw new Error(ERR_DATA);
   }
-  var ERR_DATA;
-  var init_get_data = __esm({
-    "src/lib/loader-utils/get-data.ts"() {
-      init_src2();
-      init_is_type();
-      init_make_iterator();
-      init_response_utils();
-      ERR_DATA = "Cannot convert supplied data type";
-    }
-  });
 
   // src/lib/loader-utils/get-fetch-function.ts
   function getFetchFunction(options, context) {
@@ -3132,13 +2994,6 @@
     }
     return fetchFile;
   }
-  var init_get_fetch_function = __esm({
-    "src/lib/loader-utils/get-fetch-function.ts"() {
-      init_is_type();
-      init_fetch_file();
-      init_option_utils();
-    }
-  });
 
   // src/lib/loader-utils/loader-context.ts
   function getLoaderContext(context, options, parentContext) {
@@ -3175,13 +3030,6 @@
     }
     return candidateLoaders && candidateLoaders.length ? candidateLoaders : void 0;
   }
-  var init_loader_context = __esm({
-    "src/lib/loader-utils/loader-context.ts"() {
-      init_get_fetch_function();
-      init_url_utils();
-      init_src2();
-    }
-  });
 
   // src/lib/api/parse.ts
   async function parse(data, loaders, options, context) {
@@ -3200,7 +3048,16 @@
       return null;
     }
     options = normalizeOptions(options, loader, candidateLoaders, url);
-    context = getLoaderContext({ url, _parse: parse, loaders: candidateLoaders }, options, context || null);
+    context = getLoaderContext(
+      // @ts-expect-error
+      {
+        url,
+        _parse: parse,
+        loaders: candidateLoaders
+      },
+      options,
+      context || null
+    );
     return await parseWithLoader(loader, data, options, context);
   }
   async function parseWithLoader(loader, data, options, context) {
@@ -3208,9 +3065,24 @@
     options = mergeLoaderOptions(loader.options, options);
     if (isResponse(data)) {
       const response = data;
-      const { ok, redirected, status, statusText, type, url } = response;
+      const {
+        ok,
+        redirected,
+        status,
+        statusText,
+        type,
+        url
+      } = response;
       const headers = Object.fromEntries(response.headers.entries());
-      context.response = { headers, ok, redirected, status, statusText, type, url };
+      context.response = {
+        headers,
+        ok,
+        redirected,
+        status,
+        statusText,
+        type,
+        url
+      };
     }
     data = await getArrayBufferOrStringFromData(data, loader, options);
     const loaderWithParser = loader;
@@ -3229,20 +3101,6 @@
     assert2(!loaderWithParser.parseSync);
     throw new Error(`${loader.id} loader - no parser found and worker is disabled`);
   }
-  var init_parse = __esm({
-    "src/lib/api/parse.ts"() {
-      init_src2();
-      init_src();
-      init_normalize_loader();
-      init_is_type();
-      init_option_utils();
-      init_src2();
-      init_get_data();
-      init_loader_context();
-      init_resource_utils();
-      init_select_loader();
-    }
-  });
 
   // src/lib/api/parse-sync.ts
   function parseSync(data, loaders, options, context) {
@@ -3263,7 +3121,12 @@
     const parse2 = () => {
       throw new Error("parseSync called parse (which is async");
     };
-    context = getLoaderContext({ url, _parseSync: parse2, _parse: parse2, loaders }, options, context || null);
+    context = getLoaderContext({
+      url,
+      _parseSync: parse2,
+      _parse: parse2,
+      loaders
+    }, options, context || null);
     return parseWithLoaderSync(loader, data, options, context);
   }
   function parseWithLoaderSync(loader, data, options, context) {
@@ -3276,16 +3139,6 @@
     }
     throw new Error(`${loader.name} loader: 'parseSync' not supported by this loader, use 'parse' instead. ${context.url || ""}`);
   }
-  var init_parse_sync = __esm({
-    "src/lib/api/parse-sync.ts"() {
-      init_select_loader();
-      init_normalize_loader();
-      init_option_utils();
-      init_get_data();
-      init_loader_context();
-      init_resource_utils();
-    }
-  });
 
   // src/lib/api/parse-in-batches.ts
   async function parseInBatches(data, loaders, options, context) {
@@ -3303,7 +3156,12 @@
       return [];
     }
     options = normalizeOptions(options, loader, loaderArray, url);
-    context = getLoaderContext({ url, _parseInBatches: parseInBatches, _parse: parse, loaders: loaderArray }, options, context || null);
+    context = getLoaderContext({
+      url,
+      _parseInBatches: parseInBatches,
+      _parse: parse,
+      loaders: loaderArray
+    }, options, context || null);
     return await parseWithLoaderInBatches(loader, data, options, context);
   }
   async function parseWithLoaderInBatches(loader, data, options, context) {
@@ -3317,6 +3175,7 @@
         _loader: loader,
         _context: context
       },
+      // Populate with some default fields to avoid crashing
       data: [],
       bytesUsed: 0
     };
@@ -3334,7 +3193,16 @@
     }
     async function* parseChunkInBatches() {
       const arrayBuffer = await concatenateArrayBuffersAsync(transformedIterator);
-      const parsedData = await parse(arrayBuffer, loader, { ...options, mimeType: loader.mimeTypes[0] }, context);
+      const parsedData = await parse(
+        arrayBuffer,
+        loader,
+        // TODO - Hack: supply loaders MIME type to ensure we match it
+        {
+          ...options,
+          mimeType: loader.mimeTypes[0]
+        },
+        context
+      );
       const batch = {
         mimeType: loader.mimeTypes[0],
         shape: Array.isArray(parsedData) ? "row-table" : "unknown",
@@ -3353,18 +3221,6 @@
     }
     return iteratorChain;
   }
-  var init_parse_in_batches = __esm({
-    "src/lib/api/parse-in-batches.ts"() {
-      init_src2();
-      init_normalize_loader();
-      init_option_utils();
-      init_loader_context();
-      init_get_data();
-      init_resource_utils();
-      init_select_loader();
-      init_parse();
-    }
-  });
 
   // src/lib/api/load.ts
   async function load(url, loaders, options, context) {
@@ -3388,14 +3244,6 @@
     }
     return Array.isArray(resolvedLoaders) ? await parse(data, resolvedLoaders, resolvedOptions) : await parse(data, resolvedLoaders, resolvedOptions);
   }
-  var init_load = __esm({
-    "src/lib/api/load.ts"() {
-      init_is_type();
-      init_normalize_loader();
-      init_get_fetch_function();
-      init_parse();
-    }
-  });
 
   // src/lib/api/load-in-batches.ts
   function loadInBatches(files, loaders, options, context) {
@@ -3422,13 +3270,6 @@
     }
     return Array.isArray(loaders) ? await parseInBatches(file, loaders, options) : await parseInBatches(file, loaders, options);
   }
-  var init_load_in_batches = __esm({
-    "src/lib/api/load-in-batches.ts"() {
-      init_normalize_loader();
-      init_get_fetch_function();
-      init_parse_in_batches();
-    }
-  });
 
   // src/lib/api/encode-table.ts
   async function encodeTable(data, writer, options) {
@@ -3467,19 +3308,21 @@
     throw new Error("Writer could not encode data in batches");
   }
   function getIterator(data) {
-    const dataIterator = [{ ...data, start: 0, end: data.length }];
+    const dataIterator = [{
+      ...data,
+      start: 0,
+      end: data.length
+    }];
     return dataIterator;
   }
-  var init_encode_table = __esm({
-    "src/lib/api/encode-table.ts"() {
-      init_src2();
-    }
-  });
 
   // src/lib/api/encode.ts
   async function encode(data, writer, options) {
     const globalOptions = getGlobalLoaderOptions();
-    options = { ...globalOptions, ...options };
+    options = {
+      ...globalOptions,
+      ...options
+    };
     if (canEncodeWithWorker(writer, options)) {
       return await processOnWorker(writer, data, options);
     }
@@ -3502,7 +3345,8 @@
     }
     if (!isBrowser && writer.encodeURLtoURL) {
       const tmpInputFilename = getTemporaryFilename("input");
-      await writeFile(tmpInputFilename, data);
+      const file = new NodeFileFacade(tmpInputFilename, "w");
+      await file.write(data);
       const tmpOutputFilename = getTemporaryFilename("output");
       const outputFilename = await encodeURLtoURL(tmpInputFilename, tmpOutputFilename, writer, options);
       const response = await fetchFile(outputFilename);
@@ -3553,112 +3397,94 @@
     return outputFilename;
   }
   function getIterator2(data) {
-    const dataIterator = [{ ...data, start: 0, end: data.length }];
+    const dataIterator = [{
+      ...data,
+      start: 0,
+      end: data.length
+    }];
     return dataIterator;
   }
   function getTemporaryFilename(filename2) {
     return `/tmp/${filename2}`;
   }
-  var init_encode = __esm({
-    "src/lib/api/encode.ts"() {
-      init_src2();
-      init_src();
-      init_src2();
-      init_src2();
-      init_write_file();
-      init_fetch_file();
-      init_loader_options();
-    }
-  });
-
-  // src/lib/api/save.ts
-  async function save(data, url, writer, options) {
-    const encodedData = await encode(data, writer, options);
-    return await writeFile(url, encodedData);
-  }
-  function saveSync(data, url, writer, options) {
-    const encodedData = encodeSync(data, writer, options);
-    return writeFileSync(url, encodedData);
-  }
-  var init_save = __esm({
-    "src/lib/api/save.ts"() {
-      init_encode();
-      init_write_file();
-    }
-  });
 
-  // src/iterators/make-stream/make-dom-stream.ts
+  // src/iterators/make-stream/make-stream.ts
   function makeStream(source, options) {
+    if (globalThis.loaders.makeNodeStream) {
+      return globalThis.loaders.makeNodeStream(source, options);
+    }
     const iterator = source[Symbol.asyncIterator] ? source[Symbol.asyncIterator]() : source[Symbol.iterator]();
-    return new ReadableStream({
-      type: "bytes",
-      async pull(controller) {
-        try {
-          const { done, value } = await iterator.next();
-          if (done) {
-            controller.close();
-          } else {
-            controller.enqueue(new Uint8Array(value));
+    return new ReadableStream(
+      {
+        // Create a byte stream (enables `Response(stream).arrayBuffer()`)
+        // Only supported on Chrome
+        // See: https://developer.mozilla.org/en-US/docs/Web/API/ReadableByteStreamController
+        type: "bytes",
+        async pull(controller) {
+          try {
+            const {
+              done,
+              value
+            } = await iterator.next();
+            if (done) {
+              controller.close();
+            } else {
+              controller.enqueue(new Uint8Array(value));
+            }
+          } catch (error) {
+            controller.error(error);
           }
-        } catch (error) {
-          controller.error(error);
+        },
+        async cancel() {
+          await iterator?.return?.();
         }
       },
-      async cancel() {
-        await iterator?.return?.();
+      // options: QueingStrategy<Uint8Array>
+      {
+        // This is bytes, not chunks
+        highWaterMark: 2 ** 24,
+        ...options
       }
-    }, {
-      highWaterMark: 2 ** 24,
-      ...options
-    });
+    );
   }
-  var init_make_dom_stream = __esm({
-    "src/iterators/make-stream/make-dom-stream.ts"() {
-    }
-  });
 
   // src/null-loader.ts
+  var VERSION4 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+  var NullWorkerLoader = {
+    name: "Null loader",
+    id: "null",
+    module: "core",
+    version: VERSION4,
+    worker: true,
+    mimeTypes: ["application/x.empty"],
+    extensions: ["null"],
+    tests: [() => false],
+    options: {
+      null: {}
+    }
+  };
+  var NullLoader = {
+    name: "Null loader",
+    id: "null",
+    module: "core",
+    version: VERSION4,
+    mimeTypes: ["application/x.empty"],
+    extensions: ["null"],
+    parse: async (arrayBuffer, options, context) => parseSync2(arrayBuffer, options || {}, context),
+    parseSync: parseSync2,
+    parseInBatches: async function* generator(asyncIterator, options, context) {
+      for await (const batch of asyncIterator) {
+        yield parseSync2(batch, options, context);
+      }
+    },
+    tests: [() => false],
+    options: {
+      null: {}
+    }
+  };
   function parseSync2(arrayBuffer, options, context) {
     return null;
   }
-  var VERSION4, NullWorkerLoader, NullLoader;
-  var init_null_loader = __esm({
-    "src/null-loader.ts"() {
-      VERSION4 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
-      NullWorkerLoader = {
-        name: "Null loader",
-        id: "null",
-        module: "core",
-        version: VERSION4,
-        worker: true,
-        mimeTypes: ["application/x.empty"],
-        extensions: ["null"],
-        tests: [() => false],
-        options: {
-          null: {}
-        }
-      };
-      NullLoader = {
-        name: "Null loader",
-        id: "null",
-        module: "core",
-        version: VERSION4,
-        mimeTypes: ["application/x.empty"],
-        extensions: ["null"],
-        parse: async (arrayBuffer, options, context) => parseSync2(arrayBuffer, options || {}, context),
-        parseSync: parseSync2,
-        parseInBatches: async function* generator(asyncIterator, options, context) {
-          for await (const batch of asyncIterator) {
-            yield parseSync2(batch, options, context);
-          }
-        },
-        tests: [() => false],
-        options: {
-          null: {}
-        }
-      };
-    }
-  });
 
   // src/lib/progress/fetch-progress.ts
   async function fetchProgress(response, onProgress, onDone = () => {
@@ -3690,7 +3516,10 @@
   }
   async function read(controller, reader, loadedBytes, totalBytes, onProgress, onDone, onError) {
     try {
-      const { done, value } = await reader.read();
+      const {
+        done,
+        value
+      } = await reader.read();
       if (done) {
         onDone();
         controller.close();
@@ -3698,7 +3527,10 @@
       }
       loadedBytes += value.byteLength;
       const percent = Math.round(loadedBytes / totalBytes * 100);
-      onProgress(percent, { loadedBytes, totalBytes });
+      onProgress(percent, {
+        loadedBytes,
+        totalBytes
+      });
       controller.enqueue(value);
       await read(controller, reader, loadedBytes, totalBytes, onProgress, onDone, onError);
     } catch (error) {
@@ -3706,198 +3538,110 @@
       onError(error);
     }
   }
-  var init_fetch_progress = __esm({
-    "src/lib/progress/fetch-progress.ts"() {
-    }
-  });
 
   // src/lib/filesystems/browser-filesystem.ts
-  var BrowserFileSystem;
-  var init_browser_filesystem = __esm({
-    "src/lib/filesystems/browser-filesystem.ts"() {
-      BrowserFileSystem = class {
-        constructor(files, options) {
-          this.files = {};
-          this.lowerCaseFiles = {};
-          this.usedFiles = {};
-          this._fetch = options?.fetch || fetch;
-          for (let i = 0; i < files.length; ++i) {
-            const file = files[i];
-            this.files[file.name] = file;
-            this.lowerCaseFiles[file.name.toLowerCase()] = file;
-            this.usedFiles[file.name] = false;
-          }
-          this.fetch = this.fetch.bind(this);
-        }
-        async fetch(path, options) {
-          if (path.includes("://")) {
-            return this._fetch(path, options);
-          }
-          const file = this.files[path];
-          if (!file) {
-            return new Response(path, { status: 400, statusText: "NOT FOUND" });
-          }
-          const headers = new Headers(options?.headers);
-          const range = headers.get("Range");
-          const bytes = range && /bytes=($1)-($2)/.exec(range);
-          if (bytes) {
-            const start = parseInt(bytes[1]);
-            const end = parseInt(bytes[2]);
-            const data = await file.slice(start, end).arrayBuffer();
-            const response2 = new Response(data);
-            Object.defineProperty(response2, "url", { value: path });
-            return response2;
-          }
-          const response = new Response(file);
-          Object.defineProperty(response, "url", { value: path });
-          return response;
-        }
-        async readdir(dirname2) {
-          const files = [];
-          for (const path in this.files) {
-            files.push(path);
-          }
-          return files;
-        }
-        async stat(path, options) {
-          const file = this.files[path];
-          if (!file) {
-            throw new Error(path);
-          }
-          return { size: file.size };
-        }
-        async unlink(path) {
-          delete this.files[path];
-          delete this.lowerCaseFiles[path];
-          this.usedFiles[path] = true;
-        }
-        async open(pathname, flags, mode) {
-          return this.files[pathname];
-        }
-        async read(fd, buffer, offset = 0, length = buffer.byteLength, position = null) {
-          const file = fd;
-          const startPosition = 0;
-          const arrayBuffer = await file.slice(startPosition, startPosition + length).arrayBuffer();
-          return { bytesRead: length, buffer: arrayBuffer };
-        }
-        async close(fd) {
-        }
-        _getFile(path, used) {
-          const file = this.files[path] || this.lowerCaseFiles[path];
-          if (file && used) {
-            this.usedFiles[path] = true;
-          }
-          return file;
-        }
-      };
+  var BrowserFileSystem = class {
+    files = {};
+    lowerCaseFiles = {};
+    usedFiles = {};
+    /**
+     * A FileSystem API wrapper around a list of browser 'File' objects
+     * @param files
+     * @param options
+     */
+    constructor(files, options) {
+      this._fetch = options?.fetch || fetch;
+      for (let i = 0; i < files.length; ++i) {
+        const file = files[i];
+        this.files[file.name] = file;
+        this.lowerCaseFiles[file.name.toLowerCase()] = file;
+        this.usedFiles[file.name] = false;
+      }
+      this.fetch = this.fetch.bind(this);
+    }
+    // implements IFileSystem
+    /**
+     * Implementation of fetch against this file system
+     * Delegates to global fetch for http{s}:// or data://
+     */
+    async fetch(path, options) {
+      if (path.includes("://")) {
+        return this._fetch(path, options);
+      }
+      const file = this.files[path];
+      if (!file) {
+        return new Response(path, {
+          status: 400,
+          statusText: "NOT FOUND"
+        });
+      }
+      const headers = new Headers(options?.headers);
+      const range = headers.get("Range");
+      const bytes = range && /bytes=($1)-($2)/.exec(range);
+      if (bytes) {
+        const start = parseInt(bytes[1]);
+        const end = parseInt(bytes[2]);
+        const data = await file.slice(start, end).arrayBuffer();
+        const response2 = new Response(data);
+        Object.defineProperty(response2, "url", {
+          value: path
+        });
+        return response2;
+      }
+      const response = new Response(file);
+      Object.defineProperty(response, "url", {
+        value: path
+      });
+      return response;
     }
-  });
-
-  // src/index.ts
-  var src_exports = {};
-  __export(src_exports, {
-    JSONLoader: () => JSONLoader,
-    NullLoader: () => NullLoader,
-    NullWorkerLoader: () => NullWorkerLoader,
-    RequestScheduler: () => RequestScheduler,
-    _BrowserFileSystem: () => BrowserFileSystem,
-    _fetchProgress: () => fetchProgress,
-    _unregisterLoaders: () => _unregisterLoaders,
-    assert: () => assert,
-    concatenateArrayBuffersAsync: () => concatenateArrayBuffersAsync,
-    document: () => document_,
-    encode: () => encode,
-    encodeInBatches: () => encodeInBatches,
-    encodeSync: () => encodeSync,
-    encodeTable: () => encodeTable,
-    encodeTableAsText: () => encodeTableAsText,
-    encodeTableInBatches: () => encodeTableInBatches,
-    encodeText: () => encodeText,
-    encodeTextSync: () => encodeTextSync,
-    encodeURLtoURL: () => encodeURLtoURL,
-    fetchFile: () => fetchFile,
-    forEach: () => forEach,
-    getLoaderOptions: () => getGlobalLoaderOptions,
-    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: () => makeLineIterator,
-    makeNumberedLineIterator: () => makeNumberedLineIterator,
-    makeStream: () => makeStream,
-    makeTextDecoderIterator: () => makeTextDecoderIterator,
-    makeTextEncoderIterator: () => makeTextEncoderIterator,
-    parse: () => parse,
-    parseInBatches: () => parseInBatches,
-    parseSync: () => parseSync,
-    readArrayBuffer: () => readArrayBuffer,
-    readFileSync: () => readFileSync,
-    registerLoaders: () => registerLoaders,
-    resolvePath: () => resolvePath,
-    save: () => save,
-    saveSync: () => saveSync,
-    selectLoader: () => selectLoader,
-    selectLoaderSync: () => selectLoaderSync,
-    self: () => self_,
-    setLoaderOptions: () => setGlobalOptions,
-    setPathPrefix: () => setPathPrefix,
-    window: () => window_,
-    writeFile: () => writeFile,
-    writeFileSync: () => writeFileSync
-  });
-  var init_src3 = __esm({
-    "src/index.ts"() {
-      init_fetch_file();
-      init_read_array_buffer();
-      init_read_file();
-      init_write_file();
-      init_loader_options();
-      init_register_loaders();
-      init_select_loader();
-      init_parse();
-      init_parse_sync();
-      init_parse_in_batches();
-      init_load();
-      init_load_in_batches();
-      init_encode_table();
-      init_encode();
-      init_encode();
-      init_save();
-      init_src2();
-      init_src2();
-      init_make_iterator();
-      init_make_dom_stream();
-      init_null_loader();
-      init_src2();
-      init_fetch_progress();
-      init_browser_filesystem();
-      init_register_loaders();
-      init_src2();
-      init_src2();
-      init_src2();
-      init_src2();
-      init_is_type();
+    /**
+     * List filenames in this filesystem
+     * @param dirname
+     * @returns
+     */
+    async readdir(dirname2) {
+      const files = [];
+      for (const path in this.files) {
+        files.push(path);
+      }
+      return files;
+    }
+    /**
+     * Return information (size) about files in this file system
+     */
+    async stat(path, options) {
+      const file = this.files[path];
+      if (!file) {
+        throw new Error(path);
+      }
+      return {
+        size: file.size
+      };
     }
-  });
-
-  // src/bundle.ts
-  var require_bundle = __commonJS({
-    "src/bundle.ts"(exports, module) {
-      var moduleExports = (init_src3(), src_exports);
-      globalThis.loaders = globalThis.loaders || {};
-      module.exports = Object.assign(globalThis.loaders, moduleExports);
+    /**
+     * Just removes the file from the list
+     */
+    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 BlobFile(this.files[pathname]);
+    }
+    // PRIVATE
+    // Supports case independent paths, and file usage tracking
+    _getFile(path, used) {
+      const file = this.files[path] || this.lowerCaseFiles[path];
+      if (file && used) {
+        this.usedFiles[path] = true;
+      }
+      return file;
     }
-  });
-  require_bundle();
+  };
+  return __toCommonJS(src_exports);
 })();
+      return __exports__;
+      });