@loaders.gl/i3s 4.2.0-alpha.6 → 4.2.0-beta.2

package/dist/i3s-content-worker.js

@@ -1,47 +1,16 @@
 "use strict";
 (() => {
-  var __create = Object.create;
   var __defProp = Object.defineProperty;
-  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-  var __getOwnPropNames = Object.getOwnPropertyNames;
-  var __getProtoOf = Object.getPrototypeOf;
-  var __hasOwnProp = Object.prototype.hasOwnProperty;
   var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-  var __commonJS = (cb, mod) => function __require() {
-    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
-  };
   var __export = (target, all) => {
     for (var name in all)
       __defProp(target, name, { get: all[name], enumerable: true });
   };
-  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 to;
-  };
-  var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-    // If the importer is in node compatibility mode or this is not an ESM
-    // file that has been converted to a CommonJS file using a Babel-
-    // compatible transform (i.e. "__esModule" has not been set), then set
-    // "default" to the CommonJS "module.exports" for node compatibility.
-    isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-    mod
-  ));
   var __publicField = (obj, key, value) => {
     __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
     return value;
   };
 
-  // (disabled):../worker-utils/src/lib/node/require-utils.node
-  var require_require_utils = __commonJS({
-    "(disabled):../worker-utils/src/lib/node/require-utils.node"() {
-      "use strict";
-    }
-  });
-
   // ../loader-utils/src/loader-types.ts
   async function parseFromContext(data, loaders, options, context) {
     return context._parse(data, loaders, options, context);
@@ -72,1875 +41,1921 @@
   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);
+  // ../../node_modules/@babel/runtime/helpers/esm/typeof.js
+  function _typeof(obj) {
+    "@babel/helpers - typeof";
+    return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(obj2) {
+      return typeof obj2;
+    } : function(obj2) {
+      return obj2 && "function" == typeof Symbol && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
+    }, _typeof(obj);
   }
-  function mergeOptionsRecursively(baseOptions, newOptions, level = 0) {
-    if (level > 3) {
-      return newOptions;
-    }
-    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],
-          level + 1
-        );
-      } else {
-        options[key] = newOptions[key];
-      }
+
+  // ../../node_modules/@babel/runtime/helpers/esm/toPrimitive.js
+  function _toPrimitive(input, hint) {
+    if (_typeof(input) !== "object" || input === null)
+      return input;
+    var prim = input[Symbol.toPrimitive];
+    if (prim !== void 0) {
+      var res = prim.call(input, hint || "default");
+      if (_typeof(res) !== "object")
+        return res;
+      throw new TypeError("@@toPrimitive must return a primitive value.");
     }
-    return options;
+    return (hint === "string" ? String : Number)(input);
   }
 
