@xylabs/threads 3.0.4

package/dist/worker/implementation.worker_threads.js

@@ -0,0 +1,42 @@
+"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.');
+    }
+    return port;
+}
+const isWorkerRuntime = function isWorkerRuntime() {
+    return !(0, worker_threads_1.default)().isMainThread;
+};
+const postMessageToMaster = function postMessageToMaster(data, transferList) {
+    assertMessagePort((0, worker_threads_1.default)().parentPort).postMessage(data, transferList);
+};
+const subscribeToMasterMessages = function subscribeToMasterMessages(onMessage) {
+    const parentPort = (0, worker_threads_1.default)().parentPort;
+    if (!parentPort) {
+        throw new Error('Invariant violation: MessagePort to parent is not available.');
+    }
+    const messageHandler = (message) => {
+        onMessage(message);
+    };
+    const unsubscribe = () => {
+        assertMessagePort(parentPort).off('message', messageHandler);
+    };
+    assertMessagePort(parentPort).on('message', messageHandler);
+    return unsubscribe;
+};
+function testImplementation() {
+    // Will throw if `worker_threads` are not available
+    (0, worker_threads_1.default)();
+}
+exports.default = {
+    isWorkerRuntime,
+    postMessageToMaster,
+    subscribeToMasterMessages,
+    testImplementation,
+};

package/dist/worker/index.d.ts

@@ -0,0 +1,13 @@
+import { WorkerFunction, WorkerModule } from '../types/worker';
+export { registerSerializer } from '../common';
+export { Transfer } from '../transferable';
+/** Returns `true` if this code is currently running in a worker. */
+export declare const isWorkerRuntime: () => boolean;
+/**
+ * Expose a function or a module (an object whose values are functions)
+ * to the main thread. Must be called exactly once in every worker thread
+ * to signal its API to the main thread.
+ *
+ * @param exposed Function or object whose values are functions
+ */
+export declare function expose(exposed: WorkerFunction | WorkerModule<any>): void;

package/dist/worker/index.js

