@xylabs/threads 5.0.13 → 5.0.15

package/dist/browser/index-browser.mjs

@@ -1,6 +1,3 @@
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-
 // src/serializers.ts
 function extendSerializer(extend, implementation2) {
   const fallbackDeserializer = extend.deserialize.bind(extend);
@@ -14,7 +11,6 @@ function extendSerializer(extend, implementation2) {
     }
   };
 }
-__name(extendSerializer, "extendSerializer");
 var DefaultErrorSerializer = {
   deserialize(message) {
     return Object.assign(new Error(message.message), {
@@ -31,7 +27,7 @@ var DefaultErrorSerializer = {
     };
   }
 };
-var isSerializedError = /* @__PURE__ */ __name((thing) => thing && typeof thing === "object" && "__error_marker" in thing && thing.__error_marker === "$$error", "isSerializedError");
+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;
@@ -46,15 +42,12 @@ globalThis.registeredSerializer = globalThis.registeredSerializer ?? DefaultSeri
 function registerSerializer(serializer) {
   globalThis.registeredSerializer = extendSerializer(globalThis.registeredSerializer, serializer);
 }
-__name(registerSerializer, "registerSerializer");
 function deserialize(message) {
   return globalThis.registeredSerializer.deserialize(message);
 }
-__name(deserialize, "deserialize");
 function serialize(input) {
   return globalThis.registeredSerializer.serialize(input);
 }
-__name(serialize, "serialize");
 
 // src/master/get-bundle-url.browser.ts
 var bundleURL;
@@ -64,7 +57,6 @@ function getBundleURLCached() {
   }
   return bundleURL;
 }
-__name(getBundleURLCached, "getBundleURLCached");
 function getBundleURL() {
   try {
     throw new Error("getBundleURL failed");
@@ -77,39 +69,28 @@ function getBundleURL() {
   }
   return "/";
 }
-__name(getBundleURL, "getBundleURL");
 function getBaseURL(url) {
   return ("" + url).replace(/^((?:https?|file|ftp|chrome-extension|moz-extension):\/\/.+)?\/[^/]+(?:\?.*)?$/, "$1") + "/";
 }
-__name(getBaseURL, "getBaseURL");
 
 // src/master/implementation.browser.ts
 var defaultPoolSize = typeof navigator !== "undefined" && navigator.hardwareConcurrency ? navigator.hardwareConcurrency : 4;
-var isAbsoluteURL = /* @__PURE__ */ __name((value) => /^[A-Za-z][\d+.A-Za-z\-]*:/.test(value), "isAbsoluteURL");
+var isAbsoluteURL = (value) => /^[A-Za-z][\d+.A-Za-z\-]*:/.test(value);
 function createSourceBlobURL(code) {
-  const blob = new Blob([
-    code
-  ], {
-    type: "application/javascript"
-  });
+  const blob = new Blob([code], { type: "application/javascript" });
   return URL.createObjectURL(blob);
 }
-__name(createSourceBlobURL, "createSourceBlobURL");
 function selectWorkerImplementation() {
   if (typeof Worker === "undefined") {
     return class NoWebWorker {
-      static {
-        __name(this, "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.");
+        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."
+        );
       }
     };
   }
-  let WebWorker = class WebWorker extends Worker {
-    static {
-      __name(this, "WebWorker");
-    }
+  class WebWorker extends Worker {
     constructor(url, options) {
       if (typeof url === "string" && options && options._baseURL) {
         url = new URL(url, options._baseURL);
@@ -124,30 +105,22 @@ function selectWorkerImplementation() {
       }
       super(url, options);
     }
-  };
-  let BlobWorker2 = class BlobWorker3 extends WebWorker {
-    static {
-      __name(this, "BlobWorker");
-    }
+  }
+  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 BlobWorker3(blob, options);
+      const blob = new globalThis.Blob([source], { type: "text/javascript" });
+      return new BlobWorker2(blob, options);
     }
-  };
+  }
   return {
     blob: BlobWorker2,
     default: WebWorker
   };
 }
