@xylabs/threads 3.5.4 → 3.5.6

package/dist/esm/common.js

@@ -1,11 +1,16 @@
-import { DefaultSerializer, extendSerializer } from './serializers';
-let registeredSerializer = DefaultSerializer;
-export function registerSerializer(serializer) {
-    registeredSerializer = extendSerializer(registeredSerializer, serializer);
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerSerializer = registerSerializer;
+exports.deserialize = deserialize;
+exports.serialize = serialize;
+const serializers_1 = require("./serializers");
+let registeredSerializer = serializers_1.DefaultSerializer;
+function registerSerializer(serializer) {
+    registeredSerializer = (0, serializers_1.extendSerializer)(registeredSerializer, serializer);
 }
-export function deserialize(message) {
+function deserialize(message) {
     return registeredSerializer.deserialize(message);
 }
-export function serialize(input) {
+function serialize(input) {
     return registeredSerializer.serialize(input);
 }

package/dist/esm/index.js

@@ -1,5 +1,26 @@
-export { registerSerializer } from './common';
-export * from './master/index';
-export { DefaultSerializer } from './serializers';
-export { Transfer } from './transferable';
-export { expose } from './worker/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 });
+exports.expose = exports.Transfer = exports.DefaultSerializer = exports.registerSerializer = void 0;
+var common_1 = require("./common");
+Object.defineProperty(exports, "registerSerializer", { enumerable: true, get: function () { return common_1.registerSerializer; } });
+__exportStar(require("./master/index"), exports);
+var serializers_1 = require("./serializers");
+Object.defineProperty(exports, "DefaultSerializer", { enumerable: true, get: function () { return serializers_1.DefaultSerializer; } });
+var transferable_1 = require("./transferable");
+Object.defineProperty(exports, "Transfer", { enumerable: true, get: function () { return transferable_1.Transfer; } });
+var index_1 = require("./worker/index");
+Object.defineProperty(exports, "expose", { enumerable: true, get: function () { return index_1.expose; } });

package/dist/esm/master/get-bundle-url.browser.js

@@ -1,3 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBaseURL = getBaseURL;
+exports.getBundleURL = getBundleURLCached;
 let bundleURL;
 function getBundleURLCached() {
     if (!bundleURL) {
@@ -20,4 +24,3 @@ function getBundleURL() {
 function getBaseURL(url) {
     return ('' + url).replace(/^((?:https?|file|ftp|chrome-extension|moz-extension):\/\/.+)?\/[^/]+(?:\?.*)?$/, '$1') + '/';
 }
-export { getBaseURL, getBundleURLCached as getBundleURL };

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

@@ -1,5 +1,10 @@
-import { getBundleURL } from './get-bundle-url.browser';
-export const defaultPoolSize = typeof navigator !== 'undefined' && navigator.hardwareConcurrency ? navigator.hardwareConcurrency : 4;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultPoolSize = void 0;
+exports.getWorkerImplementation = getWorkerImplementation;
+exports.isWorkerRuntime = isWorkerRuntime;
+const get_bundle_url_browser_1 = require("./get-bundle-url.browser");
+exports.defaultPoolSize = typeof navigator !== 'undefined' && navigator.hardwareConcurrency ? navigator.hardwareConcurrency : 4;
 const isAbsoluteURL = (value) => /^[A-Za-z][\d+.A-Za-z\-]*:/.test(value);
 function createSourceBlobURL(code) {
     const blob = new Blob([code], { type: 'application/javascript' });
@@ -18,8 +23,8 @@ function selectWorkerImplementation() {
             if (typeof url === 'string' && options && options._baseURL) {
                 url = new URL(url, options._baseURL);
             }
-            else if (typeof url === 'string' && !isAbsoluteURL(url) && /^file:\/\//i.test(getBundleURL())) {
-                url = new URL(url, getBundleURL().replace(/\/[^/]+$/, '/'));
+            else if (typeof url === 'string' && !isAbsoluteURL(url) && /^file:\/\//i.test((0, get_bundle_url_browser_1.getBundleURL)())) {
+                url = new URL(url, (0, get_bundle_url_browser_1.getBundleURL)().replace(/\/[^/]+$/, '/'));
                 if (options?.CORSWorkaround ?? true) {
                     url = createSourceBlobURL(`importScripts(${JSON.stringify(url)});`);
                 }
@@ -48,13 +53,13 @@ function selectWorkerImplementation() {
     };
 }
 let implementation;
-export function getWorkerImplementation() {
+function getWorkerImplementation() {
     if (!implementation) {
         implementation = selectWorkerImplementation();
     }
     return implementation;
 }
-export function isWorkerRuntime() {
+function isWorkerRuntime() {
     const isWindowContext = typeof self !== 'undefined' && typeof Window !== 'undefined' && self instanceof Window;
     return typeof self !== 'undefined' && self['postMessage'] && !isWindowContext ? true : false;
 }

package/dist/esm/master/implementation.js

@@ -1,7 +1,33 @@
-import * as BrowserImplementation from './implementation.browser';
-import * as NodeImplementation from './implementation.node';
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isWorkerRuntime = exports.getWorkerImplementation = exports.defaultPoolSize = void 0;
+const BrowserImplementation = __importStar(require("./implementation.browser"));
+const NodeImplementation = __importStar(require("./implementation.node"));
 const runningInNode = typeof process !== 'undefined' && process.arch !== 'browser' && 'pid' in process;
 const implementation = runningInNode ? NodeImplementation : BrowserImplementation;
-export const defaultPoolSize = implementation.defaultPoolSize;
-export const getWorkerImplementation = implementation.getWorkerImplementation;
-export const isWorkerRuntime = implementation.isWorkerRuntime;
+exports.defaultPoolSize = implementation.defaultPoolSize;
+exports.getWorkerImplementation = implementation.getWorkerImplementation;
+exports.isWorkerRuntime = implementation.isWorkerRuntime;

package/dist/esm/master/implementation.node.js

@@ -1,10 +1,18 @@
-import { EventEmitter } from 'node:events';
-import { cpus } from 'node:os';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-import getCallsites from 'callsites-3-1-0';
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultPoolSize = void 0;
+exports.getWorkerImplementation = getWorkerImplementation;
+exports.isWorkerRuntime = isWorkerRuntime;
+const node_events_1 = require("node:events");
+const node_os_1 = require("node:os");
+const node_path_1 = __importDefault(require("node:path"));
+const node_url_1 = require("node:url");
+const callsites_3_1_0_1 = __importDefault(require("callsites-3-1-0"));
 let tsNodeAvailable;
-export const defaultPoolSize = cpus().length;
+exports.defaultPoolSize = (0, node_os_1.cpus)().length;
 function detectTsNode() {
     if (typeof __non_webpack_require__ === 'function') {
         return false;
@@ -34,21 +42,21 @@ function createTsNodeModule(scriptPath) {
     return content;
 }
 function rebaseScriptPath(scriptPath, ignoreRegex) {
-    const parentCallSite = getCallsites().find((callsite) => {
+    const parentCallSite = (0, callsites_3_1_0_1.default)().find((callsite) => {
         const filename = callsite.getFileName();
         return Boolean(filename && !filename.match(ignoreRegex) && !/[/\\]master[/\\]implementation/.test(filename) && !/^internal\/process/.test(filename));
     });
     const rawCallerPath = parentCallSite ? parentCallSite.getFileName() : null;
     let callerPath = rawCallerPath ? rawCallerPath : null;
     if (callerPath && callerPath.startsWith('file:')) {
-        callerPath = fileURLToPath(callerPath);
+        callerPath = (0, node_url_1.fileURLToPath)(callerPath);
     }
-    const rebasedScriptPath = callerPath ? path.join(path.dirname(callerPath), scriptPath) : scriptPath;
+    const rebasedScriptPath = callerPath ? node_path_1.default.join(node_path_1.default.dirname(callerPath), scriptPath) : scriptPath;
     return rebasedScriptPath;
 }
 function resolveScriptPath(scriptPath, baseURL) {
     const makeRelative = (filePath) => {
-        return path.isAbsolute(filePath) ? filePath : path.join(baseURL || eval('__dirname'), filePath);
+        return node_path_1.default.isAbsolute(filePath) ? filePath : node_path_1.default.join(baseURL || eval('__dirname'), filePath);
     };
     const workerFilePath = typeof __non_webpack_require__ === 'function' ?
         __non_webpack_require__.resolve(makeRelative(scriptPath))
@@ -132,7 +140,7 @@ function initTinyWorker() {
                 super(resolvedScriptPath, [], { esm: true });
             }
             allWorkers.push(this);
-            this.emitter = new EventEmitter();
+            this.emitter = new node_events_1.EventEmitter();
             this.onerror = (error) => this.emitter.emit('error', error);
             this.onmessage = (message) => this.emitter.emit('message', message);
         }
@@ -179,13 +187,13 @@ function selectWorkerImplementation() {
         return initTinyWorker();
     }
 }
-export function getWorkerImplementation() {
+function getWorkerImplementation() {
     if (!implementation) {
         implementation = selectWorkerImplementation();
     }
     return implementation;
 }
-export function isWorkerRuntime() {
+function isWorkerRuntime() {
     if (isTinyWorker) {
         return self !== undefined && self['postMessage'] ? true : false;
     }

package/dist/esm/master/index.js

@@ -1,7 +1,14 @@
-import { getWorkerImplementation } from './implementation';
-export { Pool } from './pool';
-export { spawn } from './spawn';
-export { Thread } from './thread';
-export const BlobWorker = getWorkerImplementation().blob;
-export const Worker = getWorkerImplementation().default;
-export { isWorkerRuntime } from './implementation';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isWorkerRuntime = exports.Worker = exports.BlobWorker = exports.Thread = exports.spawn = exports.Pool = void 0;
+const implementation_1 = require("./implementation");
+var pool_1 = require("./pool");
+Object.defineProperty(exports, "Pool", { enumerable: true, get: function () { return pool_1.Pool; } });
+var spawn_1 = require("./spawn");
+Object.defineProperty(exports, "spawn", { enumerable: true, get: function () { return spawn_1.spawn; } });
+var thread_1 = require("./thread");
+Object.defineProperty(exports, "Thread", { enumerable: true, get: function () { return thread_1.Thread; } });
+exports.BlobWorker = (0, implementation_1.getWorkerImplementation)().blob;
+exports.Worker = (0, implementation_1.getWorkerImplementation)().default;
+var implementation_2 = require("./implementation");
+Object.defineProperty(exports, "isWorkerRuntime", { enumerable: true, get: function () { return implementation_2.isWorkerRuntime; } });

package/dist/esm/master/invocation-proxy.js

@@ -1,17 +1,24 @@
-import DebugLogger from 'debug';
-import { multicast, Observable } from 'observable-fns';
-import { deserialize, serialize } from '../common';
-import { ObservablePromise } from '../observable-promise';
-import { isTransferDescriptor } from '../transferable';
-import { MasterMessageType, WorkerMessageType, } from '../types/messages';
-const debugMessages = DebugLogger('threads:master:messages');
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createProxyFunction = createProxyFunction;
+exports.createProxyModule = createProxyModule;
+const debug_1 = __importDefault(require("debug"));
+const observable_fns_1 = require("observable-fns");
+const common_1 = require("../common");
+const observable_promise_1 = require("../observable-promise");
+const transferable_1 = require("../transferable");
+const messages_1 = require("../types/messages");
+const debugMessages = (0, debug_1.default)('threads:master:messages');
 let nextJobUID = 1;
 const dedupe = (array) => [...new Set(array)];
-const isJobErrorMessage = (data) => data && data.type === WorkerMessageType.error;
-const isJobResultMessage = (data) => data && data.type === WorkerMessageType.result;
-const isJobStartMessage = (data) => data && data.type === WorkerMessageType.running;
+const isJobErrorMessage = (data) => data && data.type === messages_1.WorkerMessageType.error;
+const isJobResultMessage = (data) => data && data.type === messages_1.WorkerMessageType.result;
+const isJobStartMessage = (data) => data && data.type === messages_1.WorkerMessageType.running;
 function createObservableForJob(worker, jobUID) {
-    return new Observable((observer) => {
+    return new observable_fns_1.Observable((observer) => {
         let asyncType;
         const messageHandler = ((event) => {
             debugMessages('Message from worker:', event.data);
@@ -23,14 +30,14 @@ function createObservableForJob(worker, jobUID) {
             else if (isJobResultMessage(event.data)) {
                 if (asyncType === 'promise') {
                     if (event.data.payload !== undefined) {
-                        observer.next(deserialize(event.data.payload));
+                        observer.next((0, common_1.deserialize)(event.data.payload));
                     }
                     observer.complete();
                     worker.removeEventListener('message', messageHandler);
                 }
                 else {
                     if (event.data.payload) {
-                        observer.next(deserialize(event.data.payload));
+                        observer.next((0, common_1.deserialize)(event.data.payload));
                     }
                     if (event.data.complete) {
                         observer.complete();
@@ -39,7 +46,7 @@ function createObservableForJob(worker, jobUID) {
                 }
             }
             else if (isJobErrorMessage(event.data)) {
-                const error = deserialize(event.data.error);
+                const error = (0, common_1.deserialize)(event.data.error);
                 if (asyncType === 'promise' || !asyncType) {
                     observer.error(error);
                 }
@@ -53,7 +60,7 @@ function createObservableForJob(worker, jobUID) {
         return () => {
             if (asyncType === 'observable' || !asyncType) {
                 const cancelMessage = {
-                    type: MasterMessageType.cancel,
+                    type: messages_1.MasterMessageType.cancel,
                     uid: jobUID,
                 };
                 worker.postMessage(cancelMessage);
@@ -72,12 +79,12 @@ function prepareArguments(rawArgs) {
     const args = [];
     const transferables = [];
     for (const arg of rawArgs) {
-        if (isTransferDescriptor(arg)) {
-            args.push(serialize(arg.send));
+        if ((0, transferable_1.isTransferDescriptor)(arg)) {
+            args.push((0, common_1.serialize)(arg.send));
             transferables.push(...arg.transferables);
         }
         else {
-            args.push(serialize(arg));
+            args.push((0, common_1.serialize)(arg));
         }
     }
     return {
@@ -85,14 +92,14 @@ function prepareArguments(rawArgs) {
         transferables: transferables.length === 0 ? transferables : dedupe(transferables),
     };
 }
-export function createProxyFunction(worker, method) {
+function createProxyFunction(worker, method) {
     return ((...rawArgs) => {
         const uid = nextJobUID++;
         const { args, transferables } = prepareArguments(rawArgs);
         const runMessage = {
             args,
             method,
-            type: MasterMessageType.run,
+            type: messages_1.MasterMessageType.run,
             uid,
         };
         debugMessages('Sending command to run function to worker:', runMessage);
@@ -100,12 +107,12 @@ export function createProxyFunction(worker, method) {
             worker.postMessage(runMessage, transferables);
         }
         catch (error) {
-            return ObservablePromise.from(Promise.reject(error));
+            return observable_promise_1.ObservablePromise.from(Promise.reject(error));
         }
-        return ObservablePromise.from(multicast(createObservableForJob(worker, uid)));
+        return observable_promise_1.ObservablePromise.from((0, observable_fns_1.multicast)(createObservableForJob(worker, uid)));
     });
 }
-export function createProxyModule(worker, methodNames) {
+function createProxyModule(worker, methodNames) {
     const proxy = {};
     for (const methodName of methodNames) {
         proxy[methodName] = createProxyFunction(worker, methodName);

package/dist/esm/master/pool-types.js

@@ -1,4 +1,7 @@
-export var PoolEventType;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PoolEventType = void 0;
+var PoolEventType;
 (function (PoolEventType) {
     PoolEventType["initialized"] = "initialized";
     PoolEventType["taskCanceled"] = "taskCanceled";
@@ -8,4 +11,4 @@ export var PoolEventType;
     PoolEventType["taskQueueDrained"] = "taskQueueDrained";
     PoolEventType["taskStart"] = "taskStart";
     PoolEventType["terminated"] = "terminated";
-})(PoolEventType || (PoolEventType = {}));
+})(PoolEventType || (exports.PoolEventType = PoolEventType = {}));

package/dist/esm/master/pool.js

@@ -1,9 +1,15 @@
-import DebugLogger from 'debug';
-import { multicast, Observable, Subject } from 'observable-fns';
-import { allSettled } from '../ponyfills';
-import { defaultPoolSize } from './implementation';
-import { PoolEventType } from './pool-types';
-import { Thread } from './thread';
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Thread = exports.PoolEventType = exports.Pool = void 0;
+const debug_1 = __importDefault(require("debug"));
+const observable_fns_1 = require("observable-fns");
+const ponyfills_1 = require("../ponyfills");
+const implementation_1 = require("./implementation");
+const pool_types_1 = require("./pool-types");
+const thread_1 = require("./thread");
 let nextPoolID = 1;
 function createArray(size) {
     const array = [];
@@ -28,26 +34,26 @@ function spawnWorkers(spawnWorker, count) {
     }));
 }
 class WorkerPool {
-    static EventType = PoolEventType;
+    static EventType = pool_types_1.PoolEventType;
     debug;
     eventObservable;
     options;
     workers;
-    eventSubject = new Subject();
+    eventSubject = new observable_fns_1.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++))}`);
+        const { size = implementation_1.defaultPoolSize } = options;
+        this.debug = (0, debug_1.default)(`threads:pool:${slugify(options.name || String(nextPoolID++))}`);
         this.options = options;
         this.workers = spawnWorkers(spawnWorker, size);
-        this.eventObservable = multicast(Observable.from(this.eventSubject));
+        this.eventObservable = (0, observable_fns_1.multicast)(observable_fns_1.Observable.from(this.eventSubject));
         Promise.all(this.workers.map((worker) => worker.init)).then(() => this.eventSubject.next({
             size: this.workers.length,
-            type: PoolEventType.initialized,
+            type: pool_types_1.PoolEventType.initialized,
         }), (error) => {
             this.debug('Error while initializing pool worker:', error);
             this.eventSubject.error(error);
@@ -63,7 +69,7 @@ class WorkerPool {
         this.debug(`Running task #${task.id} on worker #${workerID}...`);
         this.eventSubject.next({
             taskID: task.id,
-            type: PoolEventType.taskStart,
+            type: pool_types_1.PoolEventType.taskStart,
             workerID,
         });
         try {
@@ -72,7 +78,7 @@ class WorkerPool {
             this.eventSubject.next({
                 returnValue,
                 taskID: task.id,
-                type: PoolEventType.taskCompleted,
+                type: pool_types_1.PoolEventType.taskCompleted,
                 workerID,
             });
         }
@@ -81,7 +87,7 @@ class WorkerPool {
             this.eventSubject.next({
                 error,
                 taskID: task.id,
-                type: PoolEventType.taskFailed,
+                type: pool_types_1.PoolEventType.taskFailed,
                 workerID,
             });
         }
@@ -112,7 +118,7 @@ class WorkerPool {
         const nextTask = this.taskQueue.shift();
         if (!nextTask) {
             this.debug('Task queue is empty');
-            this.eventSubject.next({ type: PoolEventType.taskQueueDrained });
+            this.eventSubject.next({ type: pool_types_1.PoolEventType.taskQueueDrained });
             return;
         }
         this.run(availableWorker, nextTask);
@@ -120,15 +126,15 @@ class WorkerPool {
     taskCompletion(taskID) {
         return new Promise((resolve, reject) => {
             const eventSubscription = this.events().subscribe((event) => {
-                if (event.type === PoolEventType.taskCompleted && event.taskID === taskID) {
+                if (event.type === pool_types_1.PoolEventType.taskCompleted && event.taskID === taskID) {
                     eventSubscription.unsubscribe();
                     resolve(event.returnValue);
                 }
-                else if (event.type === PoolEventType.taskFailed && event.taskID === taskID) {
+                else if (event.type === pool_types_1.PoolEventType.taskFailed && event.taskID === taskID) {
                     eventSubscription.unsubscribe();
                     reject(event.error);
                 }
-                else if (event.type === PoolEventType.terminated) {
+                else if (event.type === pool_types_1.PoolEventType.terminated) {
                     eventSubscription.unsubscribe();
                     reject(new Error('Pool has been terminated before task was run.'));
                 }
@@ -139,7 +145,7 @@ class WorkerPool {
         const getCurrentlyRunningTasks = () => flatMap(this.workers, (worker) => worker.runningTasks);
         const taskFailures = [];
         const failureSubscription = this.eventObservable.subscribe((event) => {
-            if (event.type === PoolEventType.taskFailed) {
+            if (event.type === pool_types_1.PoolEventType.taskFailed) {
                 taskFailures.push(event.error);
             }
         });
@@ -147,21 +153,21 @@ class WorkerPool {
             throw this.initErrors[0];
         }
         if (allowResolvingImmediately && this.taskQueue.length === 0) {
-            await allSettled(getCurrentlyRunningTasks());
+            await (0, ponyfills_1.allSettled)(getCurrentlyRunningTasks());
             return taskFailures;
         }
         await new Promise((resolve, reject) => {
             const subscription = this.eventObservable.subscribe({
                 error: reject,
                 next(event) {
-                    if (event.type === PoolEventType.taskQueueDrained) {
+                    if (event.type === pool_types_1.PoolEventType.taskQueueDrained) {
                         subscription.unsubscribe();
                         resolve(void 0);
                     }
                 },
             });
         });
-        await allSettled(getCurrentlyRunningTasks());
+        await (0, ponyfills_1.allSettled)(getCurrentlyRunningTasks());
         failureSubscription.unsubscribe();
         return taskFailures;
     }
@@ -171,11 +177,11 @@ class WorkerPool {
             const subscription = this.eventObservable.subscribe({
                 error: reject,
                 next(event) {
-                    if (event.type === PoolEventType.taskQueueDrained) {
+                    if (event.type === pool_types_1.PoolEventType.taskQueueDrained) {
                         subscription.unsubscribe();
                         resolve(settlementPromise);
                     }
-                    else if (event.type === PoolEventType.taskFailed) {
+                    else if (event.type === pool_types_1.PoolEventType.taskFailed) {
                         subscription.unsubscribe();
                         reject(event.error);
                     }
@@ -210,7 +216,7 @@ class WorkerPool {
                 this.taskQueue = this.taskQueue.filter((someTask) => someTask !== task);
                 this.eventSubject.next({
                     taskID: task.id,
-                    type: PoolEventType.taskCanceled,
+                    type: pool_types_1.PoolEventType.taskCanceled,
                 });
             },
             id: taskID,
@@ -226,7 +232,7 @@ class WorkerPool {
         this.taskQueue.push(task);
         this.eventSubject.next({
             taskID: task.id,
-            type: PoolEventType.taskQueued,
+            type: pool_types_1.PoolEventType.taskQueued,
         });
         this.scheduleWork();
         return task;
@@ -238,17 +244,19 @@ class WorkerPool {
         }
         this.eventSubject.next({
             remainingQueue: [...this.taskQueue],
-            type: PoolEventType.terminated,
+            type: pool_types_1.PoolEventType.terminated,
         });
         this.eventSubject.complete();
-        await Promise.all(this.workers.map(async (worker) => Thread.terminate(await worker.init)));
+        await Promise.all(this.workers.map(async (worker) => thread_1.Thread.terminate(await worker.init)));
     }
 }
 function PoolConstructor(spawnWorker, optionsOrSize) {
     return new WorkerPool(spawnWorker, optionsOrSize);
 }
 ;
-PoolConstructor.EventType = PoolEventType;
-export const Pool = PoolConstructor;
-export { PoolEventType } from './pool-types';
-export { Thread } from './thread';
+PoolConstructor.EventType = pool_types_1.PoolEventType;
+exports.Pool = PoolConstructor;
+var pool_types_2 = require("./pool-types");
+Object.defineProperty(exports, "PoolEventType", { enumerable: true, get: function () { return pool_types_2.PoolEventType; } });
+var thread_2 = require("./thread");
+Object.defineProperty(exports, "Thread", { enumerable: true, get: function () { return thread_2.Thread; } });

package/dist/esm/master/register.js

@@ -1,9 +1,11 @@
-import { Worker as WorkerImplementation } from './index';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = require("./index");
 if (typeof global !== 'undefined') {
     ;
-    global.Worker = WorkerImplementation;
+    global.Worker = index_1.Worker;
 }
 else if (window !== undefined) {
     ;
-    window.Worker = WorkerImplementation;
+    window.Worker = index_1.Worker;
 }