@xylabs/threads/dist/browser/master/index-browser.mjs

Web workers & worker threads as simple as a function call

// src/master/get-bundle-url.browser.ts
var bundleURL;
function getBundleURLCached() {
  if (!bundleURL) {
    bundleURL = getBundleURL();
  }
  return bundleURL;
}
function getBundleURL() {
  try {
    throw new Error("getBundleURL failed");
  } catch (ex) {
    const err = ex;
    const matches = ("" + err.stack).match(/(https?|file|ftp|chrome-extension|moz-extension):\/\/[^\n)]+/g);
    if (matches) {
      return getBaseURL(matches[0]);
    }
  }
  return "/";
}
function getBaseURL(url) {
  return ("" + url).replace(/^((?:https?|file|ftp|chrome-extension|moz-extension):\/\/.+)?\/[^/]+(?:\?.*)?$/, "$1") + "/";
}

// src/master/implementation.browser.ts
var defaultPoolSize = typeof navigator !== "undefined" && navigator.hardwareConcurrency ? navigator.hardwareConcurrency : 4;
var isAbsoluteURL = (value) => /^[A-Za-z][\d+.A-Za-z\-]*:/.test(value);
function createSourceBlobURL(code) {
  const blob = new Blob([code], { type: "application/javascript" });
  return URL.createObjectURL(blob);
}
function selectWorkerImplementation() {
  if (typeof Worker === "undefined") {
    return class NoWebWorker {
      constructor() {
        throw new Error(
          "No web worker implementation available. You might have tried to spawn a worker within a worker in a browser that doesn't support workers in workers."
        );
      }
    };
  }
  class WebWorker extends Worker {
    constructor(url, options) {
      if (typeof url === "string" && options && options._baseURL) {
        url = new URL(url, options._baseURL);
      } else if (typeof url === "string" && !isAbsoluteURL(url) && /^file:\/\//i.test(getBundleURLCached())) {
        url = new URL(url, getBundleURLCached().replace(/\/[^/]+$/, "/"));
        if (options?.CORSWorkaround ?? true) {
          url = createSourceBlobURL(`importScripts(${JSON.stringify(url)});`);
        }
      }
      if (typeof url === "string" && isAbsoluteURL(url) && (options?.CORSWorkaround ?? true)) {
        url = createSourceBlobURL(`importScripts(${JSON.stringify(url)});`);
      }
      super(url, options);
    }
  }
  class BlobWorker2 extends WebWorker {
    constructor(blob, options) {
      const url = globalThis.URL.createObjectURL(blob);
      super(url, options);
    }
    static fromText(source, options) {
      const blob = new globalThis.Blob([source], { type: "text/javascript" });
      return new BlobWorker2(blob, options);
    }
  }
  return {
    blob: BlobWorker2,
    default: WebWorker
  };
}
var implementation;
function getWorkerImplementation() {
  if (!implementation) {
    implementation = selectWorkerImplementation();
  }
  return implementation;
}
function isWorkerRuntime() {
  const isWindowContext = typeof globalThis !== "undefined" && typeof Window !== "undefined" && globalThis instanceof Window;
  return typeof globalThis !== "undefined" && self["postMessage"] && !isWindowContext ? true : false;
}

// src/master/pool-browser.ts
import DebugLogger from "debug";
import {
  multicast,
  Observable,
  Subject
} from "observable-fns";

// src/master/pool-types.ts
var PoolEventType = /* @__PURE__ */ ((PoolEventType2) => {
  PoolEventType2["initialized"] = "initialized";
  PoolEventType2["taskCanceled"] = "taskCanceled";
  PoolEventType2["taskCompleted"] = "taskCompleted";
  PoolEventType2["taskFailed"] = "taskFailed";
  PoolEventType2["taskQueued"] = "taskQueued";
  PoolEventType2["taskQueueDrained"] = "taskQueueDrained";
  PoolEventType2["taskStart"] = "taskStart";
  PoolEventType2["terminated"] = "terminated";
  return PoolEventType2;
})(PoolEventType || {});

// src/symbols.ts
var $errors = /* @__PURE__ */ Symbol("thread.errors");
var $events = /* @__PURE__ */ Symbol("thread.events");
var $terminate = /* @__PURE__ */ Symbol("thread.terminate");
var $transferable = /* @__PURE__ */ Symbol("thread.transferable");
var $worker = /* @__PURE__ */ Symbol("thread.worker");