-__name(selectWorkerImplementation, "selectWorkerImplementation");
 var implementation;
 function getWorkerImplementation() {
   if (!implementation) {
@@ -155,19 +128,21 @@ function getWorkerImplementation() {
   }
   return implementation;
 }
-__name(getWorkerImplementation, "getWorkerImplementation");
 function isWorkerRuntime() {
   const isWindowContext = typeof globalThis !== "undefined" && typeof Window !== "undefined" && globalThis instanceof Window;
   return typeof globalThis !== "undefined" && self["postMessage"] && !isWindowContext ? true : false;
 }
-__name(isWorkerRuntime, "isWorkerRuntime");
 
 // src/master/pool-browser.ts
 import DebugLogger from "debug";
-import { multicast, Observable, Subject } from "observable-fns";
+import {
+  multicast,
+  Observable,
+  Subject
+} from "observable-fns";
 
 // src/master/pool-types.ts
-var PoolEventType = /* @__PURE__ */ function(PoolEventType2) {
+var PoolEventType = /* @__PURE__ */ ((PoolEventType2) => {
   PoolEventType2["initialized"] = "initialized";
   PoolEventType2["taskCanceled"] = "taskCanceled";
   PoolEventType2["taskCompleted"] = "taskCompleted";
@@ -177,7 +152,7 @@ var PoolEventType = /* @__PURE__ */ function(PoolEventType2) {
   PoolEventType2["taskStart"] = "taskStart";
   PoolEventType2["terminated"] = "terminated";
   return PoolEventType2;
-}({});
+})(PoolEventType || {});
 
 // src/symbols.ts
 var $errors = Symbol("thread.errors");
@@ -190,7 +165,6 @@ var $worker = Symbol("thread.worker");
 function fail(message) {
   throw new Error(message);
 }
-__name(fail, "fail");
 var Thread = {
   /** Return an observable that can be used to subscribe to all errors happening in the thread. */
   errors(thread) {
@@ -215,33 +189,24 @@ function createArray(size) {
   }
   return array;
 }
-__name(createArray, "createArray");
 function delay(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
-__name(delay, "delay");
 function flatMap(array, mapper) {
-  return array.reduce((flattened, element) => [
-    ...flattened,
-    ...mapper(element)
-  ], []);
+  return array.reduce((flattened, element) => [...flattened, ...mapper(element)], []);
 }
-__name(flatMap, "flatMap");
 function slugify(text) {
   return text.replaceAll(/\W/g, " ").trim().replaceAll(/\s+/g, "-");
 }
-__name(slugify, "slugify");
 function spawnWorkers(spawnWorker, count) {
-  return createArray(count).map(() => ({
-    init: spawnWorker(),
-    runningTasks: []
-  }));
-}
-__name(spawnWorkers, "spawnWorkers");
-var WorkerPool = class WorkerPool2 {
-  static {
-    __name(this, "WorkerPool");
-  }
+  return createArray(count).map(
+    () => ({
+      init: spawnWorker(),
+      runningTasks: []
+    })
+  );
+}
+var WorkerPool = class {
   static EventType = PoolEventType;
   debug;
   eventObservable;
@@ -253,22 +218,23 @@ var WorkerPool = class WorkerPool2 {
   nextTaskID = 1;
   taskQueue = [];
   constructor(spawnWorker, optionsOrSize) {
-    const options = typeof optionsOrSize === "number" ? {
-      size: optionsOrSize
-    } : 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: PoolEventType.initialized
-    }), (error) => {
-      this.debug("Error while initializing pool worker:", error);
-      this.eventSubject.error(error);
-      this.initErrors.push(error);
-    });
+    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;
@@ -279,7 +245,7 @@ var WorkerPool = class WorkerPool2 {
     this.debug(`Running task #${task.id} on worker #${workerID}...`);
     this.eventSubject.next({
       taskID: task.id,
-      type: PoolEventType.taskStart,
+      type: "taskStart" /* taskStart */,
       workerID
     });
     try {
@@ -288,7 +254,7 @@ var WorkerPool = class WorkerPool2 {
       this.eventSubject.next({
         returnValue,
         taskID: task.id,
-        type: PoolEventType.taskCompleted,
+        type: "taskCompleted" /* taskCompleted */,
         workerID
       });
     } catch (ex) {
@@ -297,16 +263,16 @@ var WorkerPool = class WorkerPool2 {
       this.eventSubject.next({
         error,
         taskID: task.id,
-        type: PoolEventType.taskFailed,
+        type: "taskFailed" /* taskFailed */,
         workerID
       });
     }
   }
   run(worker, task) {
     const runPromise = (async () => {
-      const removeTaskFromWorkersRunningTasks = /* @__PURE__ */ __name(() => {
+      const removeTaskFromWorkersRunningTasks = () => {
         worker.runningTasks = worker.runningTasks.filter((someRunPromise) => someRunPromise !== runPromise);
-      }, "removeTaskFromWorkersRunningTasks");
+      };
       await delay(0);
       try {
         await this.runPoolTask(worker, task);
@@ -326,9 +292,7 @@ var WorkerPool = class WorkerPool2 {
     const nextTask = this.taskQueue.shift();
     if (!nextTask) {
       this.debug("Task queue is empty");
-      this.eventSubject.next({
-        type: PoolEventType.taskQueueDrained
-      });
+      this.eventSubject.next({ type: "taskQueueDrained" /* taskQueueDrained */ });
       return;
     }
     this.run(availableWorker, nextTask);
@@ -336,13 +300,13 @@ var WorkerPool = class WorkerPool2 {
   taskCompletion(taskID) {
     return new Promise((resolve, reject) => {
       const eventSubscription = this.events().subscribe((event) => {
-        if (event.type === PoolEventType.taskCompleted && event.taskID === taskID) {
+        if (event.type === "taskCompleted" /* taskCompleted */ && event.taskID === taskID) {
           eventSubscription.unsubscribe();
           resolve(event.returnValue);
-        } else if (event.type === PoolEventType.taskFailed && event.taskID === taskID) {
+        } else if (event.type === "taskFailed" /* taskFailed */ && event.taskID === taskID) {
           eventSubscription.unsubscribe();
           reject(event.error);
-        } else if (event.type === PoolEventType.terminated) {
+        } else if (event.type === "terminated" /* terminated */) {
           eventSubscription.unsubscribe();
           reject(new Error("Pool has been terminated before task was run."));
         }
@@ -350,10 +314,10 @@ var WorkerPool = class WorkerPool2 {
     });
   }
   async settled(allowResolvingImmediately = false) {
-    const getCurrentlyRunningTasks = /* @__PURE__ */ __name(() => flatMap(this.workers, (worker) => worker.runningTasks), "getCurrentlyRunningTasks");
+    const getCurrentlyRunningTasks = () => flatMap(this.workers, (worker) => worker.runningTasks);
     const taskFailures = [];
     const failureSubscription = this.eventObservable.subscribe((event) => {
-      if (event.type === PoolEventType.taskFailed) {
+      if (event.type === "taskFailed" /* taskFailed */) {
         taskFailures.push(event.error);
       }
     });
@@ -368,11 +332,12 @@ var WorkerPool = class WorkerPool2 {
       const subscription = this.eventObservable.subscribe({
         error: reject,
         next(event) {
-          if (event.type === PoolEventType.taskQueueDrained) {
+          if (event.type === "taskQueueDrained" /* taskQueueDrained */) {
             subscription.unsubscribe();
             resolve(void 0);
           }
         }
+        // make a pool-wide error reject the completed() result promise
       });
     });
     await Promise.allSettled(getCurrentlyRunningTasks());
@@ -385,20 +350,18 @@ var WorkerPool = class WorkerPool2 {
       const subscription = this.eventObservable.subscribe({
         error: reject,
         next(event) {
-          if (event.type === PoolEventType.taskQueueDrained) {
+          if (event.type === "taskQueueDrained" /* taskQueueDrained */) {
             subscription.unsubscribe();
             resolve(settlementPromise);
-          } else if (event.type === PoolEventType.taskFailed) {
+          } 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
-    ]);
+    const errors = await Promise.race([settlementPromise, earlyExitPromise]);
     if (errors.length > 0) {
       throw errors[0];
     }
@@ -420,26 +383,28 @@ var WorkerPool = class WorkerPool2 {
       this.debug(`Task #${taskID} errored:`, error);
     });
     const task = {
-      cancel: /* @__PURE__ */ __name(() => {
+      cancel: () => {
         if (!this.taskQueue.includes(task)) return;
         this.taskQueue = this.taskQueue.filter((someTask) => someTask !== task);
         this.eventSubject.next({
           taskID: task.id,
-          type: PoolEventType.taskCanceled
+          type: "taskCanceled" /* taskCanceled */
         });
-      }, "cancel"),
+      },
       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.");
+      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: PoolEventType.taskQueued
+      type: "taskQueued" /* taskQueued */
     });
     this.scheduleWork();
     return task;
@@ -450,10 +415,8 @@ var WorkerPool = class WorkerPool2 {
       await this.completed(true);
     }
     this.eventSubject.next({
-      remainingQueue: [
-        ...this.taskQueue
-      ],
-      type: PoolEventType.terminated
+      remainingQueue: [...this.taskQueue],
+      type: "terminated" /* terminated */
     });
     this.eventSubject.complete();
     await Promise.all(this.workers.map(async (worker) => Thread.terminate(await worker.init)));
@@ -462,7 +425,6 @@ var WorkerPool = class WorkerPool2 {
 function PoolConstructor(spawnWorker, optionsOrSize) {
   return new WorkerPool(spawnWorker, optionsOrSize);
 }
-__name(PoolConstructor, "PoolConstructor");
 PoolConstructor.EventType = PoolEventType;
 var Pool = PoolConstructor;
 
@@ -471,7 +433,7 @@ import DebugLogger3 from "debug";
 import { Observable as Observable4 } from "observable-fns";
 
 // src/promise.ts
-var doNothing = /* @__PURE__ */ __name(() => void 0, "doNothing");
+var doNothing = () => void 0;
 function createPromiseWithResolver() {
   let alreadyResolved = false;
   let resolvedTo;
@@ -483,25 +445,13 @@ function createPromiseWithResolver() {
       resolver = resolve;
     }
   });
-  const exposedResolver = /* @__PURE__ */ __name((value) => {
+  const exposedResolver = (value) => {
     alreadyResolved = true;
     resolvedTo = value;
     resolver(resolvedTo);
-  }, "exposedResolver");
-  return [
-    promise,
-    exposedResolver
-  ];
+  };
+  return [promise, exposedResolver];
 }
-__name(createPromiseWithResolver, "createPromiseWithResolver");
-
-// src/types/master.ts
-var WorkerEventType = /* @__PURE__ */ function(WorkerEventType2) {
-  WorkerEventType2["internalError"] = "internalError";
-  WorkerEventType2["message"] = "message";
-  WorkerEventType2["termination"] = "termination";
-  return WorkerEventType2;
-}({});
 
 // src/master/invocation-proxy.ts
 import DebugLogger2 from "debug";
@@ -509,22 +459,17 @@ import { multicast as multicast2, Observable as Observable3 } from "observable-f
 
 // src/observable-promise.ts
 import { Observable as Observable2 } from "observable-fns";
-var doNothing2 = /* @__PURE__ */ __name(() => {
-}, "doNothing");
-var returnInput = /* @__PURE__ */ __name((input) => input, "returnInput");
-var runDeferred = /* @__PURE__ */ __name((fn) => Promise.resolve().then(fn), "runDeferred");
+var doNothing2 = () => {
+};
+var returnInput = (input) => input;
+var runDeferred = (fn) => Promise.resolve().then(fn);
 function fail2(error) {
   throw error;
 }
-__name(fail2, "fail");
 function isThenable(thing) {
   return thing && typeof thing.then === "function";
 }
-__name(isThenable, "isThenable");
 var ObservablePromise = class _ObservablePromise extends Observable2 {
-  static {
-    __name(this, "ObservablePromise");
-  }
   [Symbol.toStringTag] = "[object ObservablePromise]";
   initHasRun = false;
   fulfillmentCallbacks = [];
@@ -583,7 +528,7 @@ var ObservablePromise = class _ObservablePromise extends Observable2 {
     const onRejected = onRejectedRaw || fail2;
     let onRejectedCalled = false;
     return new Promise((resolve, reject) => {
-      const rejectionCallback = /* @__PURE__ */ __name((error) => {
+      const rejectionCallback = (error) => {
         if (onRejectedCalled) return;
         onRejectedCalled = true;
         try {
@@ -591,19 +536,17 @@ var ObservablePromise = class _ObservablePromise extends Observable2 {
         } catch (anotherError) {
           reject(anotherError);
         }
-      }, "rejectionCallback");
-      const fulfillmentCallback = /* @__PURE__ */ __name((value) => {
+      };
+      const fulfillmentCallback = (value) => {
         try {
           resolve(onFulfilled(value));
         } catch (ex) {
           const error = ex;
           rejectionCallback(error);
         }
-      }, "fulfillmentCallback");
+      };
       if (!this.initHasRun) {
-        this.subscribe({
-          error: rejectionCallback
-        });
+        this.subscribe({ error: rejectionCallback });
       }
       if (this.state === "fulfilled") {
         return resolve(onFulfilled(this.firstValue));
@@ -621,20 +564,23 @@ var ObservablePromise = class _ObservablePromise extends Observable2 {
   }
   finally(onCompleted) {
     const handler = onCompleted || doNothing2;
-    return this.then((value) => {
-      handler();
-      return value;
-    }, () => handler());
+    return this.then(
+      (value) => {
+        handler();
+        return value;
+      },
+      () => handler()
+    );
   }
   static from(thing) {
     return isThenable(thing) ? new _ObservablePromise((observer) => {
-      const onFulfilled = /* @__PURE__ */ __name((value) => {
+      const onFulfilled = (value) => {
         observer.next(value);
         observer.complete();
-      }, "onFulfilled");
-      const onRejected = /* @__PURE__ */ __name((error) => {
+      };
+      const onRejected = (error) => {
         observer.error(error);
-      }, "onRejected");
+      };
       thing.then(onFulfilled, onRejected);
     }) : super.from(thing);
   }
@@ -645,18 +591,14 @@ function isTransferable(thing) {
   if (!thing || typeof thing !== "object") return false;
   return true;
 }
-__name(isTransferable, "isTransferable");
 function isTransferDescriptor(thing) {
   return thing && typeof thing === "object" && thing[$transferable];
 }
-__name(isTransferDescriptor, "isTransferDescriptor");
 function Transfer(payload, transferables) {
   console.log("Transfer");
   if (!transferables) {
     if (!isTransferable(payload)) throw new Error("Not transferable");
-    transferables = [
-      payload
-    ];
+    transferables = [payload];
   }
   return {
     [$transferable]: true,
@@ -664,36 +606,18 @@ function Transfer(payload, transferables) {
     transferables
   };
 }
-__name(Transfer, "Transfer");
-
-// src/types/messages.ts
-var MasterMessageType = /* @__PURE__ */ function(MasterMessageType2) {
-  MasterMessageType2["cancel"] = "cancel";
-  MasterMessageType2["run"] = "run";
-  return MasterMessageType2;
-}({});
-var WorkerMessageType = /* @__PURE__ */ function(WorkerMessageType2) {
-  WorkerMessageType2["error"] = "error";
-  WorkerMessageType2["init"] = "init";
-  WorkerMessageType2["result"] = "result";
-  WorkerMessageType2["running"] = "running";
-  WorkerMessageType2["uncaughtError"] = "uncaughtError";
-  return WorkerMessageType2;
-}({});
 
 // src/master/invocation-proxy.ts
 var debugMessages = DebugLogger2("threads:master:messages");
 var nextJobUID = 1;
-var dedupe = /* @__PURE__ */ __name((array) => [
-  ...new Set(array)
-], "dedupe");
-var isJobErrorMessage = /* @__PURE__ */ __name((data) => data && data.type === WorkerMessageType.error, "isJobErrorMessage");
-var isJobResultMessage = /* @__PURE__ */ __name((data) => data && data.type === WorkerMessageType.result, "isJobResultMessage");
-var isJobStartMessage = /* @__PURE__ */ __name((data) => data && data.type === WorkerMessageType.running, "isJobStartMessage");
+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 = /* @__PURE__ */ __name((event) => {
+    const messageHandler = (event) => {
       debugMessages("Message from worker:", event.data);
       if (!event.data || event.data.uid !== jobUID) return;
       if (isJobStartMessage(event.data)) {
@@ -723,12 +647,12 @@ function createObservableForJob(worker, jobUID) {
         }
         worker.removeEventListener("message", messageHandler);
       }
-    }, "messageHandler");
+    };
     worker.addEventListener("message", messageHandler);
     return () => {
       if (asyncType === "observable" || !asyncType) {
         const cancelMessage = {
-          type: MasterMessageType.cancel,
+          type: "cancel" /* cancel */,
           uid: jobUID
         };
         worker.postMessage(cancelMessage);
@@ -737,7 +661,6 @@ function createObservableForJob(worker, jobUID) {
     };
   });
 }
-__name(createObservableForJob, "createObservableForJob");
 function prepareArguments(rawArgs) {
   if (rawArgs.length === 0) {
     return {
@@ -760,7 +683,6 @@ function prepareArguments(rawArgs) {
     transferables: transferables.length === 0 ? transferables : dedupe(transferables)
   };
 }
-__name(prepareArguments, "prepareArguments");
 function createProxyFunction(worker, method) {
   return (...rawArgs) => {
     const uid = nextJobUID++;
@@ -768,7 +690,7 @@ function createProxyFunction(worker, method) {
     const runMessage = {
       args,
       method,
-      type: MasterMessageType.run,
+      type: "run" /* run */,
       uid
     };
     debugMessages("Sending command to run function to worker:", runMessage);
@@ -780,7 +702,6 @@ function createProxyFunction(worker, method) {
     return ObservablePromise.from(multicast2(createObservableForJob(worker, uid)));
   };
 }
-__name(createProxyFunction, "createProxyFunction");
 function createProxyModule(worker, methodNames) {
   const proxy = {};
   for (const methodName of methodNames) {
@@ -788,31 +709,26 @@ function createProxyModule(worker, methodNames) {
   }
   return proxy;
 }
-__name(createProxyModule, "createProxyModule");
 
 // 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 = /* @__PURE__ */ __name((data) => data && data.type === "init", "isInitMessage");
-var isUncaughtErrorMessage = /* @__PURE__ */ __name((data) => data && data.type === "uncaughtError", "isUncaughtErrorMessage");
+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
-  ]);
+  const result = await Promise.race([promise, timeout]);
   clearTimeout(timeoutHandle);
   return result;
 }
-__name(withTimeout, "withTimeout");
 function receiveInitMessage(worker) {
   return new Promise((resolve, reject) => {
-    const messageHandler = /* @__PURE__ */ __name((event) => {
+    const messageHandler = (event) => {
       debugMessages2("Message from worker before finishing initialization:", event.data);
       if (isInitMessage(event.data)) {
         worker.removeEventListener("message", messageHandler);
@@ -821,34 +737,31 @@ function receiveInitMessage(worker) {
         worker.removeEventListener("message", messageHandler);
         reject(deserialize(event.data.error));
       }
-    }, "messageHandler");
+    };
     worker.addEventListener("message", messageHandler);
   });
 }
-__name(receiveInitMessage, "receiveInitMessage");
 function createEventObservable(worker, workerTermination) {
   return new Observable4((observer) => {
-    const messageHandler = /* @__PURE__ */ __name((messageEvent) => {
+    const messageHandler = (messageEvent) => {
       const workerEvent = {
         data: messageEvent.data,
-        type: WorkerEventType.message
+        type: "message" /* message */
       };
       observer.next(workerEvent);
-    }, "messageHandler");
-    const rejectionHandler = /* @__PURE__ */ __name((errorEvent) => {
+    };
+    const rejectionHandler = (errorEvent) => {
       debugThreadUtils("Unhandled promise rejection event in thread:", errorEvent);
       const workerEvent = {
         error: new Error(errorEvent.reason),
-        type: WorkerEventType.internalError
+        type: "internalError" /* internalError */
       };
       observer.next(workerEvent);
-    }, "rejectionHandler");
+    };
     worker.addEventListener("message", messageHandler);
     worker.addEventListener("unhandledrejection", rejectionHandler);
     workerTermination.then(() => {
-      const terminationEvent = {
-        type: WorkerEventType.termination
-      };
+      const terminationEvent = { type: "termination" /* termination */ };
       worker.removeEventListener("message", messageHandler);
       worker.removeEventListener("unhandledrejection", rejectionHandler);
       observer.next(terminationEvent);
@@ -856,22 +769,17 @@ function createEventObservable(worker, workerTermination) {
     });
   });
 }
-__name(createEventObservable, "createEventObservable");
 function createTerminator(worker) {
   const [termination, resolver] = createPromiseWithResolver();
-  const terminate = /* @__PURE__ */ __name(async () => {
+  const terminate = async () => {
     debugThreadUtils("Terminating worker");
     await worker.terminate();
     resolver();
-  }, "terminate");
-  return {
-    terminate,
-    termination
   };
+  return { terminate, termination };
 }
-__name(createTerminator, "createTerminator");
 function setPrivateThreadProps(raw, worker, workerEvents, terminate) {
-  const workerErrors = workerEvents.filter((event) => event.type === WorkerEventType.internalError).map((errorEvent) => errorEvent.error);
+  const workerErrors = workerEvents.filter((event) => event.type === "internalError" /* internalError */).map((errorEvent) => errorEvent.error);
   return Object.assign(raw, {
     [$errors]: workerErrors,
     [$events]: workerEvents,
@@ -879,11 +787,14 @@ function setPrivateThreadProps(raw, worker, workerEvents, terminate) {
     [$worker]: worker
   });
 }
-__name(setPrivateThreadProps, "setPrivateThreadProps");
 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 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);
@@ -898,7 +809,6 @@ async function spawn(worker, options) {
     throw new Error(`Worker init message states unexpected type of expose(): ${type}`);
   }
 }
-__name(spawn, "spawn");
 
 // src/master/index-browser.ts
 var BlobWorker = getWorkerImplementation().blob;