threadsx 2.0.0

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

@@ -0,0 +1,67 @@
+import { getBundleURL } from "./get-bundle-url.browser";
+export const defaultPoolSize = typeof navigator !== "undefined" && navigator.hardwareConcurrency
+    ? navigator.hardwareConcurrency
+    : 4;
+const isAbsoluteURL = (value) => /^[a-zA-Z][a-zA-Z\d+\-.]*:/.test(value);
+function createSourceBlobURL(code) {
+    const blob = new Blob([code], { type: "application/javascript" });
+    return URL.createObjectURL(blob);
+}
+function selectWorkerImplementation() {
+    if (typeof Worker === "undefined") {
+        // Might happen on Safari, for instance
+        // The idea is to only fail if the constructor is actually used
+        return class NoWebWorker {
+            constructor() {
+                throw 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) {
+            var _a, _b;
+            if (typeof url === "string" && options && options._baseURL) {
+                url = new URL(url, options._baseURL);
+            }
+            else if (typeof url === "string" && !isAbsoluteURL(url) && getBundleURL().match(/^file:\/\//i)) {
+                url = new URL(url, getBundleURL().replace(/\/[^/]+$/, "/"));
+                if ((_a = options === null || options === void 0 ? void 0 : options.CORSWorkaround) !== null && _a !== void 0 ? _a : true) {
+                    url = createSourceBlobURL(`importScripts(${JSON.stringify(url)});`);
+                }
+            }
+            if (typeof url === "string" && isAbsoluteURL(url)) {
+                // Create source code blob loading JS file via `importScripts()`
+                // to circumvent worker CORS restrictions
+                if ((_b = options === null || options === void 0 ? void 0 : options.CORSWorkaround) !== null && _b !== void 0 ? _b : true) {
+                    url = createSourceBlobURL(`importScripts(${JSON.stringify(url)});`);
+                }
+            }
+            super(url, options);
+        }
+    }
+    class BlobWorker extends WebWorker {
+        constructor(blob, options) {
+            const url = window.URL.createObjectURL(blob);
+            super(url, options);
+        }
+        static fromText(source, options) {
+            const blob = new window.Blob([source], { type: "text/javascript" });
+            return new BlobWorker(blob, options);
+        }
+    }
+    return {
+        blob: BlobWorker,
+        default: WebWorker
+    };
+}
+let implementation;
+export function getWorkerImplementation() {
+    if (!implementation) {
+        implementation = selectWorkerImplementation();
+    }
+    return implementation;
+}
+export function isWorkerRuntime() {
+    const isWindowContext = typeof self !== "undefined" && typeof Window !== "undefined" && self instanceof Window;
+    return typeof self !== "undefined" && typeof self.postMessage === "function" && !isWindowContext;
+}

package/dist-esm/master/implementation.js

@@ -0,0 +1,15 @@
+/*
+ * This file is only a stub to make './implementation' resolve to the right module.
+ */
+// We alias `src/master/implementation` to `src/master/implementation.browser` for web
+// browsers already in the package.json, so if get here, it's safe to pass-through the
+// node implementation
+import * as BrowserImplementation from "./implementation.browser";
+import * as NodeImplementation from "./implementation.node";
+const runningInNode = typeof process !== 'undefined' && process.arch !== 'browser' && 'pid' in process;
+const implementation = runningInNode ? NodeImplementation : BrowserImplementation;
+/** Default size of pools. Depending on the platform the value might vary from device to device. */
+export const defaultPoolSize = implementation.defaultPoolSize;
+export const getWorkerImplementation = implementation.getWorkerImplementation;
+/** Returns `true` if this code is currently running in a worker. */
+export const isWorkerRuntime = implementation.isWorkerRuntime;

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

@@ -0,0 +1,155 @@
+/// <reference lib="dom" />
+import getCallsites from "callsites";
+import { cpus } from 'os';
+import * as path from "path";
+import { fileURLToPath } from "url";
+let detectedTsRuntime;
+export const defaultPoolSize = cpus().length;
+/**
+ * Detects an available TypeScript runtime so `.ts`/`.tsx` worker files can be
+ * spawned directly during development. Prefers `tsx`, falls back to `ts-node`.
+ */
+function detectTsRuntime() {
+    if (typeof __non_webpack_require__ === "function") {
+        // Webpack build: => No TS runtime required or possible
+        return null;
+    }
+    if (detectedTsRuntime !== undefined) {
+        return detectedTsRuntime;
+    }
+    detectedTsRuntime = null;
+    for (const candidate of ["tsx", "ts-node"]) {
+        try {
+            eval("require").resolve(candidate);
+            detectedTsRuntime = candidate;
+            break;
+        }
+        catch (error) {
+            if (error && error.code === "MODULE_NOT_FOUND") {
+                continue;
+            }
+            // Re-throw
+            throw error;
+        }
+    }
+    return detectedTsRuntime;
+}
+function createTsRuntimeModule(scriptPath, runtime) {
+    const register = runtime === "tsx"
+        ? `require("tsx/cjs");`
+        : `require("ts-node/register/transpile-only");`;
+    const content = `
+    ${register}
+    require(${JSON.stringify(scriptPath)});
+  `;
+    return content;
+}
+function rebaseScriptPath(scriptPath, ignoreRegex) {
+    const parentCallSite = getCallsites().find((callsite) => {
+        const filename = callsite.getFileName();
+        return Boolean(filename &&
+            !filename.match(ignoreRegex) &&
+            !filename.match(/[/\\]master[/\\]implementation/) &&
+            !filename.match(/^internal\/process/));
+    });
+    const rawCallerPath = parentCallSite ? parentCallSite.getFileName() : null;
+    let callerPath = rawCallerPath ? rawCallerPath : null;
+    if (callerPath && callerPath.startsWith('file:')) {
+        callerPath = fileURLToPath(callerPath);
+    }
+    const rebasedScriptPath = callerPath ? path.join(path.dirname(callerPath), scriptPath) : scriptPath;
+    return rebasedScriptPath;
+}
+function resolveScriptPath(scriptPath, baseURL) {
+    const makeRelative = (filePath) => {
+        // eval() hack is also webpack-related
+        return path.isAbsolute(filePath) ? filePath : path.join(baseURL || eval("__dirname"), filePath);
+    };
+    const workerFilePath = typeof __non_webpack_require__ === "function"
+        ? __non_webpack_require__.resolve(makeRelative(scriptPath))
+        : eval("require").resolve(makeRelative(rebaseScriptPath(scriptPath, /[/\\]worker_threads[/\\]/)));
+    return workerFilePath;
+}
+function initWorkerThreadsWorker() {
+    // Webpack hack
+    const NativeWorker = typeof __non_webpack_require__ === "function"
+        ? __non_webpack_require__("worker_threads").Worker
+        : eval("require")("worker_threads").Worker;
+    let allWorkers = [];
+    class Worker extends NativeWorker {
+        constructor(scriptPath, options) {
+            // Bundlers like webpack 5 pass a `URL` (from `new Worker(new URL(...))`)
+            // pointing at the emitted worker chunk.
+            const normalizedScriptPath = scriptPath instanceof URL ? fileURLToPath(scriptPath) : scriptPath;
+            const resolvedScriptPath = options && options.fromSource
+                ? null
+                : resolveScriptPath(normalizedScriptPath, (options || {})._baseURL);
+            const tsRuntime = resolvedScriptPath && /\.tsx?$/i.test(resolvedScriptPath) ? detectTsRuntime() : null;
+            if (!resolvedScriptPath) {
+                // `options.fromSource` is true
+                const sourceCode = scriptPath;
+                super(sourceCode, Object.assign(Object.assign({}, options), { eval: true }));
+            }
+            else if (tsRuntime) {
+                super(createTsRuntimeModule(resolvedScriptPath, tsRuntime), Object.assign(Object.assign({}, options), { eval: true }));
+            }
+            else if (resolvedScriptPath.match(/\.asar[/\\]/)) {
+                // See <https://github.com/andywer/threads-plugin/issues/17>
+                super(resolvedScriptPath.replace(/\.asar([/\\])/, ".asar.unpacked$1"), options);
+            }
+            else {
+                super(resolvedScriptPath, options);
+            }
+            this.mappedEventListeners = new WeakMap();
+            allWorkers.push(this);
+        }
+        addEventListener(eventName, rawListener) {
+            const listener = (message) => {
+                rawListener({ data: message });
+            };
+            this.mappedEventListeners.set(rawListener, listener);
+            this.on(eventName, listener);
+        }
+        removeEventListener(eventName, rawListener) {
+            const listener = this.mappedEventListeners.get(rawListener) || rawListener;
+            this.off(eventName, listener);
+        }
+    }
+    const terminateWorkersAndMaster = () => {
+        // we should terminate all workers and then gracefully shutdown self process
+        Promise.all(allWorkers.map(worker => worker.terminate())).then(() => process.exit(0), () => process.exit(1));
+        allWorkers = [];
+    };
+    // Take care to not leave orphaned processes behind. See #147.
+    process.on("SIGINT", () => terminateWorkersAndMaster());
+    process.on("SIGTERM", () => terminateWorkersAndMaster());
+    class BlobWorker extends Worker {
+        constructor(blob, options) {
+            super(Buffer.from(blob).toString("utf-8"), Object.assign(Object.assign({}, options), { fromSource: true }));
+        }
+        static fromText(source, options) {
+            return new Worker(source, Object.assign(Object.assign({}, options), { fromSource: true }));
+        }
+    }
+    return {
+        blob: BlobWorker,
+        default: Worker
+    };
+}
+let implementation;
+function selectWorkerImplementation() {
+    return initWorkerThreadsWorker();
+}
+export function getWorkerImplementation() {
+    if (!implementation) {
+        implementation = selectWorkerImplementation();
+    }
+    return implementation;
+}
+export function isWorkerRuntime() {
+    // Webpack hack
+    const isMainThread = typeof __non_webpack_require__ === "function"
+        ? __non_webpack_require__("worker_threads").isMainThread
+        : eval("require")("worker_threads").isMainThread;
+    return !isMainThread;
+}

package/dist-esm/master/index.js

@@ -0,0 +1,9 @@
+import { getWorkerImplementation, isWorkerRuntime } from "./implementation";
+export { Pool } from "./pool";
+export { spawn } from "./spawn";
+export { Thread } from "./thread";
+export { isWorkerRuntime };
+/** Separate class to spawn workers from source code blobs or strings. */
+export const BlobWorker = getWorkerImplementation().blob;
+/** Worker implementation. Either web worker or a node.js Worker class. */
+export const Worker = getWorkerImplementation().default;

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

@@ -0,0 +1,121 @@
+/*
+ * This source file contains the code for proxying calls in the master thread to calls in the workers
+ * by `.postMessage()`-ing.
+ *
+ * Keep in mind that this code can make or break the program's performance! Need to optimize more…
+ */
+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");
+let nextJobUID = 1;
+const dedupe = (array) => Array.from(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;
+function createObservableForJob(worker, jobUID) {
+    return new Observable(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 (typeof event.data.payload !== "undefined") {
+                        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: MasterMessageType.cancel,
+                    uid: jobUID
+                };
+                worker.postMessage(cancelMessage);
+            }
+            worker.removeEventListener("message", messageHandler);
+        };
+    });
+}
+function prepareArguments(rawArgs) {
+    if (rawArgs.length === 0) {
+        // Exit early if possible
+        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)
+    };
+}
+export function createProxyFunction(worker, method) {
+    return ((...rawArgs) => {
+        const uid = nextJobUID++;
+        const { args, transferables } = prepareArguments(rawArgs);
+        const runMessage = {
+            type: MasterMessageType.run,
+            uid,
+            method,
+            args
+        };
+        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(multicast(createObservableForJob(worker, uid)));
+    });
+}
+export function createProxyModule(worker, methodNames) {
+    const proxy = {};
+    for (const methodName of methodNames) {
+        proxy[methodName] = createProxyFunction(worker, methodName);
+    }
+    return proxy;
+}

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