// src/master/thread.ts
function fail(message) {
  throw new Error(message);
}
var Thread = {
  /** Return an observable that can be used to subscribe to all errors happening in the thread. */
  errors(thread) {
    return thread[$errors] || fail("Error observable not found. Make sure to pass a thread instance as returned by the spawn() promise.");
  },
  /** Return an observable that can be used to subscribe to internal events happening in the thread. Useful for debugging. */
  events(thread) {
    return thread[$events] || fail("Events observable not found. Make sure to pass a thread instance as returned by the spawn() promise.");
  },
  /** Terminate a thread. Remember to terminate every thread when you are done using it. */
  terminate(thread) {
    return thread[$terminate]();
  }
};

// src/master/pool-browser.ts
var nextPoolID = 1;
function createArray(size) {
  const array = [];
  for (let index = 0; index < size; index++) {
    array.push(index);
  }
  return array;
}
function delay(ms) {
  return new Promise((resolve) => setTimeout(resolve, ms));
}
function flatMap(array, mapper) {
  return array.reduce((flattened, element) => [...flattened, ...mapper(element)], []);
}
function slugify(text) {
  return text.replaceAll(/\W/g, " ").trim().replaceAll(/\s+/g, "-");
}
function spawnWorkers(spawnWorker, count) {
  return createArray(count).map(
    () => ({
      init: spawnWorker(),
      runningTasks: []
    })
  );
}
var WorkerPool = class {
  static EventType = PoolEventType;
  debug;
  eventObservable;
  options;
  workers;
  eventSubject = new Subject();
  initErrors = [];
  isClosing = false;
  nextTaskID = 1;
  taskQueue = [];
  constructor(spawnWorker, optionsOrSize) {
    const options = typeof optionsOrSize === "number" ? { size: optionsOrSize } : optionsOrSize || {};
    const { size = defaultPoolSize } = options;
    this.debug = DebugLogger(`threads:pool:${slugify(options.name || String(nextPoolID++))}`);
    this.options = options;
    this.workers = spawnWorkers(spawnWorker, size);
    this.eventObservable = multicast(Observable.from(this.eventSubject));
    Promise.all(this.workers.map((worker) => worker.init)).then(
      () => this.eventSubject.next({
        size: this.workers.length,
        type: "initialized" /* initialized */
      }),
      (error) => {
        this.debug("Error while initializing pool worker:", error);
        this.eventSubject.error(error);
        this.initErrors.push(error);
      }
    );
  }
  findIdlingWorker() {
    const { concurrency = 1 } = this.options;
    return this.workers.find((worker) => worker.runningTasks.length < concurrency);
  }
  async runPoolTask(worker, task) {
    const workerID = this.workers.indexOf(worker) + 1;
    this.debug(`Running task #${task.id} on worker #${workerID}...`);
    this.eventSubject.next({
      taskID: task.id,
      type: "taskStart" /* taskStart */,
      workerID
    });
    try {
      const returnValue = await task.run(await worker.init);
      this.debug(`Task #${task.id} completed successfully`);
      this.eventSubject.next({
        returnValue,
        taskID: task.id,
        type: "taskCompleted" /* taskCompleted */,
        workerID
      });
    } catch (ex) {
      const error = ex;
      this.debug(`Task #${task.id} failed`);
      this.eventSubject.next({
        error,
        taskID: task.id,
        type: "taskFailed" /* taskFailed */,
        workerID
      });
    }
  }
  run(worker, task) {
    const runPromise = (async () => {
      const removeTaskFromWorkersRunningTasks = () => {
        worker.runningTasks = worker.runningTasks.filter((someRunPromise) => someRunPromise !== runPromise);
      };
      await delay(0);
      try {
        await this.runPoolTask(worker, task);
      } finally {
        removeTaskFromWorkersRunningTasks();
        if (!this.isClosing) {
          this.scheduleWork();
        }
      }
    })();
    worker.runningTasks.push(runPromise);
  }
  scheduleWork() {
    this.debug("Attempt de-queueing a task in order to run it...");
    const availableWorker = this.findIdlingWorker();
    if (!availableWorker) return;
    const nextTask = this.taskQueue.shift();
    if (!nextTask) {
      this.debug("Task queue is empty");
      this.eventSubject.next({ type: "taskQueueDrained" /* taskQueueDrained */ });
      return;
    }
    this.run(availableWorker, nextTask);
  }
  taskCompletion(taskID) {
    return new Promise((resolve, reject) => {
      const eventSubscription = this.events().subscribe((event) => {
        if (event.type === "taskCompleted" /* taskCompleted */ && event.taskID === taskID) {
          eventSubscription.unsubscribe();
          resolve(event.returnValue);
        } else if (event.type === "taskFailed" /* taskFailed */ && event.taskID === taskID) {
          eventSubscription.unsubscribe();
          reject(event.error);
        } else if (event.type === "terminated" /* terminated */) {
          eventSubscription.unsubscribe();
          reject(new Error("Pool has been terminated before task was run."));
        }
      });
    });
  }
  async settled(allowResolvingImmediately = false) {
    const getCurrentlyRunningTasks = () => flatMap(this.workers, (worker) => worker.runningTasks);
    const taskFailures = [];
    const failureSubscription = this.eventObservable.subscribe((event) => {
      if (event.type === "taskFailed" /* taskFailed */) {
        taskFailures.push(event.error);
      }
    });
    if (this.initErrors.length > 0) {
      throw this.initErrors[0];
    }
    if (allowResolvingImmediately && this.taskQueue.length === 0) {
      await Promise.allSettled(getCurrentlyRunningTasks());
      return taskFailures;
    }
    await new Promise((resolve, reject) => {
      const subscription = this.eventObservable.subscribe({
        error: reject,
        next(event) {
          if (event.type === "taskQueueDrained" /* taskQueueDrained */) {
            subscription.unsubscribe();
            resolve(void 0);
          }
        }
        // make a pool-wide error reject the completed() result promise
      });
    });
    await Promise.allSettled(getCurrentlyRunningTasks());
    failureSubscription.unsubscribe();
    return taskFailures;
  }
  async completed(allowResolvingImmediately = false) {
    const settlementPromise = this.settled(allowResolvingImmediately);
    const earlyExitPromise = new Promise((resolve, reject) => {
      const subscription = this.eventObservable.subscribe({
        error: reject,
        next(event) {
          if (event.type === "taskQueueDrained" /* taskQueueDrained */) {
            subscription.unsubscribe();
            resolve(settlementPromise);
          } else if (event.type === "taskFailed" /* taskFailed */) {
            subscription.unsubscribe();
            reject(event.error);
          }
        }
        // make a pool-wide error reject the completed() result promise
      });
    });
    const errors = await Promise.race([settlementPromise, earlyExitPromise]);
    if (errors.length > 0) {
      throw errors[0];
    }
  }
  events() {
    return this.eventObservable;
  }
  queue(taskFunction) {
    const { maxQueuedJobs = Number.POSITIVE_INFINITY } = this.options;
    if (this.isClosing) {
      throw new Error("Cannot schedule pool tasks after terminate() has been called.");
    }
    if (this.initErrors.length > 0) {
      throw this.initErrors[0];
    }
    const taskID = this.nextTaskID++;
    const taskCompletion = this.taskCompletion(taskID);
    taskCompletion.catch((error) => {
      this.debug(`Task #${taskID} errored:`, error);
    });
    const task = {
      cancel: () => {
        if (!this.taskQueue.includes(task)) return;
        this.taskQueue = this.taskQueue.filter((someTask) => someTask !== task);
        this.eventSubject.next({
          taskID: task.id,
          type: "taskCanceled" /* taskCanceled */
        });
      },
      id: taskID,
      run: taskFunction,
      then: taskCompletion.then.bind(taskCompletion)
    };
    if (this.taskQueue.length >= maxQueuedJobs) {
      throw new Error(
        "Maximum number of pool tasks queued. Refusing to queue another one.\nThis usually happens for one of two reasons: We are either at peak workload right now or some tasks just won't finish, thus blocking the pool."
      );
    }
    this.debug(`Queueing task #${task.id}...`);
    this.taskQueue.push(task);
    this.eventSubject.next({
      taskID: task.id,
      type: "taskQueued" /* taskQueued */
    });
    this.scheduleWork();
    return task;
  }
  async terminate(force) {
    this.isClosing = true;
    if (!force) {
      await this.completed(true);
    }
    this.eventSubject.next({
      remainingQueue: [...this.taskQueue],
      type: "terminated" /* terminated */
    });
    this.eventSubject.complete();
    await Promise.all(this.workers.map(async (worker) => Thread.terminate(await worker.init)));
  }
};
function PoolConstructor(spawnWorker, optionsOrSize) {
  return new WorkerPool(spawnWorker, optionsOrSize);
}
PoolConstructor.EventType = PoolEventType;
var Pool = PoolConstructor;

