@loaders.gl/core 5.0.0-alpha.12 → 5.0.0-alpha.13

package/dist/worker-utils/index.cjs

@@ -0,0 +1,1448 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// dist/worker-utils/index.js
+var index_exports = {};
+__export(index_exports, {
+  AsyncQueue: () => AsyncQueue,
+  ChildProcessProxy: () => ChildProcessProxy,
+  NullWorker: () => NullWorker,
+  WorkerBody: () => WorkerBody,
+  WorkerFarm: () => WorkerFarm,
+  WorkerJob: () => WorkerJob,
+  WorkerPool: () => WorkerPool,
+  WorkerThread: () => WorkerThread,
+  assert: () => assert,
+  canProcessOnWorker: () => canProcessOnWorker,
+  createWorker: () => createWorker,
+  extractLoadLibraryOptions: () => extractLoadLibraryOptions,
+  getLibraryUrl: () => getLibraryUrl,
+  getTransferList: () => getTransferList,
+  getTransferListForWriter: () => getTransferListForWriter,
+  getWorkerURL: () => getWorkerURL,
+  isBrowser: () => isBrowser,
+  isWorker: () => isWorker,
+  loadLibrary: () => loadLibrary,
+  preloadWorker: () => preloadWorker,
+  processOnWorker: () => processOnWorker,
+  processOnWorkerInBatches: () => processOnWorkerInBatches,
+  validateWorkerVersion: () => validateWorkerVersion
+});
+module.exports = __toCommonJS(index_exports);
+
+// dist/worker-utils/lib/npm-tag.js
+var NPM_TAG = "latest";
+
+// dist/worker-utils/lib/env-utils/version.js
+function getVersion() {
+  var _a;
+  if (!((_a = globalThis._loadersgl_) == null ? void 0 : _a.version)) {
+    globalThis._loadersgl_ = globalThis._loadersgl_ || {};
+    if (false) {
+      globalThis._loadersgl_.version = NPM_TAG;
+    } else {
+      globalThis._loadersgl_.version = "5.0.0-alpha.13";
+    }
+  }
+  return globalThis._loadersgl_.version;
+}
+var VERSION = getVersion();
+
+// dist/worker-utils/lib/env-utils/assert.js
+function assert(condition, message) {
+  if (!condition) {
+    throw new Error(message || "loaders.gl assertion failed.");
+  }
+}
+
+// dist/worker-utils/lib/env-utils/globals.js
+var globals = {
+  self: typeof self !== "undefined" && self,
+  window: typeof window !== "undefined" && window,
+  global: typeof global !== "undefined" && global,
+  document: typeof document !== "undefined" && document
+};
+var self_ = globals.self || globals.window || globals.global || {};
+var window_ = globals.window || globals.self || globals.global || {};
+var global_ = globals.global || globals.self || globals.window || {};
+var document_ = globals.document || {};
+var isBrowser = (
+  // @ts-ignore process.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 matches = typeof process !== "undefined" && process.version && /v([0-9]*)/.exec(process.version);
+var nodeVersion = matches && parseFloat(matches[1]) || 0;
+
+// dist/worker-utils/lib/worker-farm/worker-job.js
+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((resolve, reject) => {
+      this._resolve = resolve;
+      this._reject = reject;
+    });
+  }
+  /**
+   * Send a message to the job's worker thread
+   * @param data any data structure, ideally consisting mostly of transferrable objects
+   */
+  postMessage(type, payload) {
+    this.workerThread.postMessage({
+      source: "loaders.gl",
+      // Lets worker ignore unrelated messages
+      type,
+      payload
+    });
+  }
+  /**
+   * Call to resolve the `result` Promise with the supplied value
+   */
+  done(value) {
+    if (!this.isRunning) {
+      return;
+    }
+    this.isRunning = false;
+    this._resolve(value);
+  }
+  /**
+   * Call to reject the `result` Promise with the supplied error
+   */
+  error(error) {
+    if (!this.isRunning) {
+      return;
+    }
+    this.isRunning = false;
+    this._reject(error);
+  }
+  /**
+   * Terminates the worker executing this job and rejects its result.
+   * @param reason Abort reason supplied by the caller, or a cross-runtime `AbortError`.
+   */
+  abort(reason) {
+    if (!this.isRunning) {
+      return;
+    }
+    const error = reason ?? createAbortError(`Worker job "${this.name}" was aborted`);
+    this.workerThread.destroy();
+    this.error(error);
+  }
+};
+function createAbortError(message) {
+  const error = new Error(message);
+  error.name = "AbortError";
+  return error;
+}
+
+// dist/worker-utils/lib/node/worker_threads-browser.js
+var NodeWorker = class {
+  /** Restores the native worker constructor when this browser shim is embedded in a Node bundle. */
+  constructor(...arguments_) {
+    var _a;
+    const runtimeProcess = globalThis.process;
+    const WorkerConstructor = (_a = runtimeProcess == null ? void 0 : runtimeProcess.getBuiltinModule) == null ? void 0 : _a.call(runtimeProcess, "node:worker_threads").Worker;
+    if (WorkerConstructor) {
+      return new WorkerConstructor(...arguments_);
+    }
+  }
+  /** No-op browser fallback matching the native Worker API. */
+  terminate() {
+  }
+};
+var parentPort = null;
+
+// dist/worker-utils/lib/worker-utils/get-loadable-worker-url.js
+var workerURLCache = /* @__PURE__ */ new Map();
+function getLoadableWorkerURL(props) {
+  assert(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);
+    }
+  }
+  assert(workerURL);
+  return workerURL;
+}
+function getLoadableWorkerURLFromURL(url) {
+  if (!url.startsWith("http")) {
+    return url;
+  }
+  const workerSource = buildScriptSource(url);
+  return getLoadableWorkerURLFromSource(workerSource);
+}
+function getLoadableWorkerURLFromSource(workerSource) {
+  const blob = new Blob([workerSource], { type: "application/javascript" });
+  return URL.createObjectURL(blob);
+}
+function buildScriptSource(workerUrl) {
+  return `try {
+  importScripts('${workerUrl}');
+} catch (error) {
+  console.error(error);
+  throw error;
+}`;
+}
+
+// dist/worker-utils/lib/worker-utils/get-transfer-list.js
+function getTransferList(object, recursive = true, transfers) {
+  const transfersSet = transfers || /* @__PURE__ */ new Set();
+  if (!object) {
+  } else if (isTransferable(object)) {
+    transfersSet.add(object);
+  } else if (isTransferable(object.buffer)) {
+    transfersSet.add(object.buffer);
+  } else if (ArrayBuffer.isView(object)) {
+  } else if (recursive && typeof object === "object") {
+    for (const key in object) {
+      getTransferList(object[key], recursive, transfersSet);
+    }
+  }
+  return transfers === void 0 ? Array.from(transfersSet) : [];
+}
+function isTransferable(object) {
+  if (!object) {
+    return false;
+  }
+  if (object instanceof ArrayBuffer) {
+    return true;
+  }
+  if (typeof MessagePort !== "undefined" && object instanceof MessagePort) {
+    return true;
+  }
+  if (typeof ImageBitmap !== "undefined" && object instanceof ImageBitmap) {
+    return true;
+  }
+  if (typeof OffscreenCanvas !== "undefined" && object instanceof OffscreenCanvas) {
+    return true;
+  }
+  return false;
+}
+function getTransferListForWriter(object) {
+  if (object === null) {
+    return {};
+  }
+  const clone = Object.assign({}, object);
+  Object.keys(clone).forEach((key) => {
+    if (typeof object[key] === "object" && !ArrayBuffer.isView(object[key]) && !(object[key] instanceof Array)) {
+      clone[key] = getTransferListForWriter(object[key]);
+    } else if (typeof clone[key] === "function" || clone[key] instanceof RegExp) {
+      clone[key] = {};
+    } else {
+      clone[key] = object[key];
+    }
+  });
+  return clone;
+}
+
+// dist/worker-utils/lib/worker-farm/worker-thread.js
+var NOOP = () => {
+};
+var WorkerThread = class {
+  name;
+  source;
+  url;
+  /** Lazily resolves the classic worker URL used as a fallback. */
+  getUrl;
+  /** Creates a browser Worker directly. */
+  loadWorker;
+  terminated = false;
+  worker;
+  onMessage;
+  onError;
+  _loadableURL = "";
+  /** Checks if workers are supported on this platform */
+  static isSupported() {
+    return typeof Worker !== "undefined" && isBrowser || typeof NodeWorker !== "undefined" && !isBrowser;
+  }
+  constructor(props) {
+    const { name, source, url, getUrl, loadWorker } = props;
+    assert(source || url || getUrl || loadWorker);
+    this.name = name;
+    this.source = source;
+    this.url = url;
+    this.getUrl = getUrl;
+    this.loadWorker = loadWorker;
+    this.onMessage = NOOP;
+    this.onError = (error) => console.log(error);
+    this.worker = isBrowser ? this._createBrowserWorker() : this._createNodeWorker();
+  }
+  /**
+   * Terminate this worker thread
+   * @note Can free up significant memory
+   */
+  destroy() {
+    this.onMessage = NOOP;
+    this.onError = NOOP;
+    this.worker.terminate();
+    this.terminated = true;
+  }
+  /** Keeps this worker from preventing Node.js process exit while idle. */
+  unref() {
+    if (!isBrowser && typeof this.worker.unref === "function") {
+      this.worker.unref();
+    }
+  }
+  /** Keeps this worker alive while it is actively processing a job. */
+  ref() {
+    if (!isBrowser && typeof this.worker.ref === "function") {
+      this.worker.ref();
+    }
+  }
+  get isRunning() {
+    return Boolean(this.onMessage);
+  }
+  /**
+   * Send a message to this worker thread
+   * @param data any data structure, ideally consisting mostly of transferrable objects
+   * @param transferList If not supplied, calculated automatically by traversing data
+   */
+  postMessage(data, transferList) {
+    transferList = transferList || getTransferList(data);
+    this.worker.postMessage(data, transferList);
+  }
+  // PRIVATE
+  /**
+   * Generate a standard Error from an ErrorEvent
+   * @param event
+   */
+  _getErrorFromErrorEvent(event) {
+    let message = "Failed to load ";
+    message += `worker ${this.name} from ${this.url || "built-in worker factory"}. `;
+    if (event.message) {
+      message += `${event.message} in `;
+    }
+    if (event.lineno) {
+      message += `:${event.lineno}:${event.colno}`;
+    }
+    return new Error(message);
+  }
+  /**
+   * Creates a worker thread on the browser
+   */
+  _createBrowserWorker() {
+    var _a;
+    if (this.loadWorker) {
+      try {
+        const worker2 = this.loadWorker();
+        if (worker2) {
+          return this._initializeBrowserWorker(worker2);
+        }
+      } catch (error) {
+        if (!this.source && !this.url && !this.getUrl) {
+          throw error;
+        }
+      }
+    }
+    const url = this.url || ((_a = this.getUrl) == null ? void 0 : _a.call(this));
+    this._loadableURL = getLoadableWorkerURL({ source: this.source, url });
+    const worker = new Worker(this._loadableURL, { name: this.name });
+    return this._initializeBrowserWorker(worker);
+  }
+  /** Attaches protocol handlers to a browser worker. */
+  _initializeBrowserWorker(worker) {
+    worker.onmessage = (event) => {
+      if (!event.data) {
+        this.onError(new Error("No data received"));
+      } else {
+        this.onMessage(event.data);
+      }
+    };
+    worker.onerror = (error) => {
+      this.onError(this._getErrorFromErrorEvent(error));
+      this.terminated = true;
+    };
+    worker.onmessageerror = (event) => console.error(event);
+    return worker;
+  }
+  /**
+   * Creates a worker thread in node.js
+   * @todo https://nodejs.org/api/async_hooks.html#async-resource-worker-pool
+   */
+  _createNodeWorker() {
+    let worker;
+    if (this.url) {
+      const absolute = this.url.includes(":/") || this.url.startsWith("/");
+      const url = absolute ? this.url : `./${this.url}`;
+      const workerUrl = url.startsWith("file:") ? new URL(url) : url;
+      const type = this.url.endsWith(".ts") || this.url.endsWith(".mjs") ? "module" : "commonjs";
+      worker = new NodeWorker(workerUrl, { eval: false, type });
+    } else if (this.source) {
+      worker = new NodeWorker(this.source, { eval: true });
+    } else {
+      throw new Error("no worker");
+    }
+    worker.on("message", (data) => {
+      this.onMessage(data);
+    });
+    worker.on("error", (error) => {
+      this.onError(error);
+    });
+    worker.on("exit", (_code) => {
+    });
+    return worker;
+  }
+};
+
+// dist/worker-utils/lib/worker-farm/worker-pool.js
+var WorkerPool = class {
+  name = "unnamed";
+  source;
+  // | Function;
+  url;
+  /** Lazily resolves a classic worker fallback URL. */
+  getUrl;
+  /** Creates a browser Worker directly. */
+  loadWorker;
+  maxConcurrency = 1;
+  maxMobileConcurrency = 1;
+  onDebug = () => {
+  };
+  reuseWorkers = true;
+  props = {};
+  jobQueue = [];
+  idleQueue = [];
+  activeJobs = /* @__PURE__ */ new Set();
+  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.getUrl = props.getUrl;
+    this.loadWorker = props.loadWorker;
+    this.setProps(props);
+  }
+  /**
+   * Terminates all workers in the pool and aborts active jobs.
+   * @param reason Optional error delivered to active jobs.
+   * @note Can free up significant memory
+   */
+  destroy(reason = new Error("Worker pool was destroyed")) {
+    this.activeJobs.forEach((job) => job.abort(reason));
+    const queuedJobs = this.jobQueue.splice(0);
+    queuedJobs.forEach((queuedJob) => queuedJob.onReject(reason));
+    this.idleQueue.forEach((worker) => worker.destroy());
+    this.isDestroyed = true;
+  }
+  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)) {
+    if (this.isDestroyed) {
+      return Promise.reject(new Error("Worker pool was destroyed"));
+    }
+    const startPromise = new Promise((onStart, onReject) => {
+      this.jobQueue.push({ name, onMessage: onMessage2, onError, onStart, onReject });
+      return this;
+    });
+    this._startQueuedJob();
+    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);
+      this.activeJobs.add(job);
+      workerThread.ref();
+      workerThread.onMessage = (data) => queuedJob.onMessage(job, data.type, data.payload);
+      workerThread.onError = (error) => queuedJob.onError(job, error);
+      queuedJob.onStart(job);
+      try {
+        await job.result;
+      } catch {
+      } finally {
+        this.activeJobs.delete(job);
+        this.returnWorkerToQueue(workerThread);
+      }
+    }
+  }
+  /**
+   * Returns a worker to the idle queue
+   * Destroys the worker if
+   *  - pool is destroyed
+   *  - if this pool doesn't reuse workers
+   *  - if maxConcurrency has been lowered
+   * @param worker
+   */
+  returnWorkerToQueue(worker) {
+    const shouldDestroyWorker = (
+      // Aborted jobs terminate their worker immediately.
+      worker.terminated || // If the pool is destroyed, there is no reason to keep the worker around
+      this.isDestroyed || // If the app has disabled worker reuse, any completed workers should be destroyed
+      !this.reuseWorkers || // If concurrency has been lowered, this worker might be surplus to requirements
+      this.count > this._getMaxConcurrency()
+    );
+    if (shouldDestroyWorker) {
+      if (!worker.terminated) {
+        worker.destroy();
+      }
+      this.count--;
+    } else {
+      worker.unref();
+      this.idleQueue.push(worker);
+    }
+    if (!this.isDestroyed) {
+      this._startQueuedJob();
+    }
+  }
+  /**
+   * Returns idle worker or creates new worker if maxConcurrency has not been reached
+   */
+  _getAvailableWorker() {
+    if (this.idleQueue.length > 0) {
+      return this.idleQueue.shift() || null;
+    }
+    if (this.count < this._getMaxConcurrency()) {
+      this.count++;
+      const name = `${this.name.toLowerCase()} (#${this.count} of ${this.maxConcurrency})`;
+      return new WorkerThread({
+        name,
+        source: this.source,
+        url: this.url,
+        getUrl: this.getUrl,
+        loadWorker: this.loadWorker
+      });
+    }
+    return null;
+  }
+  _getMaxConcurrency() {
+    return isMobile ? this.maxMobileConcurrency : this.maxConcurrency;
+  }
+};
+
+// dist/worker-utils/lib/worker-farm/worker-farm.js
+var DEFAULT_PROPS = {
+  maxConcurrency: 3,
+  maxMobileConcurrency: 1,
+  reuseWorkers: true,
+  onDebug: () => {
+  }
+};
+var loadWorkerIds = /* @__PURE__ */ new WeakMap();
+var nextLoadWorkerId = 1;
+var WorkerFarm = class _WorkerFarm {
+  props;
+  workerPools = /* @__PURE__ */ new Map();
+  // singleton
+  static _workerFarm;
+  /** Checks if workers are supported on this platform */
+  static isSupported() {
+    return WorkerThread.isSupported();
+  }
+  /** 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 and abort active jobs.
+   * @param reason Optional error delivered to active jobs.
+   * @note Can free up significant memory
+   */
+  destroy(reason) {
+    for (const workerPool of this.workerPools.values()) {
+      workerPool.destroy(reason);
+    }
+    this.workerPools = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Set props used when initializing worker pools
+   * @param props
+   */
+  setProps(props) {
+    this.props = { ...this.props, ...props };
+    for (const workerPool of this.workerPools.values()) {
+      workerPool.setProps(this._getWorkerPoolProps());
+    }
+  }
+  /**
+   * Returns a worker pool for the specified worker
+   * @param options Worker target used to identify and initialize the pool.
+   * @param options.name Worker name used as the base pool identity.
+   * @param options.url Worker script URL.
+   * @param options.source Inline worker source.
+   * @param options.loadWorker Built-in browser worker factory.
+   * @example
+   *   const job = WorkerFarm.getWorkerFarm().getWorkerPool({name, url}).startJob(...);
+   */
+  getWorkerPool(options) {
+    const { name, source, url, getUrl, loadWorker } = options;
+    const workerPoolKey = getWorkerPoolKey(options);
+    let workerPool = this.workerPools.get(workerPoolKey);
+    if (!workerPool) {
+      workerPool = new WorkerPool({
+        name,
+        source,
+        url,
+        getUrl,
+        loadWorker
+      });
+      workerPool.setProps(this._getWorkerPoolProps());
+      this.workerPools.set(workerPoolKey, workerPool);
+    }
+    return workerPool;
+  }
+  _getWorkerPoolProps() {
+    return {
+      maxConcurrency: this.props.maxConcurrency,
+      maxMobileConcurrency: this.props.maxMobileConcurrency,
+      reuseWorkers: this.props.reuseWorkers,
+      onDebug: this.props.onDebug
+    };
+  }
+};
+function getWorkerPoolKey(options) {
+  const { name, source, url, urlKey, loadWorker } = options;
+  const sourceKey = source ? `source:${source}` : "";
+  const urlKeyPart = url || urlKey ? `url:${url || urlKey}` : "";
+  const loadWorkerKey = loadWorker ? `loadWorker:${getLoadWorkerId(loadWorker)}` : "";
+  return [name, sourceKey, urlKeyPart, loadWorkerKey].filter(Boolean).join("|");
+}
+function getLoadWorkerId(loadWorker) {
+  let loadWorkerId = loadWorkerIds.get(loadWorker);
+  if (!loadWorkerId) {
+    loadWorkerId = nextLoadWorkerId++;
+    loadWorkerIds.set(loadWorker, loadWorkerId);
+  }
+  return loadWorkerId;
+}
+
+// dist/worker-utils/lib/worker-farm/worker-body.js
+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);
+    }
+    getParentPort().then((parentPort2) => {
+      if (parentPort2) {
+        parentPort2.on("message", (message) => {
+          handleMessage(message);
+        });
+        parentPort2.on("exit", () => console.debug("Node worker closing"));
+      } else {
+        globalThis.onmessage = handleMessage;
+      }
+    });
+  }
+  static async addEventListener(onMessage2) {
+    let onMessageWrapper = onMessageWrapperMap.get(onMessage2);
+    if (!onMessageWrapper) {
+      onMessageWrapper = (message) => {
+        const messageData = getWorkerMessageData(message);
+        if (!messageData) {
+          return;
+        }
+        onMessage2(messageData.type, messageData.payload);
+      };
+      onMessageWrapperMap.set(onMessage2, onMessageWrapper);
+    }
+    const parentPort2 = await getParentPort();
+    if (parentPort2) {
+      parentPort2.on("message", onMessageWrapper);
+    } else {
+      globalThis.addEventListener("message", onMessageWrapper);
+    }
+  }
+  static async removeEventListener(onMessage2) {
+    const onMessageWrapper = onMessageWrapperMap.get(onMessage2);
+    onMessageWrapperMap.delete(onMessage2);
+    if (!onMessageWrapper) {
+      return;
+    }
+    const parentPort2 = await getParentPort();
+    if (parentPort2) {
+      parentPort2.off("message", onMessageWrapper);
+    } else {
+      globalThis.removeEventListener("message", onMessageWrapper);
+    }
+  }
+  /**
+   * 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);
+    }
+  }
+};
+function getWorkerMessageData(message) {
+  if (!message || typeof message !== "object") {
+    return null;
+  }
+  const messageData = "data" in message && message.type === "message" ? message.data : message;
+  return messageData && typeof messageData.source === "string" && messageData.source.startsWith("loaders.gl") ? messageData : null;
+}
+
+// dist/worker-utils/lib/async-queue/async-queue.js
+var AsyncQueue = class {
+  _values;
+  _settlers;
+  _closed;
+  constructor() {
+    this._values = [];
+    this._settlers = [];
+    this._closed = false;
+  }
+  /** Return an async iterator for this queue */
+  [Symbol.asyncIterator]() {
+    return this;
+  }
+  /** Push a new value - the async iterator will yield a promise resolved to this value */
+  push(value) {
+    return this.enqueue(value);
+  }
+  /**
+   * Push a new value - the async iterator will yield a promise resolved to this value
+   * Add an error - the async iterator will yield a promise rejected with this value
+   */
+  enqueue(value) {
+    if (this._closed) {
+      throw new Error("Closed");
+    }
+    if (this._settlers.length > 0) {
+      if (this._values.length > 0) {
+        throw new Error("Illegal internal state");
+      }
+      const settler = this._settlers.shift();
+      if (value instanceof Error) {
+        settler.reject(value);
+      } else {
+        settler.resolve({ value });
+      }
+    } else {
+      this._values.push(value);
+    }
+  }
+  /** Indicate that we not waiting for more values - The async iterator will be done */
+  close() {
+    while (this._settlers.length > 0) {
+      const settler = this._settlers.shift();
+      settler.resolve({ done: true });
+    }
+    this._closed = true;
+  }
+  // ITERATOR IMPLEMENTATION
+  /** @returns a Promise for an IteratorResult */
+  next() {
+    if (this._values.length > 0) {
+      const value = this._values.shift();
+      if (value instanceof Error) {
+        return Promise.reject(value);
+      }
+      return Promise.resolve({ done: false, value });
+    }
+    if (this._closed) {
+      if (this._settlers.length > 0) {
+        throw new Error("Illegal internal state");
+      }
+      return Promise.resolve({ done: true, value: void 0 });
+    }
+    return new Promise((resolve, reject) => {
+      this._settlers.push({ resolve, reject });
+    });
+  }
+};
+
+// dist/worker-utils/lib/worker-api/get-worker-url.js
+var warnedWorkerVersionFallbacks = /* @__PURE__ */ new Set();
+function getWorkerName(worker) {
+  const warning = worker.version !== VERSION ? ` (worker-utils@${VERSION})` : "";
+  return `${worker.name}@${worker.version}${warning}`;
+}
+function getCustomWorkerURL(worker, options = {}) {
+  var _a, _b;
+  const workerOptions = options[worker.id] || {};
+  const workerFile = isBrowser ? worker.workerFile || `${worker.id}-worker.js` : worker.workerNode || `${worker.id}-worker-node.js`;
+  let url = workerOptions.workerUrl;
+  if (!url && worker.id === "compression") {
+    url = options.workerUrl;
+  }
+  const workerType = options._workerType || ((_a = options == null ? void 0 : options.core) == null ? void 0 : _a._workerType);
+  if (!url && workerType === "test") {
+    if (isBrowser) {
+      url = `modules/${worker.module}/dist/${workerFile}`;
+    } else {
+      const workerSourceDirectory = worker.module === "core" && ((_b = worker.workerNode) == null ? void 0 : _b.startsWith("worker-utils/")) ? "worker-utils/workers" : "workers";
+      const workerSourceNode = worker.workerSourceNode || `${workerSourceDirectory}/${worker.id}-worker-node.ts`;
+      url = `modules/${worker.module}/src/${workerSourceNode}`;
+    }
+  }
+  return url || null;
+}
+function getWorkerURL(worker, options = {}) {
+  const customWorkerUrl = getCustomWorkerURL(worker, options);
+  const descriptorWorkerUrl = typeof worker.worker === "string" ? worker.worker : null;
+  const url = customWorkerUrl || descriptorWorkerUrl || getDefaultWorkerURL(worker, true);
+  assert(url);
+  return url;
+}
+function getDefaultWorkerURL(worker, warn = false) {
+  const workerFile = isBrowser ? worker.workerFile || `${worker.id}-worker.js` : worker.workerNode || `${worker.id}-worker-node.js`;
+  let version = worker.version;
+  if (version === "latest") {
+    version = NPM_TAG;
+  }
+  const versionTag = version ? `@${version}` : "";
+  const url = `https://unpkg.com/@loaders.gl/${worker.module}${versionTag}/dist/${workerFile}`;
+  if (warn) {
+    warnIfUsingNpmTagFallback(worker, url);
+  }
+  return url;
+}
+function warnIfUsingNpmTagFallback(worker, url) {
+  if (worker.version !== "latest") {
+    return;
+  }
+  const workerId = `${worker.module}:${worker.id}`;
+  if (warnedWorkerVersionFallbacks.has(workerId)) {
+    return;
+  }
+  warnedWorkerVersionFallbacks.add(workerId);
+  console.warn(`loaders.gl: ${worker.name} loader worker version is "latest" because __VERSION__ was not injected. Fetching ${url} from CDN.`);
+}
+
+// dist/worker-utils/lib/worker-api/process-on-worker.js
+function canProcessOnWorker(worker, options) {
+  if (!WorkerFarm.isSupported()) {
+    return false;
+  }
+  const workerOptions = options == null ? void 0 : options[worker.id];
+  return Boolean((worker.worker || worker.loadWorker || (workerOptions == null ? void 0 : workerOptions.workerUrl)) && (options == null ? void 0 : options.worker));
+}
+async function processOnWorker(worker, data, options = {}, context = {}, jobContext = {}) {
+  var _a, _b, _c;
+  throwIfAborted(options.signal);
+  const name = getWorkerName(worker);
+  const workerFarm = WorkerFarm.getWorkerFarm(options);
+  const workerPool = workerFarm.getWorkerPool(getWorkerPoolTarget(worker, options, name));
+  const jobName = options.jobName || worker.name;
+  const job = await workerPool.startJob(
+    jobName,
+    // eslint-disable-next-line
+    onMessage.bind(null, context)
+  );
+  const abortJob = () => job.abort(getAbortReason(options.signal));
+  (_a = options.signal) == null ? void 0 : _a.addEventListener("abort", abortJob, { once: true });
+  if ((_b = options.signal) == null ? void 0 : _b.aborted) {
+    abortJob();
+  }
+  try {
+    const { signal: _signal, ...workerOptions } = options;
+    const transferableOptions = getTransferListForWriter(workerOptions);
+    const transferableContext = getTransferListForWriter(jobContext);
+    if (job.isRunning) {
+      job.postMessage("process", {
+        input: data,
+        options: transferableOptions,
+        context: transferableContext
+      });
+    }
+    const result = await job.result;
+    return result.result;
+  } finally {
+    (_c = options.signal) == null ? void 0 : _c.removeEventListener("abort", abortJob);
+  }
+}
+function processOnWorkerInBatches(worker, input, options = {}, context = {}, jobContext = {}) {
+  return processOnWorkerInBatchesIterator(worker, input, options, context, jobContext);
+}
+async function* processOnWorkerInBatchesIterator(worker, input, options, context, jobContext) {
+  var _a, _b, _c;
+  throwIfAborted(options.signal);
+  const name = getWorkerName(worker);
+  const workerFarm = WorkerFarm.getWorkerFarm(options);
+  const workerPool = workerFarm.getWorkerPool(getWorkerPoolTarget(worker, options, name));
+  const outputBatches = new AsyncQueue();
+  const inputIterator = getAsyncIterator(input);
+  let outputFinished = false;
+  let inputFinished = false;
+  let inputRequest = Promise.resolve();
+  const batchJobFailed = new Error("Worker batch job failed");
+  const finishOutput = () => {
+    if (!outputFinished) {
+      outputFinished = true;
+      outputBatches.close();
+    }
+  };
+  const failOutput = (_error) => {
+    if (!outputFinished) {
+      outputFinished = true;
+      outputBatches.enqueue(batchJobFailed);
+      outputBatches.close();
+    }
+  };
+  const job = await workerPool.startJob(options.jobName || worker.name, (activeJob, type, payload) => {
+    switch (type) {
+      case "input-request":
+        inputRequest = inputRequest.then(async () => {
+          const nextBatch = await inputIterator.next();
+          if (!activeJob.isRunning) {
+            return;
+          }
+          if (nextBatch.done) {
+            inputFinished = true;
+            activeJob.postMessage("input-done", {});
+          } else {
+            activeJob.postMessage("input-batch", { input: nextBatch.value });
+          }
+        }).catch((error) => activeJob.abort(error));
+        break;
+      case "output-batch":
+        outputBatches.push(payload.result);
+        break;
+      case "done":
+        activeJob.done(payload);
+        finishOutput();
+        break;
+      case "error": {
+        const error = new Error(payload.error || "Worker batch processing failed");
+        activeJob.error(error);
+        failOutput(error);
+        break;
+      }
+      case "process":
+        void onMessage(context, activeJob, type, payload);
+        break;
+      default: {
+        const error = new Error(`Unexpected worker batch message: ${type}`);
+        activeJob.error(error);
+        failOutput(error);
+        break;
+      }
+    }
+  });
+  const abortJob = () => job.abort(getAbortReason(options.signal));
+  (_a = options.signal) == null ? void 0 : _a.addEventListener("abort", abortJob, { once: true });
+  if ((_b = options.signal) == null ? void 0 : _b.aborted) {
+    abortJob();
+  }
+  void job.result.catch(failOutput);
+  try {
+    const { signal: _signal, ...workerOptions } = options;
+    if (job.isRunning) {
+      job.postMessage("process-in-batches", {
+        options: getTransferListForWriter(workerOptions),
+        context: getTransferListForWriter(jobContext)
+      });
+    }
+    try {
+      for await (const outputBatch of outputBatches) {
+        yield outputBatch;
+        if (job.isRunning) {
+          job.postMessage("output-ack", {});
+        }
+      }
+    } catch (error) {
+      if (error === batchJobFailed) {
+        await job.result;
+      }
+      throw error;
+    }
+    await job.result;
+  } finally {
+    (_c = options.signal) == null ? void 0 : _c.removeEventListener("abort", abortJob);
+    if (job.isRunning) {
+      job.abort(createAbortError2("Worker batch iterator was closed"));
+    }
+    if (!inputFinished) {
+      closeInputIterator(inputIterator);
+    }
+  }
+}
+function throwIfAborted(signal) {
+  if (!(signal == null ? void 0 : signal.aborted)) {
+    return;
+  }
+  throw getAbortReason(signal);
+}
+function getAbortReason(signal) {
+  return (signal == null ? void 0 : signal.reason) ?? createAbortError2("Worker job was aborted");
+}
+function createAbortError2(message) {
+  const error = new Error(message);
+  error.name = "AbortError";
+  return error;
+}
+function getAsyncIterator(input) {
+  if (Symbol.asyncIterator in input) {
+    return input[Symbol.asyncIterator]();
+  }
+  return (async function* iterateSynchronously() {
+    yield* input;
+  })();
+}
+function closeInputIterator(inputIterator) {
+  var _a;
+  try {
+    void Promise.resolve((_a = inputIterator.return) == null ? void 0 : _a.call(inputIterator)).catch(() => void 0);
+  } catch {
+  }
+}
+async function preloadWorker(worker, options = {}, preloadOptions = {}) {
+  var _a;
+  const name = getWorkerName(worker);
+  const workerFarm = WorkerFarm.getWorkerFarm(options);
+  const workerPool = workerFarm.getWorkerPool(getWorkerPoolTarget(worker, options, name));
+  const count = preloadOptions.count ?? options.maxConcurrency ?? ((_a = options.core) == null ? void 0 : _a.maxConcurrency) ?? 1;
+  const preloadJobs = Array.from({ length: count }, async () => {
+    const job = await workerPool.startJob(`${worker.name} preload`, onPreloadMessage);
+    job.postMessage("preload", {});
+    return await job.result;
+  });
+  await Promise.all(preloadJobs);
+}
+function getWorkerPoolTarget(worker, options, name) {
+  if (options.source) {
+    return { name, source: options.source };
+  }
+  const customWorkerUrl = getCustomWorkerURL(worker, options);
+  if (customWorkerUrl) {
+    return { name, url: customWorkerUrl };
+  }
+  if (isBrowser && worker.loadWorker) {
+    return {
+      name,
+      loadWorker: worker.loadWorker,
+      getUrl: () => getWorkerURL(worker, options),
+      urlKey: getDefaultWorkerURL(worker)
+    };
+  }
+  return { name, url: getWorkerURL(worker, options) };
+}
+async function onMessage(context, job, type, payload) {
+  switch (type) {
+    case "done":
+      job.done(payload);
+      break;
+    case "error":
+      job.error(new Error(payload.error));
+      break;
+    case "process":
+      const { id, input, options } = payload;
+      try {
+        if (!context.process) {
+          job.postMessage("error", { id, error: "Worker not set up to process on main thread" });
+          return;
+        }
+        const result = await context.process(input, options, void 0, payload.context || {});
+        job.postMessage("done", { id, result });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "unknown error";
+        job.postMessage("error", { id, error: message });
+      }
+      break;
+    default:
+      console.warn(`process-on-worker: unknown message ${type}`);
+  }
+}
+function onPreloadMessage(job, type, payload) {
+  switch (type) {
+    case "done":
+      job.done(payload);
+      break;
+    case "error":
+      job.error(new Error(payload.error));
+      break;
+    default:
+      console.warn(`process-on-worker: unknown preload message ${type}`);
+  }
+}
+
+// dist/worker-utils/lib/worker-api/create-worker.js
+var requestId = 0;
+var activeInputBatches = null;
+var activeOutputAcknowledgements = null;
+async function createWorker(process2, processInBatches) {
+  if (!await WorkerBody.inWorkerThread()) {
+    return;
+  }
+  const context = {
+    process: processOnMainThread
+  };
+  WorkerBody.onmessage = async (type, payload) => {
+    try {
+      switch (type) {
+        case "preload":
+          WorkerBody.postMessage("done", {});
+          break;
+        case "process":
+          if (!process2) {
+            throw new Error("Worker does not support atomic processing");
+          }
+          const result = await process2(payload.input, payload.options || {}, context, payload.context || {});
+          WorkerBody.postMessage("done", { result });
+          break;
+        case "process-in-batches":
+          if (!processInBatches) {
+            throw new Error("Worker does not support batched processing");
+          }
+          const inputBatches = new AsyncQueue();
+          const outputAcknowledgements = new AsyncQueue();
+          activeInputBatches = inputBatches;
+          activeOutputAcknowledgements = outputAcknowledgements;
+          try {
+            const resultIterator = processInBatches(createDemandDrivenIterator(inputBatches), payload.options || {}, context, payload.context || {});
+            for await (const batch of resultIterator) {
+              await WorkerBody.postMessage("output-batch", { result: batch });
+              await outputAcknowledgements.next();
+            }
+            await WorkerBody.postMessage("done", {});
+          } finally {
+            activeInputBatches = null;
+            activeOutputAcknowledgements = null;
+          }
+          break;
+        case "input-batch":
+          if (!activeInputBatches) {
+            throw new Error("Worker has no active batched processing session");
+          }
+          activeInputBatches.push(payload.input);
+          break;
+        case "input-done":
+          if (!activeInputBatches) {
+            throw new Error("Worker has no active batched processing session");
+          }
+          activeInputBatches.close();
+          break;
+        case "output-ack":
+          if (!activeOutputAcknowledgements) {
+            throw new Error("Worker has no active batched processing session");
+          }
+          activeOutputAcknowledgements.push(void 0);
+          break;
+        default:
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "";
+      WorkerBody.postMessage("error", { error: message });
+    }
+  };
+}
+async function* createDemandDrivenIterator(inputBatches) {
+  while (true) {
+    await WorkerBody.postMessage("input-request", {});
+    const nextBatch = await inputBatches.next();
+    if (nextBatch.done) {
+      return;
+    }
+    yield nextBatch.value;
+  }
+}
+function processOnMainThread(arrayBuffer, options = {}, jobContext = {}) {
+  return new Promise((resolve, reject) => {
+    const id = requestId++;
+    const onMessage2 = (type, payload2) => {
+      if (payload2.id !== id) {
+        return;
+      }
+      switch (type) {
+        case "done":
+          WorkerBody.removeEventListener(onMessage2);
+          resolve(payload2.result);
+          break;
+        case "error":
+          WorkerBody.removeEventListener(onMessage2);
+          reject(payload2.error);
+          break;
+        default:
+      }
+    };
+    WorkerBody.addEventListener(onMessage2);
+    const payload = { id, input: arrayBuffer, options, context: jobContext };
+    WorkerBody.postMessage("process", payload);
+  });
+}
+
+// dist/worker-utils/lib/worker-api/validate-worker-version.js
+function validateWorkerVersion(worker, coreVersion = VERSION) {
+  assert(worker, "no worker provided");
+  const workerVersion = worker.version;
+  if (!coreVersion || !workerVersion) {
+    return false;
+  }
+  return true;
+}
+
+// dist/worker-utils/lib/library-utils/library-utils.js
+var loadLibraryPromises = {};
+function extractLoadLibraryOptions(options = {}) {
+  var _a, _b;
+  const useLocalLibraries = options.useLocalLibraries ?? ((_a = options.core) == null ? void 0 : _a.useLocalLibraries);
+  const CDN = getCDNOption(options.CDN, (_b = options.core) == null ? void 0 : _b.CDN);
+  const modules = options.modules;
+  return {
+    ...useLocalLibraries !== void 0 ? { useLocalLibraries } : {},
+    ...CDN !== void 0 ? { CDN } : {},
+    ...modules !== void 0 ? { modules } : {}
+  };
+}
+function getCDNOption(cdn, coreCDN) {
+  if (typeof cdn === "string" || cdn === null) {
+    return cdn;
+  }
+  if (typeof coreCDN === "string" || coreCDN === null) {
+    return coreCDN;
+  }
+  return void 0;
+}
+async function loadLibrary(libraryUrl, moduleName = null, options = {}, libraryName = null, moduleLibraryName = null) {
+  var _a, _b;
+  let moduleLibraryUrl = libraryUrl;
+  if (moduleName) {
+    const requestedLibraryName = libraryName || libraryUrl;
+    const injectedLibrary = (_a = options.modules) == null ? void 0 : _a[requestedLibraryName];
+    if (injectedLibrary !== void 0 && typeof injectedLibrary !== "string") {
+      return injectedLibrary;
+    }
+    libraryUrl = getLibraryUrl(libraryUrl, moduleName, options, libraryName);
+    const hasLibraryOverride = typeof injectedLibrary === "string";
+    moduleLibraryUrl = moduleLibraryName && (!hasLibraryOverride || typeof ((_b = options.modules) == null ? void 0 : _b[moduleLibraryName]) === "string") ? getLibraryUrl(moduleLibraryName, moduleName, options, moduleLibraryName) : libraryUrl;
+  }
+  const cacheKey = getLibraryCacheKey(libraryUrl, moduleLibraryUrl, isWorker);
+  loadLibraryPromises[cacheKey] = // eslint-disable-next-line @typescript-eslint/no-misused-promises
+  loadLibraryPromises[cacheKey] || loadLibraryFromFile(libraryUrl, moduleLibraryUrl);
+  return await loadLibraryPromises[cacheKey];
+}
+function getLibraryCacheKey(libraryUrl, moduleLibraryUrl, worker) {
+  return worker ? JSON.stringify([libraryUrl, moduleLibraryUrl]) : libraryUrl;
+}
+function getLibraryUrl(library, moduleName, options = {}, libraryName = null) {
+  if (options == null ? void 0 : options.core) {
+    throw new Error("loadLibrary: options.core must be pre-normalized");
+  }
+  libraryName = libraryName || library;
+  const modules = options.modules || {};
+  if (typeof modules[libraryName] === "string") {
+    return modules[libraryName];
+  }
+  if (!options.useLocalLibraries && library.startsWith("http")) {
+    return library;
+  }
+  if (!isBrowser) {
+    return `modules/${moduleName}/dist/libs/${libraryName}`;
+  }
+  if (options.CDN) {
+    if (typeof options.CDN !== "string") {
+      throw new Error("loadLibrary: options.CDN must be a string or null");
+    }
+    assert(options.CDN.startsWith("http"));
+    return `${options.CDN}/${moduleName}@${VERSION}/dist/libs/${libraryName}`;
+  }
+  if (isWorker) {
+    return libraryName.endsWith(".mjs") ? `./libs/${libraryName}` : `../src/libs/${libraryName}`;
+  }
+  return `modules/${moduleName}/src/libs/${libraryName}`;
+}
+async function loadLibraryFromFile(libraryUrl, moduleLibraryUrl) {
+  if (libraryUrl.endsWith("wasm")) {
+    return await loadAsArrayBuffer(libraryUrl);
+  }
+  if (!isBrowser) {
+    const { requireFromFile } = globalThis.loaders || {};
+    try {
+      const result = await (requireFromFile == null ? void 0 : requireFromFile(libraryUrl));
+      if (result || !libraryUrl.includes("/dist/libs/")) {
+        return result;
+      }
+      return await (requireFromFile == null ? void 0 : requireFromFile(libraryUrl.replace("/dist/libs/", "/src/libs/")));
+    } catch (error) {
+      if (libraryUrl.includes("/dist/libs/")) {
+        try {
+          return await (requireFromFile == null ? void 0 : requireFromFile(libraryUrl.replace("/dist/libs/", "/src/libs/")));
+        } catch {
+        }
+      }
+      console.error(error);
+      return null;
+    }
+  }
+  if (isWorker) {
+    return loadLibraryInWorker(libraryUrl, moduleLibraryUrl);
+  }
+  const scriptSource = await loadAsText(libraryUrl);
+  return loadLibraryFromString(scriptSource, libraryUrl);
+}
+async function loadLibraryInWorker(libraryUrl, moduleLibraryUrl = libraryUrl) {
+  try {
+    importScripts();
+  } catch {
+    const moduleUrl = new URL(moduleLibraryUrl, globalThis.location.href).href;
+    const library = await import(
+      /* @vite-ignore */
+      moduleUrl
+    );
+    return library.default ?? library;
+  }
+  return importScripts(libraryUrl);
+}
+function loadLibraryFromString(scriptSource, id) {
+  const script = document.createElement("script");
+  script.id = id;
+  try {
+    script.appendChild(document.createTextNode(scriptSource));
+  } catch (_e) {
+    script.text = scriptSource;
+  }
+  document.body.appendChild(script);
+  return null;
+}
+async function loadAsArrayBuffer(url) {
+  const { readFileAsArrayBuffer } = globalThis.loaders || {};
+  if (isBrowser || !readFileAsArrayBuffer || url.startsWith("http")) {
+    const response = await fetch(url);
+    return await response.arrayBuffer();
+  }
+  try {
+    return await readFileAsArrayBuffer(url);
+  } catch {
+    if (url.includes("/dist/libs/")) {
+      return await readFileAsArrayBuffer(url.replace("/dist/libs/", "/src/libs/"));
+    }
+    throw new Error(`Failed to load ArrayBuffer from ${url}`);
+  }
+}
+async function loadAsText(url) {
+  const { readFileAsText } = globalThis.loaders || {};
+  if (isBrowser || !readFileAsText || url.startsWith("http")) {
+    const response = await fetch(url);
+    return await response.text();
+  }
+  try {
+    return await readFileAsText(url);
+  } catch {
+    if (url.includes("/dist/libs/")) {
+      return await readFileAsText(url.replace("/dist/libs/", "/src/libs/"));
+    }
+    throw new Error(`Failed to load text from ${url}`);
+  }
+}
+
+// dist/worker-utils/lib/process-utils/child-process-proxy.browser.js
+var ChildProcessProxy = class {
+  constructor() {
+    throw new Error("ChildProcessProxy is not available in browser environments");
+  }
+  async start(props) {
+    return await Promise.resolve({});
+  }
+  async stop() {
+    return await Promise.resolve();
+  }
+  async exit() {
+    return await Promise.resolve();
+  }
+};
+
+// dist/worker-utils/index.js
+var NullWorker = {
+  id: "null",
+  name: "null",
+  module: "core",
+  workerFile: "worker-utils/null-worker.js",
+  workerNode: "worker-utils/null-worker-node.js",
+  version: VERSION,
+  options: {
+    null: {}
+  }
+};
+//# sourceMappingURL=index.cjs.map