-  // ../worker-utils/src/lib/env-utils/version.ts
-  var NPM_TAG = "latest";
-  function getVersion() {
-    if (!globalThis._loadersgl_?.version) {
-      globalThis._loadersgl_ = globalThis._loadersgl_ || {};
-      if (false) {
-        console.warn(
-          "loaders.gl: The __VERSION__ variable is not injected using babel plugin. Latest unstable workers would be fetched from the CDN."
-        );
-        globalThis._loadersgl_.version = NPM_TAG;
-      } else {
-        globalThis._loadersgl_.version = "4.2.0-alpha.5";
-      }
+  // ../../node_modules/@babel/runtime/helpers/esm/toPropertyKey.js
+  function _toPropertyKey(arg) {
+    var key = _toPrimitive(arg, "string");
+    return _typeof(key) === "symbol" ? key : String(key);
+  }
+
+  // ../../node_modules/@babel/runtime/helpers/esm/defineProperty.js
+  function _defineProperty(obj, key, value) {
+    key = _toPropertyKey(key);
+    if (key in obj) {
+      Object.defineProperty(obj, key, {
+        value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+      });
+    } else {
+      obj[key] = value;
     }
-    return globalThis._loadersgl_.version;
+    return obj;
   }
-  var VERSION = getVersion();
 
-  // ../worker-utils/src/lib/env-utils/assert.ts
-  function assert2(condition, message) {
-    if (!condition) {
-      throw new Error(message || "loaders.gl assertion failed.");
+  // ../../node_modules/@probe.gl/log/node_modules/@probe.gl/env/dist/lib/is-electron.js
+  function isElectron(mockUserAgent) {
+    if (typeof window !== "undefined" && typeof window.process === "object" && window.process.type === "renderer") {
+      return true;
+    }
+    if (typeof process !== "undefined" && typeof process.versions === "object" && Boolean(process.versions["electron"])) {
+      return true;
     }
+    const realUserAgent = typeof navigator === "object" && typeof navigator.userAgent === "string" && navigator.userAgent;
+    const userAgent = mockUserAgent || realUserAgent;
+    if (userAgent && userAgent.indexOf("Electron") >= 0) {
+      return true;
+    }
+    return false;
   }
 
-  // ../worker-utils/src/lib/env-utils/globals.ts
-  var globals2 = {
-    self: typeof self !== "undefined" && self,
-    window: typeof window !== "undefined" && window,
-    global: typeof global !== "undefined" && global,
-    document: typeof document !== "undefined" && document
-  };
-  var self_2 = globals2.self || globals2.window || globals2.global || {};
-  var window_2 = globals2.window || globals2.self || globals2.global || {};
-  var global_2 = globals2.global || globals2.self || globals2.window || {};
-  var document_2 = globals2.document || {};
-  var isBrowser2 = (
-    // @ts-ignore process.browser
-    typeof process !== "object" || String(process) !== "[object process]" || process.browser
-  );
-  var isWorker = typeof importScripts === "function";
-  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;
+  // ../../node_modules/@probe.gl/log/node_modules/@probe.gl/env/dist/lib/is-browser.js
+  function isBrowser2() {
+    const isNode = typeof process === "object" && String(process) === "[object process]" && !process.browser;
+    return !isNode || isElectron();
+  }
 
-  // ../worker-utils/src/lib/worker-farm/worker-job.ts
-  var WorkerJob = class {
-    name;
-    workerThread;
-    isRunning = true;
-    /** Promise that resolves when Job is done */
-    result;
-    _resolve = () => {
-    };
-    _reject = () => {
-    };
-    constructor(jobName, workerThread) {
-      this.name = jobName;
-      this.workerThread = workerThread;
-      this.result = new Promise((resolve2, reject) => {
-        this._resolve = resolve2;
-        this._reject = reject;
-      });
+  // ../../node_modules/@probe.gl/log/node_modules/@probe.gl/env/dist/lib/globals.js
+  var self_2 = globalThis.self || globalThis.window || globalThis.global;
+  var window_2 = globalThis.window || globalThis.self || globalThis.global;
+  var document_2 = 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 VERSION = true ? "4.2.0-beta.1" : "untranspiled source";
+  var isBrowser3 = isBrowser2();
+
+  // ../../node_modules/@probe.gl/log/dist/utils/local-storage.js
+  function getStorage(type) {
+    try {
+      const storage = window[type];
+      const x = "__storage_test__";
+      storage.setItem(x, x);
+      storage.removeItem(x);
+      return storage;
+    } catch (e2) {
+      return null;
     }
-    /**
-     * 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
-      });
+  }
+  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();
     }
-    /**
-     * Call to resolve the `result` Promise with the supplied value
-     */
-    done(value) {
-      assert2(this.isRunning);
-      this.isRunning = false;
-      this._resolve(value);
+    getConfiguration() {
+      return this.config;
     }
-    /**
-     * Call to reject the `result` Promise with the supplied error
-     */
-    error(error) {
-      assert2(this.isRunning);
-      this.isRunning = false;
-      this._reject(error);
+    setConfiguration(configuration) {
+      Object.assign(this.config, configuration);
+      if (this.storage) {
+        const serialized = JSON.stringify(this.config);
+        this.storage.setItem(this.id, serialized);
+      }
     }
-  };
-
-  // ../worker-utils/src/lib/node/worker_threads-browser.ts
-  var NodeWorker = class {
-    terminate() {
+    _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 parentPort = null;
 
-  // ../worker-utils/src/lib/worker-utils/get-loadable-worker-url.ts
-  var workerURLCache = /* @__PURE__ */ new Map();
-  function getLoadableWorkerURL(props) {
-    assert2(props.source && !props.url || !props.source && props.url);
-    let workerURL = workerURLCache.get(props.source || props.url);
-    if (!workerURL) {
-      if (props.url) {
-        workerURL = getLoadableWorkerURLFromURL(props.url);
-        workerURLCache.set(props.url, workerURL);
-      }
-      if (props.source) {
-        workerURL = getLoadableWorkerURLFromSource(props.source);
-        workerURLCache.set(props.source, workerURL);
-      }
+  // ../../node_modules/@probe.gl/log/dist/utils/formatters.js
+  function formatTime(ms) {
+    let formatted;
+    if (ms < 10) {
+      formatted = "".concat(ms.toFixed(2), "ms");
+    } else if (ms < 100) {
+      formatted = "".concat(ms.toFixed(1), "ms");
+    } else if (ms < 1e3) {
+      formatted = "".concat(ms.toFixed(0), "ms");
+    } else {
+      formatted = "".concat((ms / 1e3).toFixed(2), "s");
     }
-    assert2(workerURL);
-    return workerURL;
+    return formatted;
   }
-  function getLoadableWorkerURLFromURL(url) {
-    if (!url.startsWith("http")) {
-      return url;
-    }
-    const workerSource = buildScriptSource(url);
-    return getLoadableWorkerURLFromSource(workerSource);
+  function leftPad(string) {
+    let length2 = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 8;
+    const padLength = Math.max(length2 - string.length, 0);
+    return "".concat(" ".repeat(padLength)).concat(string);
   }
-  function getLoadableWorkerURLFromSource(workerSource) {
-    const blob = new Blob([workerSource], { type: "application/javascript" });
-    return URL.createObjectURL(blob);
-  }
-  function buildScriptSource(workerUrl) {
-    return `try {
-  importScripts('${workerUrl}');
-} catch (error) {
-  console.error(error);
-  throw error;
-}`;
+  function formatImage(image, message, scale3) {
+    let maxWidth = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : 600;
+    const imageUrl = image.src.replace(/\(/g, "%28").replace(/\)/g, "%29");
+    if (image.width > maxWidth) {
+      scale3 = Math.min(scale3, maxWidth / image.width);
+    }
+    const width = image.width * scale3;
+    const height = image.height * scale3;
+    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];
   }
 
-  // ../worker-utils/src/lib/worker-utils/get-transfer-list.ts
-  function getTransferList(object, recursive = true, transfers) {
-    const transfersSet = transfers || /* @__PURE__ */ new Set();
-    if (!object) {
-    } else if (isTransferable(object)) {
-      transfersSet.add(object);
-    } else if (isTransferable(object.buffer)) {
-      transfersSet.add(object.buffer);
-    } else if (ArrayBuffer.isView(object)) {
-    } else if (recursive && typeof object === "object") {
-      for (const key in object) {
-        getTransferList(object[key], recursive, transfersSet);
-      }
+  // ../../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;
     }
-    return transfers === void 0 ? Array.from(transfersSet) : [];
+    color = color.toUpperCase();
+    return COLOR[color] || COLOR.WHITE;
   }
-  function isTransferable(object) {
-    if (!object) {
-      return false;
-    }
-    if (object instanceof ArrayBuffer) {
-      return true;
+  function addColor(string, color, background) {
+    if (!isBrowser2 && typeof string === "string") {
+      if (color) {
+        const colorCode = getColor(color);
+        string = "\x1B[".concat(colorCode, "m").concat(string, "\x1B[39m");
+      }
+      if (background) {
+        const colorCode = getColor(background);
+        string = "\x1B[".concat(colorCode + BACKGROUND_INCREMENT, "m").concat(string, "\x1B[49m");
+      }
     }
-    if (typeof MessagePort !== "undefined" && object instanceof MessagePort) {
-      return true;
+    return string;
+  }
+
+  // ../../node_modules/@probe.gl/log/dist/utils/autobind.js
+  function autobind(obj) {
+    let predefined = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : ["constructor"];
+    const proto = Object.getPrototypeOf(obj);
+    const propNames = Object.getOwnPropertyNames(proto);
+    const object = obj;
+    for (const key of propNames) {
+      const value = object[key];
+      if (typeof value === "function") {
+        if (!predefined.find((name) => key === name)) {
+          object[key] = value.bind(obj);
+        }
+      }
     }
-    if (typeof ImageBitmap !== "undefined" && object instanceof ImageBitmap) {
-      return true;
+  }
+
+  // ../../node_modules/@probe.gl/log/dist/utils/assert.js
+  function assert2(condition, message) {
+    if (!condition) {
+      throw new Error(message || "Assertion failed");
     }
-    if (typeof OffscreenCanvas !== "undefined" && object instanceof OffscreenCanvas) {
-      return true;
+  }
+
+  // ../../node_modules/@probe.gl/log/dist/utils/hi-res-timestamp.js
+  function getHiResTimestamp() {
+    let timestamp;
+    if (isBrowser2() && window_2.performance) {
+      var _window$performance, _window$performance$n;
+      timestamp = window_2 === null || window_2 === void 0 ? void 0 : (_window$performance = window_2.performance) === null || _window$performance === void 0 ? void 0 : (_window$performance$n = _window$performance.now) === null || _window$performance$n === void 0 ? void 0 : _window$performance$n.call(_window$performance);
+    } else if ("hrtime" in process_) {
+      var _process$hrtime;
+      const timeParts = process_ === null || process_ === void 0 ? void 0 : (_process$hrtime = process_.hrtime) === null || _process$hrtime === void 0 ? void 0 : _process$hrtime.call(process_);
+      timestamp = timeParts[0] * 1e3 + timeParts[1] / 1e6;
+    } else {
+      timestamp = Date.now();
     }
-    return false;
+    return timestamp;
   }
 
-  // ../worker-utils/src/lib/worker-farm/worker-thread.ts
-  var NOOP = () => {
+  // ../../node_modules/@probe.gl/log/dist/log.js
+  var originalConsole = {
+    debug: isBrowser2() ? console.debug || console.log : console.log,
+    log: console.log,
+    info: console.info,
+    warn: console.warn,
+    error: console.error
   };
-  var WorkerThread = class {
-    name;
-    source;
-    url;
-    terminated = false;
-    worker;
-    onMessage;
-    onError;
-    _loadableURL = "";
-    /** Checks if workers are supported on this platform */
-    static isSupported() {
-      return typeof Worker !== "undefined" && isBrowser2 || typeof NodeWorker !== "undefined" && !isBrowser2;
+  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", VERSION);
+      _defineProperty(this, "_startTs", getHiResTimestamp());
+      _defineProperty(this, "_deltaTs", getHiResTimestamp());
+      _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);
     }
-    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();
+    set level(newLevel) {
+      this.setLevel(newLevel);
     }
-    /**
-     * Terminate this worker thread
-     * @note Can free up significant memory
-     */
-    destroy() {
-      this.onMessage = NOOP;
-      this.onError = NOOP;
-      this.worker.terminate();
-      this.terminated = true;
+    get level() {
+      return this.getLevel();
     }
-    get isRunning() {
-      return Boolean(this.onMessage);
+    isEnabled() {
+      return this._storage.config.enabled;
     }
-    /**
-     * 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);
+    getLevel() {
+      return this._storage.config.level;
     }
-    // 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);
+    getTotal() {
+      return Number((getHiResTimestamp() - this._startTs).toPrecision(10));
     }
-    /**
-     * 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;
+    getDelta() {
+      return Number((getHiResTimestamp() - this._deltaTs).toPrecision(10));
     }
-    /**
-     * 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 NodeWorker(url, { eval: false });
-      } else if (this.source) {
-        worker = new NodeWorker(this.source, { eval: true });
-      } else {
-        throw new Error("no worker");
-      }
-      worker.on("message", (data) => {
-        this.onMessage(data);
-      });
-      worker.on("error", (error) => {
-        this.onError(error);
-      });
-      worker.on("exit", (code) => {
-      });
-      return worker;
+    set priority(newPriority) {
+      this.level = newPriority;
     }
-  };
-
-  // ../worker-utils/src/lib/worker-farm/worker-pool.ts
-  var WorkerPool = class {
-    name = "unnamed";
-    source;
-    // | Function;
-    url;
-    maxConcurrency = 1;
-    maxMobileConcurrency = 1;
-    onDebug = () => {
-    };
-    reuseWorkers = true;
-    props = {};
-    jobQueue = [];
-    idleQueue = [];
-    count = 0;
-    isDestroyed = false;
-    /** Checks if workers are supported on this platform */
-    static isSupported() {
-      return WorkerThread.isSupported();
-    }
-    /**
-     * @param processor - worker function
-     * @param maxConcurrency - max count of workers
-     */
-    constructor(props) {
-      this.source = props.source;
-      this.url = props.url;
-      this.setProps(props);
+    get priority() {
+      return this.level;
     }
-    /**
-     * Terminates all workers in the pool
-     * @note Can free up significant memory
-     */
-    destroy() {
-      this.idleQueue.forEach((worker) => worker.destroy());
-      this.isDestroyed = true;
+    getPriority() {
+      return this.level;
     }
-    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;
-      }
+    enable() {
+      let enabled = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : true;
+      this._storage.setConfiguration({
+        enabled
+      });
+      return this;
     }
-    async startJob(name, onMessage2 = (job, type, data) => job.done(data), onError = (job, error) => job.error(error)) {
-      const startPromise = new Promise((onStart) => {
-        this.jobQueue.push({ name, onMessage: onMessage2, onError, onStart });
-        return this;
+    setLevel(level) {
+      this._storage.setConfiguration({
+        level
       });
-      this._startQueuedJob();
-      return await startPromise;
+      return this;
     }
-    // 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);
-        }
-      }
+    get(setting) {
+      return this._storage.config[setting];
     }
-    /**
-     * 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--;
+    set(setting, value) {
+      this._storage.setConfiguration({
+        [setting]: value
+      });
+    }
+    settings() {
+      if (console.table) {
+        console.table(this._storage.config);
       } else {
-        this.idleQueue.push(worker);
-      }
-      if (!this.isDestroyed) {
-        this._startQueuedJob();
+        console.log(this._storage.config);
       }
     }
-    /**
-     * 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;
+    assert(condition, message) {
+      assert2(condition, message);
     }
-    _getMaxConcurrency() {
-      return isMobile ? this.maxMobileConcurrency : this.maxConcurrency;
+    warn(message) {
+      return this._getLogFunction(0, message, originalConsole.warn, arguments, ONCE);
     }
-  };
-
-  // ../worker-utils/src/lib/worker-farm/worker-farm.ts
-  var DEFAULT_PROPS = {
-    maxConcurrency: 3,
-    maxMobileConcurrency: 1,
-    reuseWorkers: true,
-    onDebug: () => {
+    error(message) {
+      return this._getLogFunction(0, message, originalConsole.error, arguments);
     }
-  };
-  var _WorkerFarm = class {
-    props;
-    workerPools = /* @__PURE__ */ new Map();
-    /** Checks if workers are supported on this platform */
-    static isSupported() {
-      return WorkerThread.isSupported();
+    deprecated(oldUsage, newUsage) {
+      return this.warn("`".concat(oldUsage, "` is deprecated and will be removed in a later version. Use `").concat(newUsage, "` instead"));
     }
-    /** 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;
+    removed(oldUsage, newUsage) {
+      return this.error("`".concat(oldUsage, "` has been removed. Use `").concat(newUsage, "` instead"));
     }
-    /** get global instance with WorkerFarm.getWorkerFarm() */
-    constructor(props) {
-      this.props = { ...DEFAULT_PROPS };
-      this.setProps(props);
-      this.workerPools = /* @__PURE__ */ new Map();
+    probe(logLevel, message) {
+      return this._getLogFunction(logLevel, message, originalConsole.log, arguments, {
+        time: true,
+        once: true
+      });
     }
-    /**
-     * 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();
+    log(logLevel, message) {
+      return this._getLogFunction(logLevel, message, originalConsole.debug, arguments);
     }
-    /**
-     * 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());
-      }
+    info(logLevel, message) {
+      return this._getLogFunction(logLevel, message, console.info, arguments);
     }
-    /**
-     * 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
+    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)
         });
-        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
-      };
+      return noop;
     }
-  };
-  var WorkerFarm = _WorkerFarm;
-  // singleton
-  __publicField(WorkerFarm, "_workerFarm");
-
-  // ../worker-utils/src/lib/worker-farm/worker-body.ts
-  async function getParentPort() {
-    return parentPort;
-  }
-  var onMessageWrapperMap = /* @__PURE__ */ new Map();
-  var WorkerBody = class {
-    /** Check that we are actually in a worker thread */
-    static async inWorkerThread() {
-      return typeof self !== "undefined" || Boolean(await getParentPort());
-    }
-    /*
-     * (type: WorkerMessageType, payload: WorkerMessagePayload) => any
-     */
-    static set onmessage(onMessage2) {
-      async function handleMessage(message) {
-        const parentPort2 = await getParentPort();
-        const { type, payload } = parentPort2 ? message : message.data;
-        onMessage2(type, payload);
+    image(_ref) {
+      let {
+        logLevel,
+        priority,
+        image,
+        message = "",
+        scale: scale3 = 1
+      } = _ref;
+      if (!this._shouldLog(logLevel || priority)) {
+        return noop;
       }
-      getParentPort().then((parentPort2) => {
-        if (parentPort2) {
-          parentPort2.on("message", (message) => {
-            handleMessage(message);
-          });
-          parentPort2.on("exit", () => console.debug("Node worker closing"));
-        } else {
-          globalThis.onmessage = handleMessage;
-        }
+      return isBrowser2() ? logImageInBrowser({
+        image,
+        message,
+        scale: scale3
+      }) : logImageInNode({
+        image,
+        message,
+        scale: scale3
       });
     }
-    static async addEventListener(onMessage2) {
-      let onMessageWrapper = onMessageWrapperMap.get(onMessage2);
-      if (!onMessageWrapper) {
-        onMessageWrapper = async (message) => {
-          if (!isKnownMessage(message)) {
-            return;
-          }
-          const parentPort3 = await getParentPort();
-          const { type, payload } = parentPort3 ? message : message.data;
-          onMessage2(type, payload);
-        };
-      }
-      const parentPort2 = await getParentPort();
-      if (parentPort2) {
-        console.error("not implemented");
-      } else {
-        globalThis.addEventListener("message", onMessageWrapper);
-      }
-    }
-    static async removeEventListener(onMessage2) {
-      const onMessageWrapper = onMessageWrapperMap.get(onMessage2);
-      onMessageWrapperMap.delete(onMessage2);
-      const parentPort2 = await getParentPort();
-      if (parentPort2) {
-        console.error("not implemented");
-      } else {
-        globalThis.removeEventListener("message", onMessageWrapper);
-      }
+    time(logLevel, message) {
+      return this._getLogFunction(logLevel, message, console.time ? console.time : console.info);
     }
-    /**
-     * Send a message from a worker to creating thread (main thread)
-     * @param type
-     * @param payload
-     */
-    static async postMessage(type, payload) {
-      const data = { source: "loaders.gl", type, payload };
-      const transferList = getTransferList(payload);
-      const parentPort2 = await getParentPort();
-      if (parentPort2) {
-        parentPort2.postMessage(data, transferList);
-      } else {
-        globalThis.postMessage(data, transferList);
-      }
+    timeEnd(logLevel, message) {
+      return this._getLogFunction(logLevel, message, console.timeEnd ? console.timeEnd : console.info);
     }
-  };
-  function isKnownMessage(message) {
-    const { type, data } = message;
-    return type === "message" && data && typeof data.source === "string" && data.source.startsWith("loaders.gl");
-  }
-
-  // ../worker-utils/src/lib/worker-api/get-worker-url.ts
-  function getWorkerURL(worker, options = {}) {
-    const workerOptions = options[worker.id] || {};
-    const workerFile = isBrowser2 ? `${worker.id}-worker.js` : `${worker.id}-worker-node.js`;
-    let url = workerOptions.workerUrl;
-    if (!url && worker.id === "compression") {
-      url = options.workerUrl;
+    timeStamp(logLevel, message) {
+      return this._getLogFunction(logLevel, message, console.timeStamp || noop);
     }
-    if (options._workerType === "test") {
-      if (isBrowser2) {
-        url = `modules/${worker.module}/dist/${workerFile}`;
-      } else {
-        url = `modules/${worker.module}/src/workers/${worker.id}-worker-node.ts`;
-      }
+    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);
     }
-    if (!url) {
-      let version = worker.version;
-      if (version === "latest") {
-        version = NPM_TAG;
-      }
-      const versionTag = version ? `@${version}` : "";
-      url = `https://unpkg.com/@loaders.gl/${worker.module}${versionTag}/dist/${workerFile}`;
+    groupCollapsed(logLevel, message) {
+      let opts = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
+      return this.group(logLevel, message, Object.assign({}, opts, {
+        collapsed: true
+      }));
     }
-    assert2(url);
-    return url;
-  }
-
-  // ../worker-utils/src/lib/worker-api/validate-worker-version.ts
-  function validateWorkerVersion(worker, coreVersion = VERSION) {
-    assert2(worker, "no worker provided");
-    const workerVersion = worker.version;
-    if (!coreVersion || !workerVersion) {
-      return false;
+    groupEnd(logLevel) {
+      return this._getLogFunction(logLevel, "", console.groupEnd || noop);
     }
-    return true;
-  }
-
-  // ../worker-utils/src/lib/library-utils/library-utils.ts
-  var node = __toESM(require_require_utils(), 1);
-  var loadLibraryPromises = {};
-  async function loadLibrary(libraryUrl, moduleName = null, options = {}, libraryName = null) {
-    if (moduleName) {
-      libraryUrl = getLibraryUrl(libraryUrl, moduleName, options, libraryName);
+    withGroup(logLevel, message, func) {
+      this.group(logLevel, message)();
+      try {
+        func();
+      } finally {
+        this.groupEnd(logLevel)();
+      }
     }
-    loadLibraryPromises[libraryUrl] = // eslint-disable-next-line @typescript-eslint/no-misused-promises
-    loadLibraryPromises[libraryUrl] || loadLibraryFromFile(libraryUrl);
-    return await loadLibraryPromises[libraryUrl];
-  }
-  function getLibraryUrl(library, moduleName, options = {}, libraryName = null) {
-    if (!options.useLocalLibraries && library.startsWith("http")) {
-      return library;
+    trace() {
+      if (console.trace) {
+        console.trace();
+      }
     }
-    libraryName = libraryName || library;
-    const modules = options.modules || {};
-    if (modules[libraryName]) {
-      return modules[libraryName];
+    _shouldLog(logLevel) {
+      return this.isEnabled() && this.getLevel() >= normalizeLogLevel(logLevel);
     }
-    if (!isBrowser2) {
-      return `modules/${moduleName}/dist/libs/${libraryName}`;
+    _getLogFunction(logLevel, message, method, args, opts) {
+      if (this._shouldLog(logLevel)) {
+        opts = normalizeArguments({
+          logLevel,
+          message,
+          args,
+          opts
+        });
+        method = method || opts.method;
+        assert2(method);
+        opts.total = this.getTotal();
+        opts.delta = this.getDelta();
+        this._deltaTs = getHiResTimestamp();
+        const tag = opts.tag || opts.message;
+        if (opts.once && tag) {
+          if (!cache[tag]) {
+            cache[tag] = getHiResTimestamp();
+          } else {
+            return noop;
+          }
+        }
+        message = decorateMessage(this.id, opts.message, opts);
+        return method.bind(console, message, ...opts.args);
+      }
+      return noop;
     }
-    if (options.CDN) {
-      assert2(options.CDN.startsWith("http"));
-      return `${options.CDN}/${moduleName}@${VERSION}/dist/libs/${libraryName}`;
+  };
+  _defineProperty(Log, "VERSION", VERSION);
+  function normalizeLogLevel(logLevel) {
+    if (!logLevel) {
+      return 0;
     }
-    if (isWorker) {
-      return `../src/libs/${libraryName}`;
+    let resolvedLevel;
+    switch (typeof logLevel) {
+      case "number":
+        resolvedLevel = logLevel;
+        break;
+      case "object":
+        resolvedLevel = logLevel.logLevel || logLevel.priority || 0;
+        break;
+      default:
+        return 0;
     }
-    return `modules/${moduleName}/src/libs/${libraryName}`;
+    assert2(Number.isFinite(resolvedLevel) && resolvedLevel >= 0);
+    return resolvedLevel;
   }
-  async function loadLibraryFromFile(libraryUrl) {
-    if (libraryUrl.endsWith("wasm")) {
-      return await loadAsArrayBuffer(libraryUrl);
+  function normalizeArguments(opts) {
+    const {
+      logLevel,
+      message
+    } = opts;
+    opts.logLevel = normalizeLogLevel(logLevel);
+    const args = opts.args ? Array.from(opts.args) : [];
+    while (args.length && args.shift() !== message) {
     }
-    if (!isBrowser2) {
-      try {
-        return node && void 0 && await (void 0)(libraryUrl);
-      } catch (error) {
-        console.error(error);
-        return null;
-      }
+    switch (typeof logLevel) {
+      case "string":
+      case "function":
+        if (message !== void 0) {
+          args.unshift(message);
+        }
+        opts.message = logLevel;
+        break;
+      case "object":
+        Object.assign(opts, logLevel);
+        break;
+      default:
     }
-    if (isWorker) {
-      return importScripts(libraryUrl);
+    if (typeof opts.message === "function") {
+      opts.message = opts.message();
     }
-    const scriptSource = await loadAsText(libraryUrl);
-    return loadLibraryFromString(scriptSource, libraryUrl);
+    const messageType = typeof opts.message;
+    assert2(messageType === "string" || messageType === "object");
+    return Object.assign(opts, {
+      args
+    }, opts.opts);
   }
-  function loadLibraryFromString(scriptSource, id) {
-    if (!isBrowser2) {
-      return void 0 && (void 0)(scriptSource, id);
-    }
-    if (isWorker) {
-      eval.call(globalThis, scriptSource);
-      return null;
-    }
-    const script = document.createElement("script");
-    script.id = id;
-    try {
-      script.appendChild(document.createTextNode(scriptSource));
-    } catch (e2) {
-      script.text = scriptSource;
+  function decorateMessage(id, message, opts) {
+    if (typeof message === "string") {
+      const time = opts.time ? leftPad(formatTime(opts.total)) : "";
+      message = opts.time ? "".concat(id, ": ").concat(time, "  ").concat(message) : "".concat(id, ": ").concat(message);
+      message = addColor(message, opts.color, opts.background);
     }
-    document.body.appendChild(script);
-    return null;
+    return message;
   }
-  async function loadAsArrayBuffer(url) {
-    if (isBrowser2 || !void 0 || url.startsWith("http")) {
-      const response = await fetch(url);
-      return await response.arrayBuffer();
-    }
-    return await (void 0)(url);
+  function logImageInNode(_ref2) {
+    let {
+      image,
+      message = "",
+      scale: scale3 = 1
+    } = _ref2;
+    console.warn("removed");
+    return noop;
   }
-  async function loadAsText(url) {
-    if (isBrowser2 || !void 0 || url.startsWith("http")) {
-      const response = await fetch(url);
-      return await response.text();
+  function logImageInBrowser(_ref3) {
+    let {
+      image,
+      message = "",
+      scale: scale3 = 1
+    } = _ref3;
+    if (typeof image === "string") {
+      const img = new Image();
+      img.onload = () => {
+        const args = formatImage(img, message, scale3);
+        console.log(...args);
+      };
+      img.src = image;
+      return noop;
     }
-    return await (void 0)(url);
-  }
-
-  // ../loader-utils/src/lib/worker-loader-utils/create-loader-worker.ts
-  var requestId = 0;
-  async function createLoaderWorker(loader) {
-    if (!await WorkerBody.inWorkerThread()) {
-      return;
+    const element = image.nodeName || "";
+    if (element.toLowerCase() === "img") {
+      console.log(...formatImage(image, message, scale3));
+      return noop;
     }
-    WorkerBody.onmessage = async (type, payload) => {
-      switch (type) {
-        case "process":
-          try {
-            const { input, options = {}, context = {} } = payload;
-            const result = await parseData({
-              loader,
-              arrayBuffer: input,
-              options,
-              // @ts-expect-error fetch missing
-              context: {
-                ...context,
-                _parse: parseOnMainThread
-              }
-            });
-            WorkerBody.postMessage("done", { result });
-          } catch (error) {
-            const message = error instanceof Error ? error.message : "";
-            WorkerBody.postMessage("error", { error: message });
-          }
-          break;
-        default:
-      }
-    };
-  }
-  function parseOnMainThread(arrayBuffer, loader, options, context) {
-    return new Promise((resolve2, reject) => {
-      const id = requestId++;
-      const onMessage2 = (type, payload2) => {
-        if (payload2.id !== id) {
-          return;
-        }
-        switch (type) {
-          case "done":
-            WorkerBody.removeEventListener(onMessage2);
-            resolve2(payload2.result);
-            break;
-          case "error":
-            WorkerBody.removeEventListener(onMessage2);
-            reject(payload2.error);
-            break;
-          default:
-        }
-      };
-      WorkerBody.addEventListener(onMessage2);
-      const payload = { id, input: arrayBuffer, options };
-      WorkerBody.postMessage("process", payload);
-    });
+    if (element.toLowerCase() === "canvas") {
+      const img = new Image();
+      img.onload = () => console.log(...formatImage(img, message, scale3));
+      img.src = image.toDataURL();
+      return noop;
+    }
+    return noop;
   }
-  async function parseData({
-    loader,
-    arrayBuffer,
-    options,
-    context
-  }) {
-    let data;
-    let parser;
-    if (loader.parseSync || loader.parse) {
-      data = arrayBuffer;
-      parser = loader.parseSync || loader.parse;
-    } else if (loader.parseTextSync) {
-      const textDecoder = new TextDecoder();
-      data = textDecoder.decode(arrayBuffer);
-      parser = loader.parseTextSync;
-    } else {
-      throw new Error(`Could not load data with ${loader.name} loader`);
+  function getTableHeader(table) {
+    for (const key in table) {
+      for (const title in table[key]) {
+        return title || "untitled";
+      }
     }
-    options = {
-      ...options,
-      modules: loader && loader.options && loader.options.modules || {},
-      worker: false
-    };
-    return await parser(data, { ...options }, context, loader);
+    return "empty";
   }
 
-  // ../loader-utils/src/lib/worker-loader-utils/parse-with-worker.ts
-  function canParseWithWorker(loader, options) {
-    if (!WorkerFarm.isSupported()) {
-      return false;
+  // ../../node_modules/@probe.gl/log/dist/index.js
+  var dist_default = new Log({
+    id: "@probe.gl/log"
+  });
+
+  // ../loader-utils/src/lib/option-utils/merge-loader-options.ts
+  function mergeLoaderOptions(baseOptions, newOptions) {
+    return mergeOptionsRecursively(baseOptions || {}, newOptions);
+  }
+  function mergeOptionsRecursively(baseOptions, newOptions, level = 0) {
+    if (level > 3) {
+      return newOptions;
     }
-    if (!isBrowser2 && !options?._nodeWorkers) {
-      return false;
+    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],
+          level + 1
+        );
+      } else {
+        options[key] = newOptions[key];
+      }
     }
-    return loader.worker && options?.worker;
+    return options;
   }
-  async function parseWithWorker(loader, data, options, context, parseOnMainThread2) {
-    const name = loader.id;
-    const url = getWorkerURL(loader, options);
-    const workerFarm = WorkerFarm.getWorkerFarm(options);
-    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",
-      // @ts-expect-error
-      onMessage.bind(null, parseOnMainThread2)
-      // eslint-disable-line @typescript-eslint/no-misused-promises
-    );
-    job.postMessage("process", {
-      // @ts-ignore
-      input: data,
-      options,
-      context
-    });
-    const result = await job.result;
-    return await result.result;
+
+  // ../loader-utils/src/lib/module-utils/js-module-utils.ts
+  function registerJSModules(modules) {
+    globalThis.loaders ||= {};
+    globalThis.loaders.modules ||= {};
+    Object.assign(globalThis.loaders.modules, modules);
   }
-  async function onMessage(parseOnMainThread2, job, type, payload) {
-    switch (type) {
-      case "done":
-        job.done(payload);
-        break;
-      case "error":
-        job.error(new Error(payload.error));
-        break;
-      case "process":
-        const { id, input, options } = payload;
-        try {
-          const result = await parseOnMainThread2(input, options);
-          job.postMessage("done", { id, result });
-        } catch (error) {
-          const message = error instanceof Error ? error.message : "unknown error";
-          job.postMessage("error", { id, error: message });
-        }
-        break;
-      default:
-        console.warn(`parse-with-worker unknown message ${type}`);
-    }
+  function getJSModuleOrNull(name) {
+    const module = globalThis.loaders?.modules?.[name];
+    return module || null;
   }
 
-  // ../loader-utils/src/lib/binary-utils/array-buffer-utils.ts
-  function compareArrayBuffers(arrayBuffer1, arrayBuffer2, byteLength) {
-    byteLength = byteLength || arrayBuffer1.byteLength;
-    if (arrayBuffer1.byteLength < byteLength || arrayBuffer2.byteLength < byteLength) {
-      return false;
-    }
-    const array1 = new Uint8Array(arrayBuffer1);
-    const array2 = new Uint8Array(arrayBuffer2);
-    for (let i2 = 0; i2 < array1.length; ++i2) {
-      if (array1[i2] !== array2[i2]) {
-        return false;
+  // ../worker-utils/src/lib/env-utils/version.ts
+  var NPM_TAG = "latest";
+  function getVersion() {
+    if (!globalThis._loadersgl_?.version) {
+      globalThis._loadersgl_ = globalThis._loadersgl_ || {};
+      if (false) {
+        console.warn(
+          "loaders.gl: The __VERSION__ variable is not injected using babel plugin. Latest unstable workers would be fetched from the CDN."
+        );
+        globalThis._loadersgl_.version = NPM_TAG;
+      } else {
+        globalThis._loadersgl_.version = "4.2.0-beta.1";
       }
     }
-    return true;
-  }
-  function concatenateArrayBuffers(...sources) {
-    return concatenateArrayBuffersFromArray(sources);
+    return globalThis._loadersgl_.version;
   }
-  function concatenateArrayBuffersFromArray(sources) {
-    const sourceArrays = sources.map(
-      (source2) => source2 instanceof ArrayBuffer ? new Uint8Array(source2) : source2
-    );
-    const byteLength = sourceArrays.reduce((length2, typedArray) => length2 + typedArray.byteLength, 0);
-    const result = new Uint8Array(byteLength);
-    let offset = 0;
-    for (const sourceArray of sourceArrays) {
-      result.set(sourceArray, offset);
-      offset += sourceArray.byteLength;
+  var VERSION2 = getVersion();
+
+  // ../worker-utils/src/lib/env-utils/assert.ts
+  function assert3(condition, message) {
+    if (!condition) {
+      throw new Error(message || "loaders.gl assertion failed.");
     }
-    return result.buffer;
   }
 
-  // ../loader-utils/src/lib/iterators/async-iteration.ts
-  async function concatenateArrayBuffersAsync(asyncIterator) {
-    const arrayBuffers = [];
-    for await (const chunk of asyncIterator) {
-      arrayBuffers.push(chunk);
-    }
-    return concatenateArrayBuffers(...arrayBuffers);
-  }
-
-  // ../../node_modules/@babel/runtime/helpers/esm/typeof.js
-  function _typeof(obj) {
-    "@babel/helpers - typeof";
-    return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(obj2) {
-      return typeof obj2;
-    } : function(obj2) {
-      return obj2 && "function" == typeof Symbol && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
-    }, _typeof(obj);
-  }
+  // ../worker-utils/src/lib/env-utils/globals.ts
+  var globals2 = {
+    self: typeof self !== "undefined" && self,
+    window: typeof window !== "undefined" && window,
+    global: typeof global !== "undefined" && global,
+    document: typeof document !== "undefined" && document
+  };
+  var self_3 = globals2.self || globals2.window || globals2.global || {};
+  var window_3 = globals2.window || globals2.self || globals2.global || {};
+  var global_3 = globals2.global || globals2.self || globals2.window || {};
+  var document_3 = globals2.document || {};
+  var isBrowser4 = (
+    // @ts-ignore process.browser
+    typeof process !== "object" || String(process) !== "[object process]" || process.browser
+  );
+  var isWorker = typeof importScripts === "function";
+  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;
 
-  // ../../node_modules/@babel/runtime/helpers/esm/toPrimitive.js
-  function _toPrimitive(input, hint) {
-    if (_typeof(input) !== "object" || input === null)
-      return input;
-    var prim = input[Symbol.toPrimitive];
-    if (prim !== void 0) {
-      var res = prim.call(input, hint || "default");
-      if (_typeof(res) !== "object")
-        return res;
-      throw new TypeError("@@toPrimitive must return a primitive value.");
+  // ../worker-utils/src/lib/worker-farm/worker-job.ts
+  var WorkerJob = class {
+    name;
+    workerThread;
+    isRunning = true;
+    /** Promise that resolves when Job is done */
+    result;
+    _resolve = () => {
+    };
+    _reject = () => {
+    };
+    constructor(jobName, workerThread) {
+      this.name = jobName;
+      this.workerThread = workerThread;
+      this.result = new Promise((resolve2, reject) => {
+        this._resolve = resolve2;
+        this._reject = reject;
+      });
     }
-    return (hint === "string" ? String : Number)(input);
-  }
-
-  // ../../node_modules/@babel/runtime/helpers/esm/toPropertyKey.js
-  function _toPropertyKey(arg) {
-    var key = _toPrimitive(arg, "string");
-    return _typeof(key) === "symbol" ? key : String(key);
-  }
-
-  // ../../node_modules/@babel/runtime/helpers/esm/defineProperty.js
-  function _defineProperty(obj, key, value) {
-    key = _toPropertyKey(key);
-    if (key in obj) {
-      Object.defineProperty(obj, key, {
-        value,
-        enumerable: true,
-        configurable: true,
-        writable: true
+    /**
+     * 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
       });
-    } else {
-      obj[key] = value;
     }
-    return obj;
-  }
+    /**
+     * Call to resolve the `result` Promise with the supplied value
+     */
+    done(value) {
+      assert3(this.isRunning);
+      this.isRunning = false;
+      this._resolve(value);
+    }
+    /**
+     * Call to reject the `result` Promise with the supplied error
+     */
+    error(error) {
+      assert3(this.isRunning);
+      this.isRunning = false;
+      this._reject(error);
+    }
+  };
 
-  // ../loader-utils/src/lib/path-utils/file-aliases.ts
-  var pathPrefix = "";
-  var fileAliases = {};
-  function resolvePath(filename2) {
-    for (const alias in fileAliases) {
-      if (filename2.startsWith(alias)) {
-        const replacement = fileAliases[alias];
-        filename2 = filename2.replace(alias, replacement);
+  // ../worker-utils/src/lib/node/worker_threads-browser.ts
+  var NodeWorker = class {
+    terminate() {
+    }
+  };
+  var parentPort = null;
+
+  // ../worker-utils/src/lib/worker-utils/get-loadable-worker-url.ts
+  var workerURLCache = /* @__PURE__ */ new Map();
+  function getLoadableWorkerURL(props) {
+    assert3(props.source && !props.url || !props.source && props.url);
+    let workerURL = workerURLCache.get(props.source || props.url);
+    if (!workerURL) {
+      if (props.url) {
+        workerURL = getLoadableWorkerURLFromURL(props.url);
+        workerURLCache.set(props.url, workerURL);
+      }
+      if (props.source) {
+        workerURL = getLoadableWorkerURLFromSource(props.source);
+        workerURLCache.set(props.source, workerURL);
       }
     }
-    if (!filename2.startsWith("http://") && !filename2.startsWith("https://")) {
-      filename2 = `${pathPrefix}${filename2}`;
+    assert3(workerURL);
+    return workerURL;
+  }
+  function getLoadableWorkerURLFromURL(url) {
+    if (!url.startsWith("http")) {
+      return url;
     }
-    return filename2;
+    const workerSource = buildScriptSource(url);
+    return getLoadableWorkerURLFromSource(workerSource);
   }
-
-  // ../loader-utils/src/lib/node/buffer.browser.ts
-  function toArrayBuffer(buffer) {
-    return buffer;
+  function getLoadableWorkerURLFromSource(workerSource) {
+    const blob = new Blob([workerSource], { type: "application/javascript" });
+    return URL.createObjectURL(blob);
+  }
+  function buildScriptSource(workerUrl) {
+    return `try {
+  importScripts('${workerUrl}');
+} catch (error) {
+  console.error(error);
+  throw error;
+}`;
   }
 
-  // ../loader-utils/src/lib/binary-utils/memory-conversion-utils.ts
-  function isBuffer(value) {
-    return value && typeof value === "object" && value.isBuffer;
+  // ../worker-utils/src/lib/worker-utils/get-transfer-list.ts
+  function getTransferList(object, recursive = true, transfers) {
+    const transfersSet = transfers || /* @__PURE__ */ new Set();
+    if (!object) {
+    } else if (isTransferable(object)) {
+      transfersSet.add(object);
+    } else if (isTransferable(object.buffer)) {
+      transfersSet.add(object.buffer);
+    } else if (ArrayBuffer.isView(object)) {
+    } else if (recursive && typeof object === "object") {
+      for (const key in object) {
+        getTransferList(object[key], recursive, transfersSet);
+      }
+    }
+    return transfers === void 0 ? Array.from(transfersSet) : [];
   }
-  function toArrayBuffer2(data) {
-    if (isBuffer(data)) {
-      return toArrayBuffer(data);
+  function isTransferable(object) {
+    if (!object) {
+      return false;
     }
-    if (data instanceof ArrayBuffer) {
-      return data;
+    if (object instanceof ArrayBuffer) {
+      return true;
     }
-    if (ArrayBuffer.isView(data)) {
-      if (data.byteOffset === 0 && data.byteLength === data.buffer.byteLength) {
-        return data.buffer;
-      }
-      return data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
+    if (typeof MessagePort !== "undefined" && object instanceof MessagePort) {
+      return true;
     }
-    if (typeof data === "string") {
-      const text = data;
-      const uint8Array = new TextEncoder().encode(text);
-      return uint8Array.buffer;
+    if (typeof ImageBitmap !== "undefined" && object instanceof ImageBitmap) {
+      return true;
     }
-    if (data && typeof data === "object" && data._toArrayBuffer) {
-      return data._toArrayBuffer();
+    if (typeof OffscreenCanvas !== "undefined" && object instanceof OffscreenCanvas) {
+      return true;
     }
-    throw new Error("toArrayBuffer");
+    return false;
   }
 
-  // ../loader-utils/src/lib/path-utils/path.ts
-  var path_exports = {};
-  __export(path_exports, {
-    dirname: () => dirname,
-    filename: () => filename,
-    join: () => join,
-    resolve: () => resolve
-  });
-
-  // ../loader-utils/src/lib/path-utils/get-cwd.ts
-  function getCWD() {
-    if (typeof process !== "undefined" && typeof process.cwd !== "undefined") {
-      return process.cwd();
+  // ../worker-utils/src/lib/worker-farm/worker-thread.ts
+  var NOOP = () => {
+  };
+  var WorkerThread = class {
+    name;
+    source;
+    url;
+    terminated = false;
+    worker;
+    onMessage;
+    onError;
+    _loadableURL = "";
+    /** Checks if workers are supported on this platform */
+    static isSupported() {
+      return typeof Worker !== "undefined" && isBrowser4 || typeof NodeWorker !== "undefined" && !isBrowser4;
     }
-    const pathname = window.location?.pathname;
-    return pathname?.slice(0, pathname.lastIndexOf("/") + 1) || "";
-  }
-
-  // ../loader-utils/src/lib/path-utils/path.ts
-  function filename(url) {
-    const slashIndex = url ? url.lastIndexOf("/") : -1;
-    return slashIndex >= 0 ? url.substr(slashIndex + 1) : "";
-  }
-  function dirname(url) {
-    const slashIndex = url ? url.lastIndexOf("/") : -1;
-    return slashIndex >= 0 ? url.substr(0, slashIndex) : "";
-  }
-  function join(...parts) {
-    const separator = "/";
-    parts = parts.map((part, index) => {
-      if (index) {
-        part = part.replace(new RegExp(`^${separator}`), "");
-      }
-      if (index !== parts.length - 1) {
-        part = part.replace(new RegExp(`${separator}$`), "");
-      }
-      return part;
-    });
-    return parts.join(separator);
-  }
-  function resolve(...components) {
-    const paths = [];
-    for (let _i = 0; _i < components.length; _i++) {
-      paths[_i] = components[_i];
+    constructor(props) {
+      const { name, source, url } = props;
+      assert3(source || url);
+      this.name = name;
+      this.source = source;
+      this.url = url;
+      this.onMessage = NOOP;
+      this.onError = (error) => console.log(error);
+      this.worker = isBrowser4 ? this._createBrowserWorker() : this._createNodeWorker();
     }
-    let resolvedPath = "";
-    let resolvedAbsolute = false;
-    let cwd;
-    for (let i2 = paths.length - 1; i2 >= -1 && !resolvedAbsolute; i2--) {
-      let path;
-      if (i2 >= 0) {
-        path = paths[i2];
-      } else {
-        if (cwd === void 0) {
-          cwd = getCWD();
-        }
-        path = cwd;
+    /**
+     * 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 (path.length === 0) {
-        continue;
+      if (event.lineno) {
+        message += `:${event.lineno}:${event.colno}`;
       }
-      resolvedPath = `${path}/${resolvedPath}`;
-      resolvedAbsolute = path.charCodeAt(0) === SLASH;
+      return new Error(message);
     }
-    resolvedPath = normalizeStringPosix(resolvedPath, !resolvedAbsolute);
-    if (resolvedAbsolute) {
-      return `/${resolvedPath}`;
-    } else if (resolvedPath.length > 0) {
-      return resolvedPath;
+    /**
+     * 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;
     }
-    return ".";
-  }
-  var SLASH = 47;
-  var DOT = 46;
-  function normalizeStringPosix(path, allowAboveRoot) {
-    let res = "";
-    let lastSlash = -1;
-    let dots = 0;
-    let code;
-    let isAboveRoot = false;
-    for (let i2 = 0; i2 <= path.length; ++i2) {
-      if (i2 < path.length) {
-        code = path.charCodeAt(i2);
-      } else if (code === SLASH) {
-        break;
+    /**
+     * 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 NodeWorker(url, { eval: false });
+      } else if (this.source) {
+        worker = new NodeWorker(this.source, { eval: true });
       } else {
-        code = SLASH;
+        throw new Error("no worker");
       }
-      if (code === SLASH) {
-        if (lastSlash === i2 - 1 || dots === 1) {
-        } else if (lastSlash !== i2 - 1 && dots === 2) {
-          if (res.length < 2 || !isAboveRoot || res.charCodeAt(res.length - 1) !== DOT || res.charCodeAt(res.length - 2) !== DOT) {
-            if (res.length > 2) {
-              const start = res.length - 1;
-              let j = start;
-              for (; j >= 0; --j) {
-                if (res.charCodeAt(j) === SLASH) {
-                  break;
-                }
-              }
-              if (j !== start) {
-                res = j === -1 ? "" : res.slice(0, j);
-                lastSlash = i2;
-                dots = 0;
-                isAboveRoot = false;
-                continue;
-              }
-            } else if (res.length === 2 || res.length === 1) {
-              res = "";
-              lastSlash = i2;
-              dots = 0;
-              isAboveRoot = false;
-              continue;
-            }
-          }
-          if (allowAboveRoot) {
-            if (res.length > 0) {
-              res += "/..";
-            } else {
-              res = "..";
-            }
-            isAboveRoot = true;
-          }
-        } else {
-          const slice = path.slice(lastSlash + 1, i2);
-          if (res.length > 0) {
-            res += `/${slice}`;
-          } else {
-            res = slice;
-          }
-          isAboveRoot = false;
+      worker.on("message", (data) => {
+        this.onMessage(data);
+      });
+      worker.on("error", (error) => {
+        this.onError(error);
+      });
+      worker.on("exit", (code) => {
+      });
+      return worker;
+    }
+  };
+
+  // ../worker-utils/src/lib/worker-farm/worker-pool.ts
+  var WorkerPool = class {
+    name = "unnamed";
+    source;
+    // | Function;
+    url;
+    maxConcurrency = 1;
+    maxMobileConcurrency = 1;
+    onDebug = () => {
+    };
+    reuseWorkers = true;
+    props = {};
+    jobQueue = [];
+    idleQueue = [];
+    count = 0;
+    isDestroyed = false;
+    /** Checks if workers are supported on this platform */
+    static isSupported() {
+      return WorkerThread.isSupported();
+    }
+    /**
+     * @param processor - worker function
+     * @param maxConcurrency - max count of workers
+     */
+    constructor(props) {
+      this.source = props.source;
+      this.url = props.url;
+      this.setProps(props);
+    }
+    /**
+     * Terminates all workers in the pool
+     * @note Can free up significant memory
+     */
+    destroy() {
+      this.idleQueue.forEach((worker) => worker.destroy());
+      this.isDestroyed = true;
+    }
+    setProps(props) {
+      this.props = { ...this.props, ...props };
+      if (props.name !== void 0) {
+        this.name = props.name;
+      }
+      if (props.maxConcurrency !== void 0) {
+        this.maxConcurrency = props.maxConcurrency;
+      }
+      if (props.maxMobileConcurrency !== void 0) {
+        this.maxMobileConcurrency = props.maxMobileConcurrency;
+      }
+      if (props.reuseWorkers !== void 0) {
+        this.reuseWorkers = props.reuseWorkers;
+      }
+      if (props.onDebug !== void 0) {
+        this.onDebug = props.onDebug;
+      }
+    }
+    async startJob(name, onMessage2 = (job, type, data) => job.done(data), onError = (job, error) => job.error(error)) {
+      const startPromise = new Promise((onStart) => {
+        this.jobQueue.push({ name, onMessage: onMessage2, onError, onStart });
+        return this;
+      });
+      this._startQueuedJob();
+      return await startPromise;
+    }
+    // PRIVATE
+    /**
+     * Starts first queued job if worker is available or can be created
+     * Called when job is started and whenever a worker returns to the idleQueue
+     */
+    async _startQueuedJob() {
+      if (!this.jobQueue.length) {
+        return;
+      }
+      const workerThread = this._getAvailableWorker();
+      if (!workerThread) {
+        return;
+      }
+      const queuedJob = this.jobQueue.shift();
+      if (queuedJob) {
+        this.onDebug({
+          message: "Starting job",
+          name: queuedJob.name,
+          workerThread,
+          backlog: this.jobQueue.length
+        });
+        const job = new WorkerJob(queuedJob.name, workerThread);
+        workerThread.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);
         }
-        lastSlash = i2;
-        dots = 0;
-      } else if (code === DOT && dots !== -1) {
-        ++dots;
+      }
+    }
+    /**
+     * 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
+        !isBrowser4 || // 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 {
-        dots = -1;
+        this.idleQueue.push(worker);
+      }
+      if (!this.isDestroyed) {
+        this._startQueuedJob();
+      }
+    }
+    /**
+     * Returns idle worker or creates new worker if maxConcurrency has not been reached
+     */
+    _getAvailableWorker() {
+      if (this.idleQueue.length > 0) {
+        return this.idleQueue.shift() || null;
+      }
+      if (this.count < this._getMaxConcurrency()) {
+        this.count++;
+        const name = `${this.name.toLowerCase()} (#${this.count} of ${this.maxConcurrency})`;
+        return new WorkerThread({ name, source: this.source, url: this.url });
+      }
+      return null;
+    }
+    _getMaxConcurrency() {
+      return isMobile ? this.maxMobileConcurrency : this.maxConcurrency;
+    }
+  };
+
+  // ../worker-utils/src/lib/worker-farm/worker-farm.ts
+  var DEFAULT_PROPS = {
+    maxConcurrency: 3,
+    maxMobileConcurrency: 1,
+    reuseWorkers: true,
+    onDebug: () => {
+    }
+  };
+  var _WorkerFarm = class {
+    props;
+    workerPools = /* @__PURE__ */ new Map();
+    /** Checks if workers are supported on this platform */
+    static isSupported() {
+      return WorkerThread.isSupported();
+    }
+    /** Get the singleton instance of the global worker farm */
+    static getWorkerFarm(props = {}) {
+      _WorkerFarm._workerFarm = _WorkerFarm._workerFarm || new _WorkerFarm({});
+      _WorkerFarm._workerFarm.setProps(props);
+      return _WorkerFarm._workerFarm;
+    }
+    /** get global instance with WorkerFarm.getWorkerFarm() */
+    constructor(props) {
+      this.props = { ...DEFAULT_PROPS };
+      this.setProps(props);
+      this.workerPools = /* @__PURE__ */ new Map();
+    }
+    /**
+     * Terminate all workers in the farm
+     * @note Can free up significant memory
+     */
+    destroy() {
+      for (const workerPool of this.workerPools.values()) {
+        workerPool.destroy();
+      }
+      this.workerPools = /* @__PURE__ */ new Map();
+    }
+    /**
+     * Set props used when initializing worker pools
+     * @param props
+     */
+    setProps(props) {
+      this.props = { ...this.props, ...props };
+      for (const workerPool of this.workerPools.values()) {
+        workerPool.setProps(this._getWorkerPoolProps());
       }
     }
-    return res;
-  }
-
-  // ../core/src/javascript-utils/is-type.ts
-  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 isIterable = (x) => Boolean(x) && typeof x[Symbol.iterator] === "function";
-  var isAsyncIterable = (x) => x && typeof x[Symbol.asyncIterator] === "function";
-  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 isReadableDOMStream = (x) => typeof ReadableStream !== "undefined" && x instanceof ReadableStream || isObject(x) && isFunction(x.tee) && isFunction(x.cancel) && isFunction(x.getReader);
-  var isReadableNodeStream = (x) => isObject(x) && isFunction(x.read) && isFunction(x.pipe) && isBoolean(x.readable);
-  var isReadableStream = (x) => isReadableDOMStream(x) || isReadableNodeStream(x);
-
-  // ../core/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) {
-      return matches3[1];
+    /**
+     * 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;
     }
-    return mimeString;
-  }
-  function parseMIMETypeFromURL(url) {
-    const matches3 = DATA_URL_PATTERN.exec(url);
-    if (matches3) {
-      return matches3[1];
+    _getWorkerPoolProps() {
+      return {
+        maxConcurrency: this.props.maxConcurrency,
+        maxMobileConcurrency: this.props.maxMobileConcurrency,
+        reuseWorkers: this.props.reuseWorkers,
+        onDebug: this.props.onDebug
+      };
     }
-    return "";
-  }
+  };
+  var WorkerFarm = _WorkerFarm;
+  // singleton
+  __publicField(WorkerFarm, "_workerFarm");
 
-  // ../core/src/lib/utils/url-utils.ts
-  var QUERY_STRING_PATTERN = /\?.*/;
-  function extractQueryString(url) {
-    const matches3 = url.match(QUERY_STRING_PATTERN);
-    return matches3 && matches3[0];
-  }
-  function stripQueryString(url) {
-    return url.replace(QUERY_STRING_PATTERN, "");
+  // ../worker-utils/src/lib/worker-farm/worker-body.ts
+  async function getParentPort() {
+    return parentPort;
   }
-
-  // ../core/src/lib/utils/resource-utils.ts
-  function getResourceUrl(resource) {
-    if (isResponse(resource)) {
-      const response = resource;
-      return response.url;
-    }
-    if (isBlob(resource)) {
-      const blob = resource;
-      return blob.name || "";
+  var onMessageWrapperMap = /* @__PURE__ */ new Map();
+  var WorkerBody = class {
+    /** Check that we are actually in a worker thread */
+    static async inWorkerThread() {
+      return typeof self !== "undefined" || Boolean(await getParentPort());
     }
-    if (typeof resource === "string") {
-      return resource;
+    /*
+     * (type: WorkerMessageType, payload: WorkerMessagePayload) => any
+     */
+    static set onmessage(onMessage2) {
+      async function handleMessage(message) {
+        const parentPort2 = await getParentPort();
+        const { type, payload } = parentPort2 ? message : message.data;
+        onMessage2(type, payload);
+      }
+      getParentPort().then((parentPort2) => {
+        if (parentPort2) {
+          parentPort2.on("message", (message) => {
+            handleMessage(message);
+          });
+          parentPort2.on("exit", () => console.debug("Node worker closing"));
+        } else {
+          globalThis.onmessage = handleMessage;
+        }
+      });
     }
-    return "";
-  }
-  function getResourceMIMEType(resource) {
-    if (isResponse(resource)) {
-      const response = resource;
-      const contentTypeHeader = response.headers.get("content-type") || "";
-      const noQueryUrl = stripQueryString(response.url);
-      return parseMIMEType(contentTypeHeader) || parseMIMETypeFromURL(noQueryUrl);
+    static async addEventListener(onMessage2) {
+      let onMessageWrapper = onMessageWrapperMap.get(onMessage2);
+      if (!onMessageWrapper) {
+        onMessageWrapper = async (message) => {
+          if (!isKnownMessage(message)) {
+            return;
+          }
+          const parentPort3 = await getParentPort();
+          const { type, payload } = parentPort3 ? message : message.data;
+          onMessage2(type, payload);
+        };
+      }
+      const parentPort2 = await getParentPort();
+      if (parentPort2) {
+        console.error("not implemented");
+      } else {
+        globalThis.addEventListener("message", onMessageWrapper);
+      }
     }
-    if (isBlob(resource)) {
-      const blob = resource;
-      return blob.type || "";
+    static async removeEventListener(onMessage2) {
+      const onMessageWrapper = onMessageWrapperMap.get(onMessage2);
+      onMessageWrapperMap.delete(onMessage2);
+      const parentPort2 = await getParentPort();
+      if (parentPort2) {
+        console.error("not implemented");
+      } else {
+        globalThis.removeEventListener("message", onMessageWrapper);
+      }
     }
-    if (typeof resource === "string") {
-      return parseMIMETypeFromURL(resource);
+    /**
+     * Send a message from a worker to creating thread (main thread)
+     * @param type
+     * @param payload
+     */
+    static async postMessage(type, payload) {
+      const data = { source: "loaders.gl", type, payload };
+      const transferList = getTransferList(payload);
+      const parentPort2 = await getParentPort();
+      if (parentPort2) {
+        parentPort2.postMessage(data, transferList);
+      } else {
+        globalThis.postMessage(data, transferList);
+      }
     }
-    return "";
+  };
+  function isKnownMessage(message) {
+    const { type, data } = message;
+    return type === "message" && data && typeof data.source === "string" && data.source.startsWith("loaders.gl");
   }
-  function getResourceContentLength(resource) {
-    if (isResponse(resource)) {
-      const response = resource;
-      return response.headers["content-length"] || -1;
-    }
-    if (isBlob(resource)) {
-      const blob = resource;
-      return blob.size;
+
+  // ../worker-utils/src/lib/worker-api/get-worker-url.ts
+  function getWorkerURL(worker, options = {}) {
+    const workerOptions = options[worker.id] || {};
+    const workerFile = isBrowser4 ? `${worker.id}-worker.js` : `${worker.id}-worker-node.js`;
+    let url = workerOptions.workerUrl;
+    if (!url && worker.id === "compression") {
+      url = options.workerUrl;
     }
-    if (typeof resource === "string") {
-      return resource.length;
+    if (options._workerType === "test") {
+      if (isBrowser4) {
+        url = `modules/${worker.module}/dist/${workerFile}`;
+      } else {
+        url = `modules/${worker.module}/src/workers/${worker.id}-worker-node.ts`;
+      }
     }
-    if (resource instanceof ArrayBuffer) {
-      return resource.byteLength;
+    if (!url) {
+      let version = worker.version;
+      if (version === "latest") {
+        version = NPM_TAG;
+      }
+      const versionTag = version ? `@${version}` : "";
+      url = `https://unpkg.com/@loaders.gl/${worker.module}${versionTag}/dist/${workerFile}`;
     }
-    if (ArrayBuffer.isView(resource)) {
-      return resource.byteLength;
+    assert3(url);
+    return url;
+  }
+
+  // ../worker-utils/src/lib/worker-api/validate-worker-version.ts
+  function validateWorkerVersion(worker, coreVersion = VERSION2) {
+    assert3(worker, "no worker provided");
+    const workerVersion = worker.version;
+    if (!coreVersion || !workerVersion) {
+      return false;
     }
-    return -1;
+    return true;
   }
 
-  // ../core/src/lib/utils/response-utils.ts
-  async function makeResponse(resource) {
-    if (isResponse(resource)) {
-      return resource;
+  // ../worker-utils/src/lib/library-utils/library-utils.ts
+  var loadLibraryPromises = {};
+  async function loadLibrary(libraryUrl, moduleName = null, options = {}, libraryName = null) {
+    if (moduleName) {
+      libraryUrl = getLibraryUrl(libraryUrl, moduleName, options, libraryName);
     }
-    const headers = {};
-    const contentLength = getResourceContentLength(resource);
-    if (contentLength >= 0) {
-      headers["content-length"] = String(contentLength);
+    loadLibraryPromises[libraryUrl] = // eslint-disable-next-line @typescript-eslint/no-misused-promises
+    loadLibraryPromises[libraryUrl] || loadLibraryFromFile(libraryUrl);
+    return await loadLibraryPromises[libraryUrl];
+  }
+  function getLibraryUrl(library, moduleName, options = {}, libraryName = null) {
+    if (!options.useLocalLibraries && library.startsWith("http")) {
+      return library;
     }
-    const url = getResourceUrl(resource);
-    const type = getResourceMIMEType(resource);
-    if (type) {
-      headers["content-type"] = type;
+    libraryName = libraryName || library;
+    const modules = options.modules || {};
+    if (modules[libraryName]) {
+      return modules[libraryName];
     }
-    const initialDataUrl = await getInitialDataUrl(resource);
-    if (initialDataUrl) {
-      headers["x-first-bytes"] = initialDataUrl;
+    if (!isBrowser4) {
+      return `modules/${moduleName}/dist/libs/${libraryName}`;
     }
-    if (typeof resource === "string") {
-      resource = new TextEncoder().encode(resource);
+    if (options.CDN) {
+      assert3(options.CDN.startsWith("http"));
+      return `${options.CDN}/${moduleName}@${VERSION2}/dist/libs/${libraryName}`;
+    }
+    if (isWorker) {
+      return `../src/libs/${libraryName}`;
     }
-    const response = new Response(resource, { headers });
-    Object.defineProperty(response, "url", { value: url });
-    return response;
+    return `modules/${moduleName}/src/libs/${libraryName}`;
   }
-  async function checkResponse(response) {
-    if (!response.ok) {
-      const message = await getResponseError(response);
-      throw new Error(message);
+  async function loadLibraryFromFile(libraryUrl) {
+    if (libraryUrl.endsWith("wasm")) {
+      return await loadAsArrayBuffer(libraryUrl);
     }
-  }
-  async function getResponseError(response) {
-    let message = `Failed to fetch resource ${response.url} (${response.status}): `;
-    try {
-      const contentType = response.headers.get("Content-Type");
-      let text = response.statusText;
-      if (contentType?.includes("application/json")) {
-        text += ` ${await response.text()}`;
+    if (!isBrowser4) {
+      try {
+        const { requireFromFile } = globalThis.loaders || {};
+        return await requireFromFile?.(libraryUrl);
+      } catch (error) {
+        console.error(error);
+        return null;
       }
-      message += text;
-      message = message.length > 60 ? `${message.slice(0, 60)}...` : message;
-    } catch (error) {
     }
-    return message;
+    if (isWorker) {
+      return importScripts(libraryUrl);
+    }
+    const scriptSource = await loadAsText(libraryUrl);
+    return loadLibraryFromString(scriptSource, libraryUrl);
   }
-  async function getInitialDataUrl(resource) {
-    const INITIAL_DATA_LENGTH = 5;
-    if (typeof resource === "string") {
-      return `data:,${resource.slice(0, INITIAL_DATA_LENGTH)}`;
+  function loadLibraryFromString(scriptSource, id) {
+    if (!isBrowser4) {
+      const { requireFromString } = globalThis.loaders || {};
+      return requireFromString?.(scriptSource, id);
     }
-    if (resource instanceof Blob) {
-      const blobSlice = resource.slice(0, 5);
-      return await new Promise((resolve2) => {
-        const reader = new FileReader();
-        reader.onload = (event) => resolve2(event?.target?.result);
-        reader.readAsDataURL(blobSlice);
-      });
+    if (isWorker) {
+      eval.call(globalThis, scriptSource);
+      return null;
     }
-    if (resource instanceof ArrayBuffer) {
-      const slice = resource.slice(0, INITIAL_DATA_LENGTH);
-      const base64 = arrayBufferToBase64(slice);
-      return `data:base64,${base64}`;
+    const script = document.createElement("script");
+    script.id = id;
+    try {
+      script.appendChild(document.createTextNode(scriptSource));
+    } catch (e2) {
+      script.text = scriptSource;
     }
+    document.body.appendChild(script);
     return null;
   }
-  function arrayBufferToBase64(buffer) {
-    let binary = "";
-    const bytes = new Uint8Array(buffer);
-    for (let i2 = 0; i2 < bytes.byteLength; i2++) {
-      binary += String.fromCharCode(bytes[i2]);
+  async function loadAsArrayBuffer(url) {
+    const { readFileAsArrayBuffer } = globalThis.loaders || {};
+    if (isBrowser4 || !readFileAsArrayBuffer || url.startsWith("http")) {
+      const response = await fetch(url);
+      return await response.arrayBuffer();
     }
-    return btoa(binary);
+    return await readFileAsArrayBuffer(url);
+  }
+  async function loadAsText(url) {
+    const { readFileAsText } = globalThis.loaders || {};
+    if (isBrowser4 || !readFileAsText || url.startsWith("http")) {
+      const response = await fetch(url);
+      return await response.text();
+    }
+    return await readFileAsText(url);
   }
 
-  // ../core/src/lib/fetch/fetch-file.ts
-  function isNodePath(url) {
-    return !isRequestURL(url) && !isDataURL(url);
+  // ../loader-utils/src/lib/worker-loader-utils/create-loader-worker.ts
+  var requestId = 0;
+  async function createLoaderWorker(loader) {
+    if (!await WorkerBody.inWorkerThread()) {
+      return;
+    }
+    WorkerBody.onmessage = async (type, payload) => {
+      switch (type) {
+        case "process":
+          try {
+            const { input, options = {}, context = {} } = payload;
+            const result = await parseData({
+              loader,
+              arrayBuffer: input,
+              options,
+              // @ts-expect-error fetch missing
+              context: {
+                ...context,
+                _parse: parseOnMainThread
+              }
+            });
+            WorkerBody.postMessage("done", { result });
+          } catch (error) {
+            const message = error instanceof Error ? error.message : "";
+            WorkerBody.postMessage("error", { error: message });
+          }
+          break;
+        default:
+      }
+    };
   }
-  function isRequestURL(url) {
-    return url.startsWith("http:") || url.startsWith("https:");
+  function parseOnMainThread(arrayBuffer, loader, options, context) {
+    return new Promise((resolve2, reject) => {
+      const id = requestId++;
+      const onMessage2 = (type, payload2) => {
+        if (payload2.id !== id) {
+          return;
+        }
+        switch (type) {
+          case "done":
+            WorkerBody.removeEventListener(onMessage2);
+            resolve2(payload2.result);
+            break;
+          case "error":
+            WorkerBody.removeEventListener(onMessage2);
+            reject(payload2.error);
+            break;
+          default:
+        }
+      };
+      WorkerBody.addEventListener(onMessage2);
+      const payload = { id, input: arrayBuffer, options };
+      WorkerBody.postMessage("process", payload);
+    });
   }
-  function isDataURL(url) {
-    return url.startsWith("data:");
+  async function parseData({
+    loader,
+    arrayBuffer,
+    options,
+    context
+  }) {
+    let data;
+    let parser;
+    if (loader.parseSync || loader.parse) {
+      data = arrayBuffer;
+      parser = loader.parseSync || loader.parse;
+    } else if (loader.parseTextSync) {
+      const textDecoder = new TextDecoder();
+      data = textDecoder.decode(arrayBuffer);
+      parser = loader.parseTextSync;
+    } else {
+      throw new Error(`Could not load data with ${loader.name} loader`);
+    }
+    options = {
+      ...options,
+      modules: loader && loader.options && loader.options.modules || {},
+      worker: false
+    };
+    return await parser(data, { ...options }, context, loader);
   }
-  async function fetchFile(urlOrData, fetchOptions) {
-    if (typeof urlOrData === "string") {
-      const url = resolvePath(urlOrData);
-      if (isNodePath(url)) {
-        if (globalThis.loaders?.fetchNode) {
-          return globalThis.loaders?.fetchNode(url, fetchOptions);
+
+  // ../loader-utils/src/lib/worker-loader-utils/parse-with-worker.ts
+  function canParseWithWorker(loader, options) {
+    if (!WorkerFarm.isSupported()) {
+      return false;
+    }
+    if (!isBrowser4 && !options?._nodeWorkers) {
+      return false;
+    }
+    return loader.worker && options?.worker;
+  }
+  async function parseWithWorker(loader, data, options, context, parseOnMainThread2) {
+    const name = loader.id;
+    const url = getWorkerURL(loader, options);
+    const workerFarm = WorkerFarm.getWorkerFarm(options);
+    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",
+      // @ts-expect-error
+      onMessage.bind(null, parseOnMainThread2)
+      // eslint-disable-line @typescript-eslint/no-misused-promises
+    );
+    job.postMessage("process", {
+      // @ts-ignore
+      input: data,
+      options,
+      context
+    });
+    const result = await job.result;
+    return await result.result;
+  }
+  async function onMessage(parseOnMainThread2, job, type, payload) {
+    switch (type) {
+      case "done":
+        job.done(payload);
+        break;
+      case "error":
+        job.error(new Error(payload.error));
+        break;
+      case "process":
+        const { id, input, options } = payload;
+        try {
+          const result = await parseOnMainThread2(input, options);
+          job.postMessage("done", { id, result });
+        } catch (error) {
+          const message = error instanceof Error ? error.message : "unknown error";
+          job.postMessage("error", { id, error: message });
         }
+        break;
+      default:
+        console.warn(`parse-with-worker unknown message ${type}`);
+    }
+  }
+
+  // ../loader-utils/src/lib/binary-utils/array-buffer-utils.ts
+  function compareArrayBuffers(arrayBuffer1, arrayBuffer2, byteLength) {
+    byteLength = byteLength || arrayBuffer1.byteLength;
+    if (arrayBuffer1.byteLength < byteLength || arrayBuffer2.byteLength < byteLength) {
+      return false;
+    }
+    const array1 = new Uint8Array(arrayBuffer1);
+    const array2 = new Uint8Array(arrayBuffer2);
+    for (let i2 = 0; i2 < array1.length; ++i2) {
+      if (array1[i2] !== array2[i2]) {
+        return false;
       }
-      return await fetch(url, fetchOptions);
     }
-    return await makeResponse(urlOrData);
+    return true;
+  }
+  function concatenateArrayBuffers(...sources) {
+    return concatenateArrayBuffersFromArray(sources);
+  }
+  function concatenateArrayBuffersFromArray(sources) {
+    const sourceArrays = sources.map(
+      (source2) => source2 instanceof ArrayBuffer ? new Uint8Array(source2) : source2
+    );
+    const byteLength = sourceArrays.reduce((length2, typedArray) => length2 + typedArray.byteLength, 0);
+    const result = new Uint8Array(byteLength);
+    let offset = 0;
+    for (const sourceArray of sourceArrays) {
+      result.set(sourceArray, offset);
+      offset += sourceArray.byteLength;
+    }
+    return result.buffer;
   }
 
-  // ../../node_modules/@probe.gl/log/node_modules/@probe.gl/env/dist/lib/is-electron.js
-  function isElectron(mockUserAgent) {
-    if (typeof window !== "undefined" && typeof window.process === "object" && window.process.type === "renderer") {
-      return true;
+  // ../loader-utils/src/lib/iterators/async-iteration.ts
+  async function concatenateArrayBuffersAsync(asyncIterator) {
+    const arrayBuffers = [];
+    for await (const chunk of asyncIterator) {
+      arrayBuffers.push(chunk);
     }
-    if (typeof process !== "undefined" && typeof process.versions === "object" && Boolean(process.versions["electron"])) {
-      return true;
+    return concatenateArrayBuffers(...arrayBuffers);
+  }
+
+  // ../loader-utils/src/lib/path-utils/file-aliases.ts
+  var pathPrefix = "";
+  var fileAliases = {};
+  function resolvePath(filename2) {
+    for (const alias in fileAliases) {
+      if (filename2.startsWith(alias)) {
+        const replacement = fileAliases[alias];
+        filename2 = filename2.replace(alias, replacement);
+      }
     }
-    const realUserAgent = typeof navigator === "object" && typeof navigator.userAgent === "string" && navigator.userAgent;
-    const userAgent = mockUserAgent || realUserAgent;
-    if (userAgent && userAgent.indexOf("Electron") >= 0) {
-      return true;
+    if (!filename2.startsWith("http://") && !filename2.startsWith("https://")) {
+      filename2 = `${pathPrefix}${filename2}`;
     }
-    return false;
+    return filename2;
   }
 
-  // ../../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();
+  // ../loader-utils/src/lib/node/buffer.browser.ts
+  function toArrayBuffer(buffer) {
+    return buffer;
   }
 
-  // ../../node_modules/@probe.gl/log/node_modules/@probe.gl/env/dist/lib/globals.js
-  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 VERSION2 = true ? "4.2.0-alpha.5" : "untranspiled source";
-  var isBrowser4 = isBrowser3();
-
-  // ../../node_modules/@probe.gl/log/dist/utils/local-storage.js
-  function getStorage(type) {
-    try {
-      const storage = window[type];
-      const x = "__storage_test__";
-      storage.setItem(x, x);
-      storage.removeItem(x);
-      return storage;
-    } catch (e2) {
-      return null;
-    }
+  // ../loader-utils/src/lib/binary-utils/memory-conversion-utils.ts
+  function isBuffer(value) {
+    return value && typeof value === "object" && value.isBuffer;
   }
-  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();
+  function toArrayBuffer2(data) {
+    if (isBuffer(data)) {
+      return toArrayBuffer(data);
     }
-    getConfiguration() {
-      return this.config;
+    if (data instanceof ArrayBuffer) {
+      return data;
     }
-    setConfiguration(configuration) {
-      Object.assign(this.config, configuration);
-      if (this.storage) {
-        const serialized = JSON.stringify(this.config);
-        this.storage.setItem(this.id, serialized);
+    if (ArrayBuffer.isView(data)) {
+      if (data.byteOffset === 0 && data.byteLength === data.buffer.byteLength) {
+        return data.buffer;
       }
+      return data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
     }
-    _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;
+    if (typeof data === "string") {
+      const text = data;
+      const uint8Array = new TextEncoder().encode(text);
+      return uint8Array.buffer;
     }
-  };
-
-  // ../../node_modules/@probe.gl/log/dist/utils/formatters.js
-  function formatTime(ms) {
-    let formatted;
-    if (ms < 10) {
-      formatted = "".concat(ms.toFixed(2), "ms");
-    } else if (ms < 100) {
-      formatted = "".concat(ms.toFixed(1), "ms");
-    } else if (ms < 1e3) {
-      formatted = "".concat(ms.toFixed(0), "ms");
-    } else {
-      formatted = "".concat((ms / 1e3).toFixed(2), "s");
+    if (data && typeof data === "object" && data._toArrayBuffer) {
+      return data._toArrayBuffer();
     }
-    return formatted;
-  }
-  function leftPad(string) {
-    let length2 = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 8;
-    const padLength = Math.max(length2 - string.length, 0);
-    return "".concat(" ".repeat(padLength)).concat(string);
+    throw new Error("toArrayBuffer");
   }
-  function formatImage(image, message, scale3) {
-    let maxWidth = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : 600;
-    const imageUrl = image.src.replace(/\(/g, "%28").replace(/\)/g, "%29");
-    if (image.width > maxWidth) {
-      scale3 = Math.min(scale3, maxWidth / image.width);
+
+  // ../loader-utils/src/lib/path-utils/path.ts
+  var path_exports = {};
+  __export(path_exports, {
+    dirname: () => dirname,
+    filename: () => filename,
+    join: () => join,
+    resolve: () => resolve
+  });
+
+  // ../loader-utils/src/lib/path-utils/get-cwd.ts
+  function getCWD() {
+    if (typeof process !== "undefined" && typeof process.cwd !== "undefined") {
+      return process.cwd();
     }
-    const width = image.width * scale3;
-    const height = image.height * scale3;
-    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];
+    const pathname = window.location?.pathname;
+    return pathname?.slice(0, pathname.lastIndexOf("/") + 1) || "";
   }
 
-  // ../../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;
+  // ../loader-utils/src/lib/path-utils/path.ts
+  function filename(url) {
+    const slashIndex = url ? url.lastIndexOf("/") : -1;
+    return slashIndex >= 0 ? url.substr(slashIndex + 1) : "";
+  }
+  function dirname(url) {
+    const slashIndex = url ? url.lastIndexOf("/") : -1;
+    return slashIndex >= 0 ? url.substr(0, slashIndex) : "";
+  }
+  function join(...parts) {
+    const separator = "/";
+    parts = parts.map((part, index) => {
+      if (index) {
+        part = part.replace(new RegExp(`^${separator}`), "");
+      }
+      if (index !== parts.length - 1) {
+        part = part.replace(new RegExp(`${separator}$`), "");
+      }
+      return part;
+    });
+    return parts.join(separator);
+  }
+  function resolve(...components) {
+    const paths = [];
+    for (let _i = 0; _i < components.length; _i++) {
+      paths[_i] = components[_i];
     }
-    color = color.toUpperCase();
-    return COLOR[color] || COLOR.WHITE;
+    let resolvedPath = "";
+    let resolvedAbsolute = false;
+    let cwd;
+    for (let i2 = paths.length - 1; i2 >= -1 && !resolvedAbsolute; i2--) {
+      let path;
+      if (i2 >= 0) {
+        path = paths[i2];
+      } else {
+        if (cwd === void 0) {
+          cwd = getCWD();
+        }
+        path = cwd;
+      }
+      if (path.length === 0) {
+        continue;
+      }
+      resolvedPath = `${path}/${resolvedPath}`;
+      resolvedAbsolute = path.charCodeAt(0) === SLASH;
+    }
+    resolvedPath = normalizeStringPosix(resolvedPath, !resolvedAbsolute);
+    if (resolvedAbsolute) {
+      return `/${resolvedPath}`;
+    } else if (resolvedPath.length > 0) {
+      return resolvedPath;
+    }
+    return ".";
   }
-  function addColor(string, color, background) {
-    if (!isBrowser3 && typeof string === "string") {
-      if (color) {
-        const colorCode = getColor(color);
-        string = "\x1B[".concat(colorCode, "m").concat(string, "\x1B[39m");
+  var SLASH = 47;
+  var DOT = 46;
+  function normalizeStringPosix(path, allowAboveRoot) {
+    let res = "";
+    let lastSlash = -1;
+    let dots = 0;
+    let code;
+    let isAboveRoot = false;
+    for (let i2 = 0; i2 <= path.length; ++i2) {
+      if (i2 < path.length) {
+        code = path.charCodeAt(i2);
+      } else if (code === SLASH) {
+        break;
+      } else {
+        code = SLASH;
       }
-      if (background) {
-        const colorCode = getColor(background);
-        string = "\x1B[".concat(colorCode + BACKGROUND_INCREMENT, "m").concat(string, "\x1B[49m");
+      if (code === SLASH) {
+        if (lastSlash === i2 - 1 || dots === 1) {
+        } else if (lastSlash !== i2 - 1 && dots === 2) {
+          if (res.length < 2 || !isAboveRoot || res.charCodeAt(res.length - 1) !== DOT || res.charCodeAt(res.length - 2) !== DOT) {
+            if (res.length > 2) {
+              const start = res.length - 1;
+              let j = start;
+              for (; j >= 0; --j) {
+                if (res.charCodeAt(j) === SLASH) {
+                  break;
+                }
+              }
+              if (j !== start) {
+                res = j === -1 ? "" : res.slice(0, j);
+                lastSlash = i2;
+                dots = 0;
+                isAboveRoot = false;
+                continue;
+              }
+            } else if (res.length === 2 || res.length === 1) {
+              res = "";
+              lastSlash = i2;
+              dots = 0;
+              isAboveRoot = false;
+              continue;
+            }
+          }
+          if (allowAboveRoot) {
+            if (res.length > 0) {
+              res += "/..";
+            } else {
+              res = "..";
+            }
+            isAboveRoot = true;
+          }
+        } else {
+          const slice = path.slice(lastSlash + 1, i2);
+          if (res.length > 0) {
+            res += `/${slice}`;
+          } else {
+            res = slice;
+          }
+          isAboveRoot = false;
+        }
+        lastSlash = i2;
+        dots = 0;
+      } else if (code === DOT && dots !== -1) {
+        ++dots;
+      } else {
+        dots = -1;
       }
     }
-    return string;
+    return res;
   }
 
-  // ../../node_modules/@probe.gl/log/dist/utils/autobind.js
-  function autobind(obj) {
-    let predefined = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : ["constructor"];
-    const proto = Object.getPrototypeOf(obj);
-    const propNames = Object.getOwnPropertyNames(proto);
-    const object = obj;
-    for (const key of propNames) {
-      const value = object[key];
-      if (typeof value === "function") {
-        if (!predefined.find((name) => key === name)) {
-          object[key] = value.bind(obj);
-        }
-      }
+  // ../core/src/javascript-utils/is-type.ts
+  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 isIterable = (x) => Boolean(x) && typeof x[Symbol.iterator] === "function";
+  var isAsyncIterable = (x) => x && typeof x[Symbol.asyncIterator] === "function";
+  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 isReadableDOMStream = (x) => typeof ReadableStream !== "undefined" && x instanceof ReadableStream || isObject(x) && isFunction(x.tee) && isFunction(x.cancel) && isFunction(x.getReader);
+  var isReadableNodeStream = (x) => isObject(x) && isFunction(x.read) && isFunction(x.pipe) && isBoolean(x.readable);
+  var isReadableStream = (x) => isReadableDOMStream(x) || isReadableNodeStream(x);
+
+  // ../core/src/lib/fetch/fetch-error.ts
+  var FetchError = class extends Error {
+    constructor(message, info) {
+      super(message);
+      this.reason = info.reason;
+      this.url = info.url;
+      this.response = info.response;
+    }
+    /** A best effort reason for why the fetch failed */
+    reason;
+    /** The URL that failed to load. Empty string if not available. */
+    url;
+    /** The Response object, if any. */
+    response;
+  };
+
+  // ../core/src/lib/utils/mime-type-utils.ts
+  var DATA_URL_PATTERN = /^data:([-\w.]+\/[-\w.+]+)(;|,)/;
+  var MIME_TYPE_PATTERN = /^([-\w.]+\/[-\w.+]+)/;
+  function compareMIMETypes(mimeType1, mimeType2) {
+    if (mimeType1.toLowerCase() === mimeType2.toLowerCase()) {
+      return true;
     }
+    return false;
   }
-
-  // ../../node_modules/@probe.gl/log/dist/utils/assert.js
-  function assert3(condition, message) {
-    if (!condition) {
-      throw new Error(message || "Assertion failed");
+  function parseMIMEType(mimeString) {
+    const matches3 = MIME_TYPE_PATTERN.exec(mimeString);
+    if (matches3) {
+      return matches3[1];
     }
+    return mimeString;
   }
-
-  // ../../node_modules/@probe.gl/log/dist/utils/hi-res-timestamp.js
-  function getHiResTimestamp() {
-    let timestamp;
-    if (isBrowser3() && window_3.performance) {
-      var _window$performance, _window$performance$n;
-      timestamp = window_3 === null || window_3 === void 0 ? void 0 : (_window$performance = window_3.performance) === null || _window$performance === void 0 ? void 0 : (_window$performance$n = _window$performance.now) === null || _window$performance$n === void 0 ? void 0 : _window$performance$n.call(_window$performance);
-    } else if ("hrtime" in process_) {
-      var _process$hrtime;
-      const timeParts = process_ === null || process_ === void 0 ? void 0 : (_process$hrtime = process_.hrtime) === null || _process$hrtime === void 0 ? void 0 : _process$hrtime.call(process_);
-      timestamp = timeParts[0] * 1e3 + timeParts[1] / 1e6;
-    } else {
-      timestamp = Date.now();
+  function parseMIMETypeFromURL(url) {
+    const matches3 = DATA_URL_PATTERN.exec(url);
+    if (matches3) {
+      return matches3[1];
     }
-    return timestamp;
+    return "";
   }
 
-  // ../../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() {
+  // ../core/src/lib/utils/url-utils.ts
+  var QUERY_STRING_PATTERN = /\?.*/;
+  function extractQueryString(url) {
+    const matches3 = url.match(QUERY_STRING_PATTERN);
+    return matches3 && matches3[0];
   }
-  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", VERSION2);
-      _defineProperty(this, "_startTs", getHiResTimestamp());
-      _defineProperty(this, "_deltaTs", getHiResTimestamp());
-      _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((getHiResTimestamp() - this._startTs).toPrecision(10));
-    }
-    getDelta() {
-      return Number((getHiResTimestamp() - 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
-      });
+  function stripQueryString(url) {
+    return url.replace(QUERY_STRING_PATTERN, "");
+  }
+  function shortenUrlForDisplay(url) {
+    if (url.length < 50) {
+      return url;
     }
-    log(logLevel, message) {
-      return this._getLogFunction(logLevel, message, originalConsole.debug, arguments);
+    const urlEnd = url.slice(url.length - 15);
+    const urlStart = url.substr(0, 32);
+    return `${urlStart}...${urlEnd}`;
+  }
+
+  // ../core/src/lib/utils/resource-utils.ts
+  function getResourceUrl(resource) {
+    if (isResponse(resource)) {
+      const response = resource;
+      return response.url;
     }
-    info(logLevel, message) {
-      return this._getLogFunction(logLevel, message, console.info, arguments);
+    if (isBlob(resource)) {
+      const blob = resource;
+      return blob.name || "";
     }
-    once(logLevel, message) {
-      return this._getLogFunction(logLevel, message, originalConsole.debug || originalConsole.info, arguments, ONCE);
+    if (typeof resource === "string") {
+      return resource;
     }
-    table(logLevel, table, columns) {
-      if (table) {
-        return this._getLogFunction(logLevel, table, console.table || noop, columns && [columns], {
-          tag: getTableHeader(table)
-        });
-      }
-      return noop;
+    return "";
+  }
+  function getResourceMIMEType(resource) {
+    if (isResponse(resource)) {
+      const response = resource;
+      const contentTypeHeader = response.headers.get("content-type") || "";
+      const noQueryUrl = stripQueryString(response.url);
+      return parseMIMEType(contentTypeHeader) || parseMIMETypeFromURL(noQueryUrl);
     }
-    image(_ref) {
-      let {
-        logLevel,
-        priority,
-        image,
-        message = "",
-        scale: scale3 = 1
-      } = _ref;
-      if (!this._shouldLog(logLevel || priority)) {
-        return noop;
-      }
-      return isBrowser3() ? logImageInBrowser({
-        image,
-        message,
-        scale: scale3
-      }) : logImageInNode({
-        image,
-        message,
-        scale: scale3
-      });
+    if (isBlob(resource)) {
+      const blob = resource;
+      return blob.type || "";
     }
-    time(logLevel, message) {
-      return this._getLogFunction(logLevel, message, console.time ? console.time : console.info);
+    if (typeof resource === "string") {
+      return parseMIMETypeFromURL(resource);
     }
-    timeEnd(logLevel, message) {
-      return this._getLogFunction(logLevel, message, console.timeEnd ? console.timeEnd : console.info);
+    return "";
+  }
+  function getResourceContentLength(resource) {
+    if (isResponse(resource)) {
+      const response = resource;
+      return response.headers["content-length"] || -1;
     }
-    timeStamp(logLevel, message) {
-      return this._getLogFunction(logLevel, message, console.timeStamp || noop);
+    if (isBlob(resource)) {
+      const blob = resource;
+      return blob.size;
     }
-    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);
+    if (typeof resource === "string") {
+      return resource.length;
     }
-    groupCollapsed(logLevel, message) {
-      let opts = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
-      return this.group(logLevel, message, Object.assign({}, opts, {
-        collapsed: true
-      }));
+    if (resource instanceof ArrayBuffer) {
+      return resource.byteLength;
     }
-    groupEnd(logLevel) {
-      return this._getLogFunction(logLevel, "", console.groupEnd || noop);
+    if (ArrayBuffer.isView(resource)) {
+      return resource.byteLength;
     }
-    withGroup(logLevel, message, func) {
-      this.group(logLevel, message)();
-      try {
-        func();
-      } finally {
-        this.groupEnd(logLevel)();
-      }
+    return -1;
+  }
+
+  // ../core/src/lib/utils/response-utils.ts
+  async function makeResponse(resource) {
+    if (isResponse(resource)) {
+      return resource;
     }
-    trace() {
-      if (console.trace) {
-        console.trace();
-      }
+    const headers = {};
+    const contentLength = getResourceContentLength(resource);
+    if (contentLength >= 0) {
+      headers["content-length"] = String(contentLength);
     }
-    _shouldLog(logLevel) {
-      return this.isEnabled() && this.getLevel() >= normalizeLogLevel(logLevel);
+    const url = getResourceUrl(resource);
+    const type = getResourceMIMEType(resource);
+    if (type) {
+      headers["content-type"] = type;
     }
-    _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 = getHiResTimestamp();
-        const tag = opts.tag || opts.message;
-        if (opts.once && tag) {
-          if (!cache[tag]) {
-            cache[tag] = getHiResTimestamp();
-          } else {
-            return noop;
-          }
-        }
-        message = decorateMessage(this.id, opts.message, opts);
-        return method.bind(console, message, ...opts.args);
-      }
-      return noop;
+    const initialDataUrl = await getInitialDataUrl(resource);
+    if (initialDataUrl) {
+      headers["x-first-bytes"] = initialDataUrl;
     }
-  };
-  _defineProperty(Log, "VERSION", VERSION2);
-  function normalizeLogLevel(logLevel) {
-    if (!logLevel) {
-      return 0;
+    if (typeof resource === "string") {
+      resource = new TextEncoder().encode(resource);
     }
-    let resolvedLevel;
-    switch (typeof logLevel) {
-      case "number":
-        resolvedLevel = logLevel;
-        break;
-      case "object":
-        resolvedLevel = logLevel.logLevel || logLevel.priority || 0;
-        break;
-      default:
-        return 0;
+    const response = new Response(resource, { headers });
+    Object.defineProperty(response, "url", { value: url });
+    return response;
+  }
+  async function checkResponse(response) {
+    if (!response.ok) {
+      const error = await getResponseError(response);
+      throw error;
     }
-    assert3(Number.isFinite(resolvedLevel) && resolvedLevel >= 0);
-    return resolvedLevel;
   }
-  function normalizeArguments(opts) {
-    const {
-      logLevel,
-      message
-    } = opts;
-    opts.logLevel = normalizeLogLevel(logLevel);
-    const args = opts.args ? Array.from(opts.args) : [];
-    while (args.length && args.shift() !== message) {
+  async function getResponseError(response) {
+    const shortUrl = shortenUrlForDisplay(response.url);
+    let message = `Failed to fetch resource (${response.status}) ${response.statusText}: ${shortUrl}`;
+    message = message.length > 100 ? `${message.slice(0, 100)}...` : message;
+    const info = {
+      reason: response.statusText,
+      url: response.url,
+      response
+    };
+    try {
+      const contentType = response.headers.get("Content-Type");
+      info.reason = contentType?.includes("application/json") ? await response.json() : response.text();
+    } catch (error) {
     }
-    switch (typeof logLevel) {
-      case "string":
-      case "function":
-        if (message !== void 0) {
-          args.unshift(message);
-        }
-        opts.message = logLevel;
-        break;
-      case "object":
-        Object.assign(opts, logLevel);
-        break;
-      default:
+    return new FetchError(message, info);
+  }
+  async function getInitialDataUrl(resource) {
+    const INITIAL_DATA_LENGTH = 5;
+    if (typeof resource === "string") {
+      return `data:,${resource.slice(0, INITIAL_DATA_LENGTH)}`;
     }
-    if (typeof opts.message === "function") {
-      opts.message = opts.message();
+    if (resource instanceof Blob) {
+      const blobSlice = resource.slice(0, 5);
+      return await new Promise((resolve2) => {
+        const reader = new FileReader();
+        reader.onload = (event) => resolve2(event?.target?.result);
+        reader.readAsDataURL(blobSlice);
+      });
     }
-    const messageType = typeof opts.message;
-    assert3(messageType === "string" || messageType === "object");
-    return Object.assign(opts, {
-      args
-    }, opts.opts);
+    if (resource instanceof ArrayBuffer) {
+      const slice = resource.slice(0, INITIAL_DATA_LENGTH);
+      const base64 = arrayBufferToBase64(slice);
+      return `data:base64,${base64}`;
+    }
+    return null;
   }
-  function decorateMessage(id, message, opts) {
-    if (typeof message === "string") {
-      const time = opts.time ? leftPad(formatTime(opts.total)) : "";
-      message = opts.time ? "".concat(id, ": ").concat(time, "  ").concat(message) : "".concat(id, ": ").concat(message);
-      message = addColor(message, opts.color, opts.background);
+  function arrayBufferToBase64(buffer) {
+    let binary = "";
+    const bytes = new Uint8Array(buffer);
+    for (let i2 = 0; i2 < bytes.byteLength; i2++) {
+      binary += String.fromCharCode(bytes[i2]);
     }
-    return message;
+    return btoa(binary);
   }
-  function logImageInNode(_ref2) {
-    let {
-      image,
-      message = "",
-      scale: scale3 = 1
-    } = _ref2;
-    console.warn("removed");
-    return noop;
+
+  // ../core/src/lib/fetch/fetch-file.ts
+  function isNodePath(url) {
+    return !isRequestURL(url) && !isDataURL(url);
   }
-  function logImageInBrowser(_ref3) {
-    let {
-      image,
-      message = "",
-      scale: scale3 = 1
-    } = _ref3;
-    if (typeof image === "string") {
-      const img = new Image();
-      img.onload = () => {
-        const args = formatImage(img, message, scale3);
-        console.log(...args);
-      };
-      img.src = image;
-      return noop;
-    }
-    const element = image.nodeName || "";
-    if (element.toLowerCase() === "img") {
-      console.log(...formatImage(image, message, scale3));
-      return noop;
-    }
-    if (element.toLowerCase() === "canvas") {
-      const img = new Image();
-      img.onload = () => console.log(...formatImage(img, message, scale3));
-      img.src = image.toDataURL();
-      return noop;
-    }
-    return noop;
+  function isRequestURL(url) {
+    return url.startsWith("http:") || url.startsWith("https:");
   }
-  function getTableHeader(table) {
-    for (const key in table) {
-      for (const title in table[key]) {
-        return title || "untitled";
+  function isDataURL(url) {
+    return url.startsWith("data:");
+  }
+  async function fetchFile(urlOrData, fetchOptions) {
+    if (typeof urlOrData === "string") {
+      const url = resolvePath(urlOrData);
+      if (isNodePath(url)) {
+        if (globalThis.loaders?.fetchNode) {
+          return globalThis.loaders?.fetchNode(url, fetchOptions);
+        }
       }
+      return await fetch(url, fetchOptions);
     }
-    return "empty";
+    return await makeResponse(urlOrData);
   }
 
-  // ../../node_modules/@probe.gl/log/dist/index.js
-  var dist_default = new Log({
-    id: "@probe.gl/log"
-  });
-
   // ../core/src/lib/loader-utils/loggers.ts
   var probeLog = new Log({ id: "loaders.gl" });
   var NullLog = class {
@@ -2280,10 +2295,10 @@
   }
   function findLoaderByMIMEType(loaders, mimeType) {
     for (const loader of loaders) {
-      if (loader.mimeTypes && loader.mimeTypes.includes(mimeType)) {
+      if (loader.mimeTypes?.some((mimeType1) => compareMIMETypes(mimeType, mimeType1))) {
         return loader;
       }
-      if (mimeType === `application/x.${loader.id}`) {
+      if (compareMIMETypes(mimeType, `application/x.${loader.id}`)) {
         return loader;
       }
     }
@@ -2605,7 +2620,7 @@
     if (loaderWithParser.parse) {
       return await loaderWithParser.parse(data, options, context);
     }
-    assert2(!loaderWithParser.parseSync);
+    assert3(!loaderWithParser.parseSync);
     throw new Error(`${loader.id} loader - no parser found and worker is disabled`);
   }
 
@@ -5314,7 +5329,7 @@
   _defineProperty(Ellipsoid, "WGS84", new Ellipsoid(WGS84_RADIUS_X, WGS84_RADIUS_Y, WGS84_RADIUS_Z));
 
   // ../images/src/lib/utils/version.ts
-  var VERSION3 = true ? "4.2.0-alpha.5" : "latest";
+  var VERSION3 = true ? "4.2.0-beta.1" : "latest";
 
   // ../images/src/lib/category-api/image-type.ts
   var parseImageNode = globalThis.loaders?.parseImageNode;
@@ -5707,6 +5722,8 @@
     // imagebitmap: {} - passes (platform dependent) parameters to ImageBitmap constructor
   };
   var ImageLoader = {
+    dataType: null,
+    batchType: null,
     id: "image",
     module: "images",
     name: "Images",
@@ -5720,10 +5737,12 @@
   };
 
   // ../draco/src/lib/utils/version.ts
-  var VERSION4 = true ? "4.2.0-alpha.5" : "latest";
+  var VERSION4 = true ? "4.2.0-beta.1" : "latest";
 
   // ../draco/src/draco-loader.ts
   var DracoLoader = {
+    dataType: null,
+    batchType: null,
     name: "Draco",
     id: "draco",
     module: "draco",
@@ -5801,7 +5820,11 @@
     4: Uint16Array,
     5: Int32Array,
     6: Uint32Array,
+    // 7: BigInt64Array,
+    // 8: BigUint64Array,
     9: Float32Array
+    // 10: Float64Array
+    // 11: BOOL - What array type do we use for this?
   };
   var INDEX_ITEM_SIZE = 4;
   var DracoParser = class {
@@ -5974,14 +5997,17 @@
       for (const loaderAttribute of Object.values(loaderData.attributes)) {
         const attributeName = this._deduceAttributeName(loaderAttribute, options);
         loaderAttribute.name = attributeName;
-        const { value, size } = this._getAttributeValues(dracoGeometry, loaderAttribute);
-        attributes[attributeName] = {
-          value,
-          size,
-          byteOffset: loaderAttribute.byte_offset,
-          byteStride: loaderAttribute.byte_stride,
-          normalized: loaderAttribute.normalized
-        };
+        const values = this._getAttributeValues(dracoGeometry, loaderAttribute);
+        if (values) {
+          const { value, size } = values;
+          attributes[attributeName] = {
+            value,
+            size,
+            byteOffset: loaderAttribute.byte_offset,
+            byteStride: loaderAttribute.byte_stride,
+            normalized: loaderAttribute.normalized
+          };
+        }
       }
       return attributes;
     }
@@ -6023,6 +6049,10 @@
      */
     _getAttributeValues(dracoGeometry, attribute) {
       const TypedArrayCtor = DRACO_DATA_TYPE_TO_TYPED_ARRAY_MAP[attribute.data_type];
+      if (!TypedArrayCtor) {
+        console.warn(`DRACO: Unsupported attribute type ${attribute.data_type}`);
+        return null;
+      }
       const numComponents = attribute.num_components;
       const numPoints = dracoGeometry.num_points();
       const numValues = numPoints * numComponents;
@@ -6253,11 +6283,11 @@
   async function loadDracoDecoderModule(options) {
     const modules = options.modules || {};
     if (modules.draco3d) {
-      loadDecoderPromise = loadDecoderPromise || modules.draco3d.createDecoderModule({}).then((draco) => {
+      loadDecoderPromise ||= modules.draco3d.createDecoderModule({}).then((draco) => {
         return { draco };
       });
     } else {
-      loadDecoderPromise = loadDecoderPromise || loadDracoDecoder(options);
+      loadDecoderPromise ||= loadDracoDecoder(options);
     }
     return await loadDecoderPromise;
   }
@@ -6323,7 +6353,7 @@
   }
 
   // ../textures/src/lib/utils/version.ts
-  var VERSION5 = true ? "4.2.0-alpha.5" : "latest";
+  var VERSION5 = true ? "4.2.0-beta.1" : "latest";
 
   // ../textures/src/lib/parsers/basis-module-loader.ts
   var BASIS_EXTERNAL_LIBRARIES = {
@@ -6338,11 +6368,12 @@
   };
   var loadBasisTranscoderPromise;
   async function loadBasisTranscoderModule(options) {
-    const modules = options.modules || {};
-    if (modules.basis) {
-      return modules.basis;
+    registerJSModules(options.modules);
+    const basis = getJSModuleOrNull("basis");
+    if (basis) {
+      return basis;
     }
-    loadBasisTranscoderPromise = loadBasisTranscoderPromise || loadBasisTranscoder(options);
+    loadBasisTranscoderPromise ||= loadBasisTranscoder(options);
     return await loadBasisTranscoderPromise;
   }
   async function loadBasisTranscoder(options) {
@@ -7008,6 +7039,8 @@
 
   // ../textures/src/basis-loader.ts
   var BasisWorkerLoader = {
+    dataType: null,
+    batchType: null,
     name: "Basis",
     id: "basis",
     module: "textures",
@@ -7020,12 +7053,9 @@
     options: {
       basis: {
         format: "auto",
-        // gl context doesn't exist on a worker thread
         libraryPath: "libs/",
         containerFormat: "auto",
-        // 'basis' || 'ktx2' || 'auto'
         module: "transcoder"
-        // 'transcoder' || 'encoder'
       }
     }
   };
@@ -7326,6 +7356,8 @@
 
   // ../textures/src/compressed-texture-loader.ts
   var CompressedTextureWorkerLoader = {
+    dataType: null,
+    batchType: null,
     name: "Texture Containers",
     id: "compressed-texture",
     module: "textures",
@@ -7852,8 +7884,10 @@
   }
 
   // src/i3s-content-loader.ts
-  var VERSION6 = true ? "4.2.0-alpha.5" : "latest";
+  var VERSION6 = true ? "4.2.0-beta.1" : "latest";
   var I3SContentLoader = {
+    dataType: null,
+    batchType: null,
     name: "I3S Content (Indexed Scene Layers)",
     id: "i3s-content",
     module: "i3s",