// src/master/spawn.ts
import DebugLogger3 from "debug";
import { Observable as Observable4 } from "observable-fns";

// src/serializers.ts
var DefaultErrorSerializer = {
  deserialize(message) {
    return Object.assign(new Error(message.message), {
      name: message.name,
      stack: message.stack
    });
  },
  serialize(error) {
    return {
      __error_marker: "$$error",
      message: error.message,
      name: error.name,
      stack: error.stack
    };
  }
};
var isSerializedError = (thing) => thing && typeof thing === "object" && "__error_marker" in thing && thing.__error_marker === "$$error";
var DefaultSerializer = {
  deserialize(message) {
    return isSerializedError(message) ? DefaultErrorSerializer.deserialize(message) : message;
  },
  serialize(input) {
    return input instanceof Error ? DefaultErrorSerializer.serialize(input) : input;
  }
};

// src/common.ts
globalThis.registeredSerializer = globalThis.registeredSerializer ?? DefaultSerializer;
function deserialize(message) {
  return globalThis.registeredSerializer.deserialize(message);
}
function serialize(input) {
  return globalThis.registeredSerializer.serialize(input);
}

// src/promise.ts
var doNothing = () => void 0;
function createPromiseWithResolver() {
  let alreadyResolved = false;
  let resolvedTo;
  let resolver = doNothing;
  const promise = new Promise((resolve) => {
    if (alreadyResolved) {
      resolve(resolvedTo);
    } else {
      resolver = resolve;
    }
  });
  const exposedResolver = (value) => {
    alreadyResolved = true;
    resolvedTo = value;
    resolver(resolvedTo);
  };
  return [promise, exposedResolver];
}

