@xylabs/threads 3.5.4 → 3.5.6

package/dist/esm/master/spawn.js

@@ -1,13 +1,19 @@
-import DebugLogger from 'debug';
-import { Observable } from 'observable-fns';
-import { deserialize } from '../common';
-import { createPromiseWithResolver } from '../promise';
-import { $errors, $events, $terminate, $worker } from '../symbols';
-import { WorkerEventType, } from '../types/master';
-import { createProxyFunction, createProxyModule } from './invocation-proxy';
-const debugMessages = DebugLogger('threads:master:messages');
-const debugSpawn = DebugLogger('threads:master:spawn');
-const debugThreadUtils = DebugLogger('threads:master:thread-utils');
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.spawn = spawn;
+const debug_1 = __importDefault(require("debug"));
+const observable_fns_1 = require("observable-fns");
+const common_1 = require("../common");
+const promise_1 = require("../promise");
+const symbols_1 = require("../symbols");
+const master_1 = require("../types/master");
+const invocation_proxy_1 = require("./invocation-proxy");
+const debugMessages = (0, debug_1.default)('threads:master:messages');
+const debugSpawn = (0, debug_1.default)('threads:master:spawn');
+const debugThreadUtils = (0, debug_1.default)('threads:master:thread-utils');
 const isInitMessage = (data) => data && data.type === 'init';
 const isUncaughtErrorMessage = (data) => data && data.type === 'uncaughtError';
 const initMessageTimeout = typeof process !== 'undefined' && process.env !== undefined && process.env.THREADS_WORKER_INIT_TIMEOUT ?