@@ -0,0 +1,195 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.expose = exports.isWorkerRuntime = exports.Transfer = exports.registerSerializer = void 0;
+/* eslint-disable @typescript-eslint/no-floating-promises */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+const is_observable_1 = __importDefault(require("is-observable"));
+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; } });
+/** Returns `true` if this code is currently running in a worker. */
+exports.isWorkerRuntime = implementation_1.default.isWorkerRuntime;
+let exposeCalled = false;
+const activeSubscriptions = new Map();
+const isMasterJobCancelMessage = (thing) => thing && thing.type === messages_1.MasterMessageType.cancel;
+const isMasterJobRunMessage = (thing) => thing && thing.type === messages_1.MasterMessageType.run;
+/**
+ * There are issues with `is-observable` not recognizing zen-observable's instances.
+ * We are using `observable-fns`, but it's based on zen-observable, too.
+ */
+const isObservable = (thing) => (0, is_observable_1.default)(thing) || isZenObservable(thing);
+function isZenObservable(thing) {
+    return thing && typeof thing === 'object' && typeof thing.subscribe === 'function';
+}
+function deconstructTransfer(thing) {
+    return (0, transferable_1.isTransferDescriptor)(thing) ? { payload: thing.send, transferables: thing.transferables } : { payload: thing, transferables: undefined };
+}
+function postFunctionInitMessage() {
+    const initMessage = {
+        exposed: {
+            type: 'function',
+        },
+        type: messages_1.WorkerMessageType.init,
+    };
+    implementation_1.default.postMessageToMaster(initMessage);
+}
+function postModuleInitMessage(methodNames) {
+    const initMessage = {
+        exposed: {
+            methods: methodNames,
+            type: 'module',
+        },
+        type: messages_1.WorkerMessageType.init,
+    };
+    implementation_1.default.postMessageToMaster(initMessage);
+}
+function postJobErrorMessage(uid, rawError) {
+    const { payload: error, transferables } = deconstructTransfer(rawError);
+    const errorMessage = {
+        error: (0, common_1.serialize)(error),
+        type: messages_1.WorkerMessageType.error,
+        uid,
+    };
+    implementation_1.default.postMessageToMaster(errorMessage, transferables);
+}
+function postJobResultMessage(uid, completed, resultValue) {
+    const { payload, transferables } = deconstructTransfer(resultValue);
+    const resultMessage = {
+        complete: completed ? true : undefined,
+        payload,
+        type: messages_1.WorkerMessageType.result,
+        uid,
+    };
+    implementation_1.default.postMessageToMaster(resultMessage, transferables);
+}
+function postJobStartMessage(uid, resultType) {
+    const startMessage = {
+        resultType,
+        type: messages_1.WorkerMessageType.running,
+        uid,
+    };
+    implementation_1.default.postMessageToMaster(startMessage);
+}
+function postUncaughtErrorMessage(error) {
+    try {
+        const errorMessage = {
+            error: (0, common_1.serialize)(error),
+            type: messages_1.WorkerMessageType.uncaughtError,
+        };
+        implementation_1.default.postMessageToMaster(errorMessage);
+    }
+    catch (subError) {
+        // tslint:disable-next-line no-console
+        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);
+    }
+}
+async function runFunction(jobUID, fn, args) {
+    let syncResult;
+    try {
+        syncResult = fn(...args);
+    }
+    catch (error) {
+        return postJobErrorMessage(jobUID, error);
+    }
+    const resultType = isObservable(syncResult) ? 'observable' : 'promise';
+    postJobStartMessage(jobUID, resultType);
+    if (isObservable(syncResult)) {
+        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);
+            activeSubscriptions.delete(jobUID);
+        });
+        activeSubscriptions.set(jobUID, subscription);
+    }
+    else {
+        try {
+            const result = await syncResult;
+            postJobResultMessage(jobUID, true, (0, common_1.serialize)(result));
+        }
+        catch (error) {
+            postJobErrorMessage(jobUID, (0, common_1.serialize)(error));
+        }
+    }
+}
+/**
+ * Expose a function or a module (an object whose values are functions)
+ * to the main thread. Must be called exactly once in every worker thread
+ * to signal its API to the main thread.
+ *
+ * @param exposed Function or object whose values are functions
+ */
+function expose(exposed) {
+    if (!implementation_1.default.isWorkerRuntime()) {
+        throw new Error('expose() called in the master thread.');
+    }
+    if (exposeCalled) {
+        throw new Error('expose() called more than once. This is not possible. Pass an object to expose() if you want to expose multiple functions.');
+    }
+    exposeCalled = true;
+    if (typeof exposed === 'function') {
+        implementation_1.default.subscribeToMasterMessages((messageData) => {
+            if (isMasterJobRunMessage(messageData) && !messageData.method) {
+                runFunction(messageData.uid, exposed, messageData.args.map(common_1.deserialize));
+            }
+        });
+        postFunctionInitMessage();
+    }
+    else if (typeof exposed === 'object' && exposed) {
+        implementation_1.default.subscribeToMasterMessages((messageData) => {
+            if (isMasterJobRunMessage(messageData) && messageData.method) {
+                runFunction(messageData.uid, exposed[messageData.method], messageData.args.map(common_1.deserialize));
+            }
+        });
+        const methodNames = Object.keys(exposed).filter((key) => typeof exposed[key] === 'function');
+        postModuleInitMessage(methodNames);
+    }
+    else {
+        throw new Error(`Invalid argument passed to expose(). Expected a function or an object, got: ${exposed}`);
+    }
+    implementation_1.default.subscribeToMasterMessages((messageData) => {
+        if (isMasterJobCancelMessage(messageData)) {
+            const jobUID = messageData.uid;
+            const subscription = activeSubscriptions.get(jobUID);
+            if (subscription) {
+                subscription.unsubscribe();
+                activeSubscriptions.delete(jobUID);
+            }
+        }
+    });
+}
+exports.expose = expose;
+if (typeof self !== 'undefined' && typeof self.addEventListener === 'function' && implementation_1.default.isWorkerRuntime()) {
+    self.addEventListener('error', (event) => {
+        // Post with some delay, so the master had some time to subscribe to messages
+        setTimeout(() => postUncaughtErrorMessage(event.error || event), 250);
+    });
+    self.addEventListener('unhandledrejection', (event) => {
+        const error = event.reason;
+        if (error && typeof error.message === 'string') {
+            // Post with some delay, so the master had some time to subscribe to messages
+            setTimeout(() => postUncaughtErrorMessage(error), 250);
+        }
+    });
+}
+if (typeof process !== 'undefined' && typeof process.on === 'function' && implementation_1.default.isWorkerRuntime()) {
+    process.on('uncaughtException', (error) => {
+        // Post with some delay, so the master had some time to subscribe to messages
+        setTimeout(() => postUncaughtErrorMessage(error), 250);
+    });
+    process.on('unhandledRejection', (error) => {
+        if (error && typeof error.message === 'string') {
+            // Post with some delay, so the master had some time to subscribe to messages
+            setTimeout(() => postUncaughtErrorMessage(error), 250);
+        }
+    });
+}

package/dist/worker_threads.d.ts

@@ -0,0 +1,8 @@
+type MessagePort = any;
+interface WorkerThreadsModule {
+    MessagePort: typeof MessagePort;
+    isMainThread: boolean;
+    parentPort: MessagePort;
+}
+export default function getImplementation(): WorkerThreadsModule;
+export {};