// src/master/invocation-proxy.ts
import DebugLogger2 from "debug";
import { multicast as multicast2, Observable as Observable3 } from "observable-fns";

// src/observable-promise.ts
import { Observable as Observable2 } from "observable-fns";
var doNothing2 = () => {
};
var returnInput = (input) => input;
var runDeferred = (fn) => Promise.resolve().then(fn);
function fail2(error) {
  throw error;
}
function isThenable(thing) {
  return thing && typeof thing.then === "function";
}
var ObservablePromise = class _ObservablePromise extends Observable2 {
  [Symbol.toStringTag] = "[object ObservablePromise]";
  initHasRun = false;
  fulfillmentCallbacks = [];
  rejectionCallbacks = [];
  firstValue;
  firstValueSet = false;
  rejection;
  state = "pending";
  constructor(init) {
    super((originalObserver) => {
      const self2 = this;
      const observer = {
        ...originalObserver,
        complete() {
          originalObserver.complete();
          self2.onCompletion();
        },
        error(error) {
          originalObserver.error(error);
          self2.onError(error);
        },
        next(value) {
          originalObserver.next(value);
          self2.onNext(value);
        }
      };
      try {
        this.initHasRun = true;
        return init(observer);
      } catch (error) {
        observer.error(error);
      }
    });
  }
  onNext(value) {
    if (!this.firstValueSet) {
      this.firstValue = value;
      this.firstValueSet = true;
    }
  }
  onError(error) {
    this.state = "rejected";
    this.rejection = error;
    for (const onRejected of this.rejectionCallbacks) {
      runDeferred(() => onRejected(error));
    }
  }
  onCompletion() {
    this.state = "fulfilled";
    for (const onFulfilled of this.fulfillmentCallbacks) {
      runDeferred(() => onFulfilled(this.firstValue));
    }
  }
  then(onFulfilledRaw, onRejectedRaw) {
    const onFulfilled = onFulfilledRaw || returnInput;
    const onRejected = onRejectedRaw || fail2;
    let onRejectedCalled = false;
    return new Promise((resolve, reject) => {
      const rejectionCallback = (error) => {
        if (onRejectedCalled) return;
        onRejectedCalled = true;
        try {
          resolve(onRejected(error));
        } catch (anotherError) {
          reject(anotherError);
        }
      };
      const fulfillmentCallback = (value) => {
        try {
          resolve(onFulfilled(value));
        } catch (ex) {
          const error = ex;
          rejectionCallback(error);
        }
      };
      if (!this.initHasRun) {
        this.subscribe({ error: rejectionCallback });
      }
      if (this.state === "fulfilled") {
        return resolve(onFulfilled(this.firstValue));
      }
      if (this.state === "rejected") {
        onRejectedCalled = true;
        return resolve(onRejected(this.rejection));
      }
      this.fulfillmentCallbacks.push(fulfillmentCallback);
      this.rejectionCallbacks.push(rejectionCallback);
    });
  }
  catch(onRejected) {
    return this.then(void 0, onRejected);
  }
  finally(onCompleted) {
    const handler = onCompleted || doNothing2;
    return this.then(
      (value) => {
        handler();
        return value;
      },
      () => handler()
    );
  }
  static from(thing) {
    return isThenable(thing) ? new _ObservablePromise((observer) => {
      const onFulfilled = (value) => {
        observer.next(value);
        observer.complete();
      };
      const onRejected = (error) => {
        observer.error(error);
      };
      thing.then(onFulfilled, onRejected);
    }) : super.from(thing);
  }
};