@@ -0,0 +1,12 @@
+/** Pool event type. Specifies the type of each `PoolEvent`. */
+export var PoolEventType;
+(function (PoolEventType) {
+    PoolEventType["initialized"] = "initialized";
+    PoolEventType["taskCanceled"] = "taskCanceled";
+    PoolEventType["taskCompleted"] = "taskCompleted";
+    PoolEventType["taskFailed"] = "taskFailed";
+    PoolEventType["taskQueued"] = "taskQueued";
+    PoolEventType["taskQueueDrained"] = "taskQueueDrained";
+    PoolEventType["taskStart"] = "taskStart";
+    PoolEventType["terminated"] = "terminated";
+})(PoolEventType || (PoolEventType = {}));

package/dist-esm/master/pool.js

@@ -0,0 +1,283 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+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";
+export { PoolEventType, Thread };
+let 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.replace(/\W/g, " ").trim().replace(/\s+/g, "-");
+}
+function spawnWorkers(spawnWorker, count) {
+    return createArray(count).map(() => ({
+        init: spawnWorker(),
+        runningTasks: []
+    }));
+}
+class WorkerPool {
+    constructor(spawnWorker, optionsOrSize) {
+        this.eventSubject = new Subject();
+        this.initErrors = [];
+        this.isClosing = false;
+        this.nextTaskID = 1;
+        this.taskQueue = [];
+        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({
+            type: PoolEventType.initialized,
+            size: this.workers.length
+        }), 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);
+    }
+    runPoolTask(worker, task) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const workerID = this.workers.indexOf(worker) + 1;
+            this.debug(`Running task #${task.id} on worker #${workerID}...`);
+            this.eventSubject.next({
+                type: PoolEventType.taskStart,
+                taskID: task.id,
+                workerID
+            });
+            try {
+                const returnValue = yield task.run(yield worker.init);
+                this.debug(`Task #${task.id} completed successfully`);
+                this.eventSubject.next({
+                    type: PoolEventType.taskCompleted,
+                    returnValue,
+                    taskID: task.id,
+                    workerID
+                });
+            }
+            catch (error) {
+                this.debug(`Task #${task.id} failed`);
+                this.eventSubject.next({
+                    type: PoolEventType.taskFailed,
+                    taskID: task.id,
+                    error: error,
+                    workerID
+                });
+            }
+        });
+    }
+    run(worker, task) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const runPromise = (() => __awaiter(this, void 0, void 0, function* () {
+                const removeTaskFromWorkersRunningTasks = () => {
+                    worker.runningTasks = worker.runningTasks.filter(someRunPromise => someRunPromise !== runPromise);
+                };
+                // Defer task execution by one tick to give handlers time to subscribe
+                yield delay(0);
+                try {
+                    yield 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: PoolEventType.taskQueueDrained });
+            return;
+        }
+        this.run(availableWorker, nextTask);
+    }
+    taskCompletion(taskID) {
+        return new Promise((resolve, reject) => {
+            const eventSubscription = this.events().subscribe(event => {
+                if (event.type === PoolEventType.taskCompleted && event.taskID === taskID) {
+                    eventSubscription.unsubscribe();
+                    resolve(event.returnValue);
+                }
+                else if (event.type === PoolEventType.taskFailed && event.taskID === taskID) {
+                    eventSubscription.unsubscribe();
+                    reject(event.error);
+                }
+                else if (event.type === PoolEventType.terminated) {
+                    eventSubscription.unsubscribe();
+                    reject(Error("Pool has been terminated before task was run."));
+                }
+            });
+        });
+    }
+    settled() {
+        return __awaiter(this, arguments, void 0, function* (allowResolvingImmediately = false) {
+            const getCurrentlyRunningTasks = () => flatMap(this.workers, worker => worker.runningTasks);
+            const taskFailures = [];
+            const failureSubscription = this.eventObservable.subscribe(event => {
+                if (event.type === PoolEventType.taskFailed) {
+                    taskFailures.push(event.error);
+                }
+            });
+            if (this.initErrors.length > 0) {
+                return Promise.reject(this.initErrors[0]);
+            }
+            if (allowResolvingImmediately && this.taskQueue.length === 0) {
+                yield allSettled(getCurrentlyRunningTasks());
+                return taskFailures;
+            }
+            yield new Promise((resolve, reject) => {
+                const subscription = this.eventObservable.subscribe({
+                    next(event) {
+                        if (event.type === PoolEventType.taskQueueDrained) {
+                            subscription.unsubscribe();
+                            resolve(void 0);
+                        }
+                    },
+                    error: reject // make a pool-wide error reject the completed() result promise
+                });
+            });
+            yield allSettled(getCurrentlyRunningTasks());
+            failureSubscription.unsubscribe();
+            return taskFailures;
+        });
+    }
+    completed() {
+        return __awaiter(this, arguments, void 0, function* (allowResolvingImmediately = false) {
+            const settlementPromise = this.settled(allowResolvingImmediately);
+            const earlyExitPromise = new Promise((resolve, reject) => {
+                const subscription = this.eventObservable.subscribe({
+                    next(event) {
+                        if (event.type === PoolEventType.taskQueueDrained) {
+                            subscription.unsubscribe();
+                            resolve(settlementPromise);
+                        }
+                        else if (event.type === PoolEventType.taskFailed) {
+                            subscription.unsubscribe();
+                            reject(event.error);
+                        }
+                    },
+                    error: reject // make a pool-wide error reject the completed() result promise
+                });
+            });
+            const errors = yield Promise.race([
+                settlementPromise,
+                earlyExitPromise
+            ]);
+            if (errors.length > 0) {
+                throw errors[0];
+            }
+        });
+    }
+    events() {
+        return this.eventObservable;
+    }
+    queue(taskFunction) {
+        const { maxQueuedJobs = Infinity } = this.options;
+        if (this.isClosing) {
+            throw 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) => {
+            // Prevent unhandled rejections here as we assume the user will use
+            // `pool.completed()`, `pool.settled()` or `task.catch()` to handle errors
+            this.debug(`Task #${taskID} errored:`, error);
+        });
+        const task = {
+            id: taskID,
+            run: taskFunction,
+            cancel: () => {
+                if (this.taskQueue.indexOf(task) === -1)
+                    return;
+                this.taskQueue = this.taskQueue.filter(someTask => someTask !== task);
+                this.eventSubject.next({
+                    type: PoolEventType.taskCanceled,
+                    taskID: task.id
+                });
+            },
+            then: taskCompletion.then.bind(taskCompletion)
+        };
+        if (this.taskQueue.length >= maxQueuedJobs) {
+            throw Error("Maximum number of pool tasks queued. Refusing to queue another one.\n" +
+                "This 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({
+            type: PoolEventType.taskQueued,
+            taskID: task.id
+        });
+        this.scheduleWork();
+        return task;
+    }
+    terminate(force) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.isClosing = true;
+            if (!force) {
+                yield this.completed(true);
+            }
+            this.eventSubject.next({
+                type: PoolEventType.terminated,
+                remainingQueue: [...this.taskQueue]
+            });
+            this.eventSubject.complete();
+            yield Promise.all(this.workers.map((worker) => __awaiter(this, void 0, void 0, function* () { return Thread.terminate(yield worker.init); })));
+        });
+    }
+}
+WorkerPool.EventType = PoolEventType;
+/**
+ * Thread pool constructor. Creates a new pool and spawns its worker threads.
+ */
+function PoolConstructor(spawnWorker, optionsOrSize) {
+    // The function exists only so we don't need to use `new` to create a pool (we still can, though).
+    // If the Pool is a class or not is an implementation detail that should not concern the user.
+    return new WorkerPool(spawnWorker, optionsOrSize);
+}
+PoolConstructor.EventType = PoolEventType;
+/**
+ * Thread pool constructor. Creates a new pool and spawns its worker threads.
+ */
+export const Pool = PoolConstructor;

package/dist-esm/master/register.js

@@ -0,0 +1,7 @@
+import { Worker as WorkerImplementation } from "./index";
+if (typeof global !== "undefined") {
+    global.Worker = WorkerImplementation;
+}
+else if (typeof window !== "undefined") {
+    window.Worker = WorkerImplementation;
+}