package/dist/worker_threads.js

@@ -0,0 +1,17 @@
+"use strict";
+/* eslint-disable import/no-default-export */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+// Webpack hack
+// tslint:disable no-eval
+Object.defineProperty(exports, "__esModule", { value: true });
+let implementation;
+function selectImplementation() {
+    return typeof __non_webpack_require__ === 'function' ? __non_webpack_require__('worker_threads') : eval('require')('worker_threads');
+}
+function getImplementation() {
+    if (!implementation) {
+        implementation = selectImplementation();
+    }
+    return implementation;
+}
+exports.default = getImplementation;

package/dist-esm/common.js

@@ -0,0 +1,12 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { DefaultSerializer, extendSerializer } from './serializers';
+let registeredSerializer = DefaultSerializer;
+export function registerSerializer(serializer) {
+    registeredSerializer = extendSerializer(registeredSerializer, serializer);
+}
+export function deserialize(message) {
+    return registeredSerializer.deserialize(message);
+}
+export function serialize(input) {
+    return registeredSerializer.serialize(input);
+}

package/dist-esm/index.js

@@ -0,0 +1,6 @@
+/* eslint-disable import/no-internal-modules */
+export { registerSerializer } from './common';
+export * from './master/index';
+export { DefaultSerializer } from './serializers';
+export { Transfer } from './transferable';
+export { expose } from './worker/index';

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

@@ -0,0 +1,25 @@
+// Source: <https://github.com/parcel-bundler/parcel/blob/master/packages/core/parcel-bundler/src/builtins/bundle-url.js>
+let bundleURL;
+function getBundleURLCached() {
+    if (!bundleURL) {
+        bundleURL = getBundleURL();
+    }
+    return bundleURL;
+}
+function getBundleURL() {
+    // Attempt to find the URL of the current script and use that as the base URL
+    try {
+        throw new Error('getBundleURL failed');
+    }
+    catch (err) {
+        const matches = ('' + err.stack).match(/(https?|file|ftp|chrome-extension|moz-extension):\/\/[^\n)]+/g);
+        if (matches) {
+            return getBaseURL(matches[0]);
+        }
+    }
+    return '/';
+}
+function getBaseURL(url) {
+    return ('' + url).replace(/^((?:https?|file|ftp|chrome-extension|moz-extension):\/\/.+)?\/[^/]+(?:\?.*)?$/, '$1') + '/';
+}
+export { getBaseURL, getBundleURLCached as getBundleURL };

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