@@ -32,18 +38,18 @@ function receiveInitMessage(worker) {
             }
             else if (isUncaughtErrorMessage(event.data)) {
                 worker.removeEventListener('message', messageHandler);
-                reject(deserialize(event.data.error));
+                reject((0, common_1.deserialize)(event.data.error));
             }
         });
         worker.addEventListener('message', messageHandler);
     });
 }
 function createEventObservable(worker, workerTermination) {
-    return new Observable((observer) => {
+    return new observable_fns_1.Observable((observer) => {
         const messageHandler = ((messageEvent) => {
             const workerEvent = {
                 data: messageEvent.data,
-                type: WorkerEventType.message,
+                type: master_1.WorkerEventType.message,
             };
             observer.next(workerEvent);
         });
@@ -51,7 +57,7 @@ function createEventObservable(worker, workerTermination) {
             debugThreadUtils('Unhandled promise rejection event in thread:', errorEvent);
             const workerEvent = {
                 error: new Error(errorEvent.reason),
-                type: WorkerEventType.internalError,
+                type: master_1.WorkerEventType.internalError,
             };
             observer.next(workerEvent);
         });
@@ -59,7 +65,7 @@ function createEventObservable(worker, workerTermination) {
         worker.addEventListener('unhandledrejection', rejectionHandler);
         workerTermination.then(() => {
             const terminationEvent = {
-                type: WorkerEventType.termination,
+                type: master_1.WorkerEventType.termination,
             };
             worker.removeEventListener('message', messageHandler);
             worker.removeEventListener('unhandledrejection', rejectionHandler);
@@ -69,7 +75,7 @@ function createEventObservable(worker, workerTermination) {
     });
 }
 function createTerminator(worker) {
-    const [termination, resolver] = createPromiseWithResolver();
+    const [termination, resolver] = (0, promise_1.createPromiseWithResolver)();
     const terminate = async () => {
         debugThreadUtils('Terminating worker');
         await worker.terminate();
@@ -79,16 +85,16 @@ function createTerminator(worker) {
 }
 function setPrivateThreadProps(raw, worker, workerEvents, terminate) {
     const workerErrors = workerEvents
-        .filter((event) => event.type === WorkerEventType.internalError)
+        .filter((event) => event.type === master_1.WorkerEventType.internalError)
         .map((errorEvent) => errorEvent.error);
     return Object.assign(raw, {
-        [$errors]: workerErrors,
-        [$events]: workerEvents,
-        [$terminate]: terminate,
-        [$worker]: worker,
+        [symbols_1.$errors]: workerErrors,
+        [symbols_1.$events]: workerEvents,
+        [symbols_1.$terminate]: terminate,
+        [symbols_1.$worker]: worker,
     });
 }
-export async function spawn(worker, options) {
+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().`);
@@ -96,11 +102,11 @@ export async function spawn(worker, options) {
     const { termination, terminate } = createTerminator(worker);
     const events = createEventObservable(worker, termination);
     if (exposed.type === 'function') {
-        const proxy = createProxyFunction(worker);
+        const proxy = (0, invocation_proxy_1.createProxyFunction)(worker);
         return setPrivateThreadProps(proxy, worker, events, terminate);
     }
     else if (exposed.type === 'module') {
-        const proxy = createProxyModule(worker, exposed.methods);
+        const proxy = (0, invocation_proxy_1.createProxyModule)(worker, exposed.methods);
         return setPrivateThreadProps(proxy, worker, events, terminate);
     }
     else {

package/dist/esm/master/thread.js

@@ -1,15 +1,18 @@
-import { $errors, $events, $terminate } from '../symbols';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Thread = void 0;
+const symbols_1 = require("../symbols");
 function fail(message) {
     throw new Error(message);
 }
-export const Thread = {
+exports.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 thread[symbols_1.$errors] || fail('Error observable not found. Make sure to pass a thread instance as returned by the spawn() promise.');
     },
     events(thread) {
-        return thread[$events] || fail('Events observable not found. Make sure to pass a thread instance as returned by the spawn() promise.');
+        return thread[symbols_1.$events] || fail('Events observable not found. Make sure to pass a thread instance as returned by the spawn() promise.');
     },
     terminate(thread) {
-        return thread[$terminate]();
+        return thread[symbols_1.$terminate]();
     },
 };

package/dist/esm/observable-promise.js

@@ -1,4 +1,7 @@
-import { Observable } from 'observable-fns';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObservablePromise = void 0;
+const observable_fns_1 = require("observable-fns");
 const doNothing = () => { };
 const returnInput = (input) => input;
 const runDeferred = (fn) => Promise.resolve().then(fn);
@@ -8,7 +11,7 @@ function fail(error) {
 function isThenable(thing) {
     return thing && typeof thing.then === 'function';
 }
-export class ObservablePromise extends Observable {
+class ObservablePromise extends observable_fns_1.Observable {
     [Symbol.toStringTag] = '[object ObservablePromise]';
     initHasRun = false;
     fulfillmentCallbacks = [];
@@ -126,3 +129,4 @@ export class ObservablePromise extends Observable {
             : super.from(thing);
     }
 }
+exports.ObservablePromise = ObservablePromise;

package/dist/esm/observable.js

@@ -1,6 +1,9 @@
-import { Observable } from 'observable-fns';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Observable = exports.Subject = void 0;
+const observable_fns_1 = require("observable-fns");
 const $observers = Symbol('observers');
-export class Subject extends Observable {
+class Subject extends observable_fns_1.Observable {
     [$observers];
     constructor() {
         super((observer) => {
@@ -25,4 +28,6 @@ export class Subject extends Observable {
             observer.next(value);
     }
 }
-export { Observable } from 'observable-fns';
+exports.Subject = Subject;
+var observable_fns_2 = require("observable-fns");
+Object.defineProperty(exports, "Observable", { enumerable: true, get: function () { return observable_fns_2.Observable; } });

package/dist/esm/ponyfills.js

@@ -1,4 +1,7 @@
-export function allSettled(values) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.allSettled = allSettled;
+function allSettled(values) {
     return Promise.all(values.map((item) => {
         const onFulfill = (value) => {
             return { status: 'fulfilled', value };

package/dist/esm/promise.js

@@ -1,5 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPromiseWithResolver = createPromiseWithResolver;
 const doNothing = () => undefined;
-export function createPromiseWithResolver() {
+function createPromiseWithResolver() {
     let alreadyResolved = false;
     let resolvedTo;
     let resolver = doNothing;

package/dist/esm/serializers.js

@@ -1,4 +1,8 @@
-export function extendSerializer(extend, implementation) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultSerializer = void 0;
+exports.extendSerializer = extendSerializer;
+function extendSerializer(extend, implementation) {
     const fallbackDeserializer = extend.deserialize.bind(extend);
     const fallbackSerializer = extend.serialize.bind(extend);
     return {
@@ -27,7 +31,7 @@ const DefaultErrorSerializer = {
     },
 };
 const isSerializedError = (thing) => thing && typeof thing === 'object' && '__error_marker' in thing && thing.__error_marker === '$$error';
-export const DefaultSerializer = {
+exports.DefaultSerializer = {
     deserialize(message) {
         return isSerializedError(message) ? DefaultErrorSerializer.deserialize(message) : message;
     },

package/dist/esm/symbols.js

@@ -1,5 +1,8 @@
-export const $errors = Symbol('thread.errors');
-export const $events = Symbol('thread.events');
-export const $terminate = Symbol('thread.terminate');
-export const $transferable = Symbol('thread.transferable');
-export const $worker = Symbol('thread.worker');
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.$worker = exports.$transferable = exports.$terminate = exports.$events = exports.$errors = void 0;
+exports.$errors = Symbol('thread.errors');
+exports.$events = Symbol('thread.events');
+exports.$terminate = Symbol('thread.terminate');
+exports.$transferable = Symbol('thread.transferable');
+exports.$worker = Symbol('thread.worker');

package/dist/esm/transferable.js

@@ -1,20 +1,24 @@
-import { $transferable } from './symbols';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isTransferDescriptor = isTransferDescriptor;
+exports.Transfer = Transfer;
+const symbols_1 = require("./symbols");
 function isTransferable(thing) {
     if (!thing || typeof thing !== 'object')
         return false;
     return true;
 }
-export function isTransferDescriptor(thing) {
-    return thing && typeof thing === 'object' && thing[$transferable];
+function isTransferDescriptor(thing) {
+    return thing && typeof thing === 'object' && thing[symbols_1.$transferable];
 }
-export function Transfer(payload, transferables) {
+function Transfer(payload, transferables) {
     if (!transferables) {
         if (!isTransferable(payload))
             throw new Error('Not transferable');
         transferables = [payload];
     }
     return {
-        [$transferable]: true,
+        [symbols_1.$transferable]: true,
         send: payload,
         transferables,
     };

package/dist/esm/types/master.js

@@ -1,7 +1,10 @@
-import { $errors, $events, $terminate, $worker } from '../symbols';
-export var WorkerEventType;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkerEventType = void 0;
+const symbols_1 = require("../symbols");
+var WorkerEventType;
 (function (WorkerEventType) {
     WorkerEventType["internalError"] = "internalError";
     WorkerEventType["message"] = "message";
     WorkerEventType["termination"] = "termination";
-})(WorkerEventType || (WorkerEventType = {}));
+})(WorkerEventType || (exports.WorkerEventType = WorkerEventType = {}));

package/dist/esm/types/messages.js

@@ -1,13 +1,16 @@
-export var MasterMessageType;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkerMessageType = exports.MasterMessageType = void 0;
+var MasterMessageType;
 (function (MasterMessageType) {
     MasterMessageType["cancel"] = "cancel";
     MasterMessageType["run"] = "run";
-})(MasterMessageType || (MasterMessageType = {}));
-export var WorkerMessageType;
+})(MasterMessageType || (exports.MasterMessageType = MasterMessageType = {}));
+var WorkerMessageType;
 (function (WorkerMessageType) {
     WorkerMessageType["error"] = "error";
     WorkerMessageType["init"] = "init";
     WorkerMessageType["result"] = "result";
     WorkerMessageType["running"] = "running";
     WorkerMessageType["uncaughtError"] = "uncaughtError";
-})(WorkerMessageType || (WorkerMessageType = {}));
+})(WorkerMessageType || (exports.WorkerMessageType = WorkerMessageType = {}));

package/dist/esm/types/worker.js

@@ -1 +1,2 @@
-export {};
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/esm/worker/bundle-entry.js

@@ -1,10 +1,26 @@
-import { expose } from './index';
-export * from './index';
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = require("./index");
+__exportStar(require("./index"), exports);
 if (typeof global !== 'undefined') {
     ;
-    global.expose = expose;
+    global.expose = index_1.expose;
 }
 if (typeof self !== 'undefined') {
     ;
-    self.expose = expose;
+    self.expose = index_1.expose;
 }

package/dist/esm/worker/implementation.browser.js

@@ -1,3 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
 const isWorkerRuntime = function isWorkerRuntime() {
     const isWindowContext = self !== undefined && typeof Window !== 'undefined' && self instanceof Window;
     return self !== undefined && self['postMessage'] && !isWindowContext ? true : false;
@@ -15,7 +17,7 @@ const subscribeToMasterMessages = function subscribeToMasterMessages(onMessage)
     self.addEventListener('message', messageHandler);
     return unsubscribe;
 };
-export default {
+exports.default = {
     isWorkerRuntime,
     postMessageToMaster,
     subscribeToMasterMessages,

package/dist/esm/worker/implementation.js

@@ -1,14 +1,19 @@
-import WebWorkerImplementation from './implementation.browser';
-import TinyWorkerImplementation from './implementation.tiny-worker';
-import WorkerThreadsImplementation from './implementation.worker_threads';
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const implementation_browser_1 = __importDefault(require("./implementation.browser"));
+const implementation_tiny_worker_1 = __importDefault(require("./implementation.tiny-worker"));
+const implementation_worker_threads_1 = __importDefault(require("./implementation.worker_threads"));
 const runningInNode = typeof process !== 'undefined' && process.arch !== 'browser' && 'pid' in process;
 function selectNodeImplementation() {
     try {
-        WorkerThreadsImplementation.testImplementation();
-        return WorkerThreadsImplementation;
+        implementation_worker_threads_1.default.testImplementation();
+        return implementation_worker_threads_1.default;
     }
     catch {
-        return TinyWorkerImplementation;
+        return implementation_tiny_worker_1.default;
     }
 }
-export default runningInNode ? selectNodeImplementation() : WebWorkerImplementation;
+exports.default = runningInNode ? selectNodeImplementation() : implementation_browser_1.default;

package/dist/esm/worker/implementation.tiny-worker.js

@@ -1,3 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
 try {
     if (self === undefined) {
         ;
@@ -28,7 +30,7 @@ const subscribeToMasterMessages = function subscribeToMasterMessages(onMessage)
     const unsubscribe = () => messageHandlers.delete(onMessage);
     return unsubscribe;
 };
-export default {
+exports.default = {
     isWorkerRuntime,
     postMessageToMaster,
     subscribeToMasterMessages,

package/dist/esm/worker/implementation.worker_threads.js

@@ -1,4 +1,9 @@
-import WorkerThreads from '../worker_threads';
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const worker_threads_1 = __importDefault(require("../worker_threads"));
 function assertMessagePort(port) {
     if (!port) {
         throw new Error('Invariant violation: MessagePort to parent is not available.');
@@ -6,13 +11,13 @@ function assertMessagePort(port) {
     return port;
 }
 const isWorkerRuntime = function isWorkerRuntime() {
-    return !WorkerThreads().isMainThread;
+    return !(0, worker_threads_1.default)().isMainThread;
 };
 const postMessageToMaster = function postMessageToMaster(data, transferList) {
-    assertMessagePort(WorkerThreads().parentPort).postMessage(data, transferList);
+    assertMessagePort((0, worker_threads_1.default)().parentPort).postMessage(data, transferList);
 };
 const subscribeToMasterMessages = function subscribeToMasterMessages(onMessage) {
-    const parentPort = WorkerThreads().parentPort;
+    const parentPort = (0, worker_threads_1.default)().parentPort;
     if (!parentPort) {
         throw new Error('Invariant violation: MessagePort to parent is not available.');
     }
@@ -26,9 +31,9 @@ const subscribeToMasterMessages = function subscribeToMasterMessages(onMessage)
     return unsubscribe;
 };
 function testImplementation() {
-    WorkerThreads();
+    (0, worker_threads_1.default)();
 }
-export default {
+exports.default = {
     isWorkerRuntime,
     postMessageToMaster,
     subscribeToMasterMessages,

package/dist/esm/worker/index.js

@@ -1,30 +1,39 @@
-import isSomeObservable from 'is-observable-2-1-0';
-import { deserialize, serialize } from '../common';
-import { isTransferDescriptor } from '../transferable';
-import { MasterMessageType, WorkerMessageType, } from '../types/messages';
-import Implementation from './implementation';
-export { registerSerializer } from '../common';
-export { Transfer } from '../transferable';
-export const isWorkerRuntime = Implementation.isWorkerRuntime;
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isWorkerRuntime = exports.Transfer = exports.registerSerializer = void 0;
+exports.expose = expose;
+const is_observable_2_1_0_1 = __importDefault(require("is-observable-2-1-0"));
+const common_1 = require("../common");
+const transferable_1 = require("../transferable");
+const messages_1 = require("../types/messages");
+const implementation_1 = __importDefault(require("./implementation"));
+var common_2 = require("../common");
+Object.defineProperty(exports, "registerSerializer", { enumerable: true, get: function () { return common_2.registerSerializer; } });
+var transferable_2 = require("../transferable");
+Object.defineProperty(exports, "Transfer", { enumerable: true, get: function () { return transferable_2.Transfer; } });
+exports.isWorkerRuntime = implementation_1.default.isWorkerRuntime;
 let exposeCalled = false;
 const activeSubscriptions = new Map();
-const isMasterJobCancelMessage = (thing) => thing && thing.type === MasterMessageType.cancel;
-const isMasterJobRunMessage = (thing) => thing && thing.type === MasterMessageType.run;
-const isObservable = (thing) => isSomeObservable(thing) || isZenObservable(thing);
+const isMasterJobCancelMessage = (thing) => thing && thing.type === messages_1.MasterMessageType.cancel;
+const isMasterJobRunMessage = (thing) => thing && thing.type === messages_1.MasterMessageType.run;
+const isObservable = (thing) => (0, is_observable_2_1_0_1.default)(thing) || isZenObservable(thing);
 function isZenObservable(thing) {
     return thing && typeof thing === 'object' && typeof thing.subscribe === 'function';
 }
 function deconstructTransfer(thing) {
-    return isTransferDescriptor(thing) ? { payload: thing.send, transferables: thing.transferables } : { payload: thing, transferables: undefined };
+    return (0, transferable_1.isTransferDescriptor)(thing) ? { payload: thing.send, transferables: thing.transferables } : { payload: thing, transferables: undefined };
 }
 function postFunctionInitMessage() {
     const initMessage = {
         exposed: {
             type: 'function',
         },
-        type: WorkerMessageType.init,
+        type: messages_1.WorkerMessageType.init,
     };
-    Implementation.postMessageToMaster(initMessage);
+    implementation_1.default.postMessageToMaster(initMessage);
 }
 function postModuleInitMessage(methodNames) {
     const initMessage = {
@@ -32,44 +41,44 @@ function postModuleInitMessage(methodNames) {
             methods: methodNames,
             type: 'module',
         },
-        type: WorkerMessageType.init,
+        type: messages_1.WorkerMessageType.init,
     };
-    Implementation.postMessageToMaster(initMessage);
+    implementation_1.default.postMessageToMaster(initMessage);
 }
 function postJobErrorMessage(uid, rawError) {
     const { payload: error, transferables } = deconstructTransfer(rawError);
     const errorMessage = {
-        error: serialize(error),
-        type: WorkerMessageType.error,
+        error: (0, common_1.serialize)(error),
+        type: messages_1.WorkerMessageType.error,
         uid,
     };
-    Implementation.postMessageToMaster(errorMessage, transferables);
+    implementation_1.default.postMessageToMaster(errorMessage, transferables);
 }
 function postJobResultMessage(uid, completed, resultValue) {
     const { payload, transferables } = deconstructTransfer(resultValue);
     const resultMessage = {
         complete: completed ? true : undefined,
         payload,
-        type: WorkerMessageType.result,
+        type: messages_1.WorkerMessageType.result,
         uid,
     };
-    Implementation.postMessageToMaster(resultMessage, transferables);
+    implementation_1.default.postMessageToMaster(resultMessage, transferables);
 }
 function postJobStartMessage(uid, resultType) {
     const startMessage = {
         resultType,
-        type: WorkerMessageType.running,
+        type: messages_1.WorkerMessageType.running,
         uid,
     };
-    Implementation.postMessageToMaster(startMessage);
+    implementation_1.default.postMessageToMaster(startMessage);
 }
 function postUncaughtErrorMessage(error) {
     try {
         const errorMessage = {
-            error: serialize(error),
-            type: WorkerMessageType.uncaughtError,
+            error: (0, common_1.serialize)(error),
+            type: messages_1.WorkerMessageType.uncaughtError,
         };
-        Implementation.postMessageToMaster(errorMessage);
+        implementation_1.default.postMessageToMaster(errorMessage);
     }
     catch (subError) {
         console.error('Not reporting uncaught error back to master thread as it ' + 'occured while reporting an uncaught error already.' + '\nLatest error:', subError, '\nOriginal error:', error);
@@ -86,8 +95,8 @@ async function runFunction(jobUID, fn, args) {
     const resultType = isObservable(syncResult) ? 'observable' : 'promise';
     postJobStartMessage(jobUID, resultType);
     if (isObservable(syncResult)) {
-        const subscription = syncResult.subscribe((value) => postJobResultMessage(jobUID, false, serialize(value)), (error) => {
-            postJobErrorMessage(jobUID, serialize(error));
+        const subscription = syncResult.subscribe((value) => postJobResultMessage(jobUID, false, (0, common_1.serialize)(value)), (error) => {
+            postJobErrorMessage(jobUID, (0, common_1.serialize)(error));
             activeSubscriptions.delete(jobUID);
         }, () => {
             postJobResultMessage(jobUID, true);
@@ -98,15 +107,15 @@ async function runFunction(jobUID, fn, args) {
     else {
         try {
             const result = await syncResult;
-            postJobResultMessage(jobUID, true, serialize(result));
+            postJobResultMessage(jobUID, true, (0, common_1.serialize)(result));
         }
         catch (error) {
-            postJobErrorMessage(jobUID, serialize(error));
+            postJobErrorMessage(jobUID, (0, common_1.serialize)(error));
         }
     }
 }
-export function expose(exposed) {
-    if (!Implementation.isWorkerRuntime()) {
+function expose(exposed) {
+    if (!implementation_1.default.isWorkerRuntime()) {
         throw new Error('expose() called in the master thread.');
     }
     if (exposeCalled) {
@@ -114,17 +123,17 @@ export function expose(exposed) {
     }
     exposeCalled = true;
     if (typeof exposed === 'function') {
-        Implementation.subscribeToMasterMessages((messageData) => {
+        implementation_1.default.subscribeToMasterMessages((messageData) => {
             if (isMasterJobRunMessage(messageData) && !messageData.method) {
-                runFunction(messageData.uid, exposed, messageData.args.map(deserialize));
+                runFunction(messageData.uid, exposed, messageData.args.map(common_1.deserialize));
             }
         });
         postFunctionInitMessage();
     }
     else if (typeof exposed === 'object' && exposed) {
-        Implementation.subscribeToMasterMessages((messageData) => {
+        implementation_1.default.subscribeToMasterMessages((messageData) => {
             if (isMasterJobRunMessage(messageData) && messageData.method) {
-                runFunction(messageData.uid, exposed[messageData.method], messageData.args.map(deserialize));
+                runFunction(messageData.uid, exposed[messageData.method], messageData.args.map(common_1.deserialize));
             }
         });
         const methodNames = Object.keys(exposed).filter((key) => typeof exposed[key] === 'function');
@@ -133,7 +142,7 @@ export function expose(exposed) {
     else {
         throw new Error(`Invalid argument passed to expose(). Expected a function or an object, got: ${exposed}`);
     }
-    Implementation.subscribeToMasterMessages((messageData) => {
+    implementation_1.default.subscribeToMasterMessages((messageData) => {
         if (isMasterJobCancelMessage(messageData)) {
             const jobUID = messageData.uid;
             const subscription = activeSubscriptions.get(jobUID);
@@ -144,7 +153,7 @@ export function expose(exposed) {
         }
     });
 }
-if (typeof self !== 'undefined' && typeof self.addEventListener === 'function' && Implementation.isWorkerRuntime()) {
+if (typeof self !== 'undefined' && typeof self.addEventListener === 'function' && implementation_1.default.isWorkerRuntime()) {
     self.addEventListener('error', (event) => {
         setTimeout(() => postUncaughtErrorMessage(event.error || event), 250);
     });
@@ -155,7 +164,7 @@ if (typeof self !== 'undefined' && typeof self.addEventListener === 'function' &
         }
     });
 }
-if (typeof process !== 'undefined' && typeof process.on === 'function' && Implementation.isWorkerRuntime()) {
+if (typeof process !== 'undefined' && typeof process.on === 'function' && implementation_1.default.isWorkerRuntime()) {
     process.on('uncaughtException', (error) => {
         setTimeout(() => postUncaughtErrorMessage(error), 250);
     });

package/dist/esm/worker_threads.js

@@ -1,8 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = getImplementation;
 let implementation;
 function selectImplementation() {
     return typeof __non_webpack_require__ === 'function' ? __non_webpack_require__('worker_threads') : eval('require')('worker_threads');
 }
-export default function getImplementation() {
+function getImplementation() {
     if (!implementation) {
         implementation = selectImplementation();
     }