// src/transferable.ts
function isTransferDescriptor(thing) {
  return thing && typeof thing === "object" && thing[$transferable];
}

// src/master/invocation-proxy.ts
var debugMessages = DebugLogger2("threads:master:messages");
var nextJobUID = 1;
var dedupe = (array) => [...new Set(array)];
var isJobErrorMessage = (data) => data && data.type === "error" /* error */;
var isJobResultMessage = (data) => data && data.type === "result" /* result */;
var isJobStartMessage = (data) => data && data.type === "running" /* running */;
function createObservableForJob(worker, jobUID) {
  return new Observable3((observer) => {
    let asyncType;
    const messageHandler = ((event) => {
      debugMessages("Message from worker:", event.data);
      if (!event.data || event.data.uid !== jobUID) return;
      if (isJobStartMessage(event.data)) {
        asyncType = event.data.resultType;
      } else if (isJobResultMessage(event.data)) {
        if (asyncType === "promise") {
          if (event.data.payload !== void 0) {
            observer.next(deserialize(event.data.payload));
          }
          observer.complete();
          worker.removeEventListener("message", messageHandler);
        } else {
          if (event.data.payload) {
            observer.next(deserialize(event.data.payload));
          }
          if (event.data.complete) {
            observer.complete();
            worker.removeEventListener("message", messageHandler);
          }
        }
      } else if (isJobErrorMessage(event.data)) {
        const error = deserialize(event.data.error);
        if (asyncType === "promise" || !asyncType) {
          observer.error(error);
        } else {
          observer.error(error);
        }
        worker.removeEventListener("message", messageHandler);
      }
    });
    worker.addEventListener("message", messageHandler);
    return () => {
      if (asyncType === "observable" || !asyncType) {
        const cancelMessage = {
          type: "cancel" /* cancel */,
          uid: jobUID
        };
        worker.postMessage(cancelMessage);
      }
      worker.removeEventListener("message", messageHandler);
    };
  });
}
function prepareArguments(rawArgs) {
  if (rawArgs.length === 0) {
    return {
      args: [],
      transferables: []
    };
  }
  const args = [];
  const transferables = [];
  for (const arg of rawArgs) {
    if (isTransferDescriptor(arg)) {
      args.push(serialize(arg.send));
      transferables.push(...arg.transferables);
    } else {
      args.push(serialize(arg));
    }
  }
  return {
    args,
    transferables: transferables.length === 0 ? transferables : dedupe(transferables)
  };
}
function createProxyFunction(worker, method) {
  return ((...rawArgs) => {
    const uid = nextJobUID++;
    const { args, transferables } = prepareArguments(rawArgs);
    const runMessage = {
      args,
      method,
      type: "run" /* run */,
      uid
    };
    debugMessages("Sending command to run function to worker:", runMessage);
    try {
      worker.postMessage(runMessage, transferables);
    } catch (error) {
      return ObservablePromise.from(Promise.reject(error));
    }
    return ObservablePromise.from(multicast2(createObservableForJob(worker, uid)));
  });
}
function createProxyModule(worker, methodNames) {
  const proxy = {};
  for (const methodName of methodNames) {
    proxy[methodName] = createProxyFunction(worker, methodName);
  }
  return proxy;
}