@@ -0,0 +1,64 @@
+// tslint:disable max-classes-per-file
+import { getBundleURL } from './get-bundle-url.browser';
+export const 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' });
+    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 new Error("No web worker implementation available. You might have tried to spawn a worker within a worker in a browser that doesn't support workers in workers.");
+            }
+        };
+    }
+    class WebWorker extends Worker {
+        constructor(url, options) {
+            if (typeof url === 'string' && options && options._baseURL) {
+                url = new URL(url, options._baseURL);
+            }
+            else if (typeof url === 'string' && !isAbsoluteURL(url) && /^file:\/\//i.test(getBundleURL())) {
+                url = new URL(url, getBundleURL().replace(/\/[^/]+$/, '/'));
+                if (options?.CORSWorkaround ?? 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
+                (options?.CORSWorkaround ?? 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' && self['postMessage'] && !isWindowContext ? true : false;
+}

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,224 @@
+/* eslint-disable unicorn/prefer-logical-operator-over-ternary */
+/* eslint-disable unicorn/prefer-regexp-test */
+/* eslint-disable @typescript-eslint/no-var-requires */
+/* eslint-disable unicorn/prefer-add-event-listener */
+/* eslint-disable unicorn/prefer-event-target */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable unicorn/text-encoding-identifier-case */
+/* eslint-disable unicorn/no-process-exit */
+/// <reference lib="dom" />
+import { EventEmitter } from 'node:events';
+import { cpus } from 'node:os';
+import * as path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import getCallsites from 'callsites';
+let tsNodeAvailable;
+export const defaultPoolSize = cpus().length;
+function detectTsNode() {
+    if (typeof __non_webpack_require__ === 'function') {
+        // Webpack build: => No ts-node required or possible
+        return false;
+    }
+    if (tsNodeAvailable) {
+        return tsNodeAvailable;
+    }
+    try {
+        eval('require').resolve('ts-node');
+        tsNodeAvailable = true;
+    }
+    catch (error) {
+        if (error && error.code === 'MODULE_NOT_FOUND') {
+            tsNodeAvailable = false;
+        }
+        else {
+            // Re-throw
+            throw error;
+        }
+    }
+    return tsNodeAvailable;
+}
+function createTsNodeModule(scriptPath) {
+    const content = `
+    require("ts-node/register/transpile-only");
+    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) && !/[/\\]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);
+    }
+    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 {
+        mappedEventListeners;
+        constructor(scriptPath, options) {
+            const resolvedScriptPath = options && options.fromSource ? null : resolveScriptPath(scriptPath, (options || {})._baseURL);
+            if (!resolvedScriptPath) {
+                // `options.fromSource` is true
+                const sourceCode = scriptPath;
+                super(sourceCode, { ...options, eval: true });
+            }
+            else if (/\.tsx?$/i.test(resolvedScriptPath) && detectTsNode()) {
+                super(createTsNodeModule(resolvedScriptPath), { ...options, eval: true });
+            }
+            else if (/\.asar[/\\]/.test(resolvedScriptPath)) {
+                // 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'), { ...options, fromSource: true });
+        }
+        static fromText(source, options) {
+            return new Worker(source, { ...options, fromSource: true });
+        }
+    }
+    return {
+        blob: BlobWorker,
+        default: Worker,
+    };
+}
+function initTinyWorker() {
+    const TinyWorker = require('tiny-worker');
+    let allWorkers = [];
+    class Worker extends TinyWorker {
+        emitter;
+        constructor(scriptPath, options) {
+            // Need to apply a work-around for Windows or it will choke upon the absolute path
+            // (`Error [ERR_INVALID_PROTOCOL]: Protocol 'c:' not supported`)
+            const resolvedScriptPath = options && options.fromSource ? null
+                : process.platform === 'win32' ? `file:///${resolveScriptPath(scriptPath).replaceAll('\\', '/')}`
+                    : resolveScriptPath(scriptPath);
+            if (!resolvedScriptPath) {
+                // `options.fromSource` is true
+                const sourceCode = scriptPath;
+                super(new Function(sourceCode), [], { esm: true });
+            }
+            else if (/\.tsx?$/i.test(resolvedScriptPath) && detectTsNode()) {
+                super(new Function(createTsNodeModule(resolveScriptPath(scriptPath))), [], { esm: true });
+            }
+            else if (/\.asar[/\\]/.test(resolvedScriptPath)) {
+                // See <https://github.com/andywer/threads-plugin/issues/17>
+                super(resolvedScriptPath.replace(/\.asar([/\\])/, '.asar.unpacked$1'), [], { esm: true });
+            }
+            else {
+                super(resolvedScriptPath, [], { esm: true });
+            }
+            allWorkers.push(this);
+            this.emitter = new EventEmitter();
+            this.onerror = (error) => this.emitter.emit('error', error);
+            this.onmessage = (message) => this.emitter.emit('message', message);
+        }
+        addEventListener(eventName, listener) {
+            this.emitter.addListener(eventName, listener);
+        }
+        removeEventListener(eventName, listener) {
+            this.emitter.removeListener(eventName, listener);
+        }
+        terminate() {
+            allWorkers = allWorkers.filter((worker) => worker !== this);
+            return super.terminate();
+        }
+    }
+    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 <https://github.com/avoidwork/tiny-worker#faq>
+    process.on('SIGINT', () => terminateWorkersAndMaster());
+    process.on('SIGTERM', () => terminateWorkersAndMaster());
+    class BlobWorker extends Worker {
+        constructor(blob, options) {
+            super(Buffer.from(blob).toString('utf-8'), { ...options, fromSource: true });
+        }
+        static fromText(source, options) {
+            return new Worker(source, { ...options, fromSource: true });
+        }
+    }
+    return {
+        blob: BlobWorker,
+        default: Worker,
+    };
+}
+let implementation;
+let isTinyWorker;
+function selectWorkerImplementation() {
+    try {
+        isTinyWorker = false;
+        return initWorkerThreadsWorker();
+    }
+    catch {
+        // tslint:disable-next-line no-console
+        console.debug('Node worker_threads not available. Trying to fall back to tiny-worker polyfill...');
+        isTinyWorker = true;
+        return initTinyWorker();
+    }
+}
+export function getWorkerImplementation() {
+    if (!implementation) {
+        implementation = selectWorkerImplementation();
+    }
+    return implementation;
+}
+export function isWorkerRuntime() {
+    if (isTinyWorker) {
+        return self !== undefined && self['postMessage'] ? true : false;
+    }
+    else {
+        // 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 } from './implementation';
+export { Pool } from './pool';
+export { spawn } from './spawn';
+export { Thread } from './thread';
+/** 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;
+export { isWorkerRuntime } from './implementation';