// src/master/spawn.ts
var debugMessages2 = DebugLogger3("threads:master:messages");
var debugSpawn = DebugLogger3("threads:master:spawn");
var debugThreadUtils = DebugLogger3("threads:master:thread-utils");
var isInitMessage = (data) => data && data.type === "init";
var isUncaughtErrorMessage = (data) => data && data.type === "uncaughtError";
var initMessageTimeout = typeof process !== "undefined" && process.env !== void 0 && process.env.THREADS_WORKER_INIT_TIMEOUT ? Number.parseInt(process.env.THREADS_WORKER_INIT_TIMEOUT, 10) : 1e4;
async function withTimeout(promise, timeoutInMs, errorMessage) {
  let timeoutHandle;
  const timeout = new Promise((resolve, reject) => {
    timeoutHandle = setTimeout(() => reject(new Error(errorMessage)), timeoutInMs);
  });
  const result = await Promise.race([promise, timeout]);
  clearTimeout(timeoutHandle);
  return result;
}
function receiveInitMessage(worker) {
  return new Promise((resolve, reject) => {
    const messageHandler = ((event) => {
      debugMessages2("Message from worker before finishing initialization:", event.data);
      if (isInitMessage(event.data)) {
        worker.removeEventListener("message", messageHandler);
        resolve(event.data);
      } else if (isUncaughtErrorMessage(event.data)) {
        worker.removeEventListener("message", messageHandler);
        reject(deserialize(event.data.error));
      }
    });
    worker.addEventListener("message", messageHandler);
  });
}
function createEventObservable(worker, workerTermination) {
  return new Observable4((observer) => {
    const messageHandler = ((messageEvent) => {
      const workerEvent = {
        data: messageEvent.data,
        type: "message" /* message */
      };
      observer.next(workerEvent);
    });
    const rejectionHandler = ((errorEvent) => {
      debugThreadUtils("Unhandled promise rejection event in thread:", errorEvent);
      const workerEvent = {
        error: new Error(errorEvent.reason),
        type: "internalError" /* internalError */
      };
      observer.next(workerEvent);
    });
    worker.addEventListener("message", messageHandler);
    worker.addEventListener("unhandledrejection", rejectionHandler);
    workerTermination.then(() => {
      const terminationEvent = { type: "termination" /* termination */ };
      worker.removeEventListener("message", messageHandler);
      worker.removeEventListener("unhandledrejection", rejectionHandler);
      observer.next(terminationEvent);
      observer.complete();
    });
  });
}
function createTerminator(worker) {
  const [termination, resolver] = createPromiseWithResolver();
  const terminate = async () => {
    debugThreadUtils("Terminating worker");
    await worker.terminate();
    resolver();
  };
  return { terminate, termination };
}
function setPrivateThreadProps(raw, worker, workerEvents, terminate) {
  const workerErrors = workerEvents.filter((event) => event.type === "internalError" /* internalError */).map((errorEvent) => errorEvent.error);
  return Object.assign(raw, {
    [$errors]: workerErrors,
    [$events]: workerEvents,
    [$terminate]: terminate,
    [$worker]: worker
  });
}
async function spawn(worker, options) {
  debugSpawn("Initializing new thread");
  const timeout = options && options.timeout ? options.timeout : initMessageTimeout;
  const initMessage = await withTimeout(
    receiveInitMessage(worker),
    timeout,
    `Timeout: Did not receive an init message from worker after ${timeout}ms. Make sure the worker calls expose().`
  );
  const exposed = initMessage.exposed;
  const { termination, terminate } = createTerminator(worker);
  const events = createEventObservable(worker, termination);
  if (exposed.type === "function") {
    const proxy = createProxyFunction(worker);
    return setPrivateThreadProps(proxy, worker, events, terminate);
  } else if (exposed.type === "module") {
    const proxy = createProxyModule(worker, exposed.methods);
    return setPrivateThreadProps(proxy, worker, events, terminate);
  } else {
    const type = exposed.type;
    throw new Error(`Worker init message states unexpected type of expose(): ${type}`);
  }
}

// src/master/index-browser.ts
var BlobWorker = getWorkerImplementation().blob;
var Worker2 = getWorkerImplementation().default;
export {
  BlobWorker,
  Pool,
  Thread,
  Worker2 as Worker,
  isWorkerRuntime,
  spawn
};
//# sourceMappingURL=index-browser.mjs.map