threadsx 2.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2019 Andy Wermke
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/README.md

@@ -0,0 +1,164 @@
+<h1 align="center">threadsx</h1>
+
+<p align="center">
+  <strong>Make web workers &amp; worker threads as simple as a function call.</strong>
+</p>
+
+<p align="center">
+  <a href="https://github.com/jmaleonard/threadsx/actions/workflows/ci.yml"><img alt="CI" src="https://github.com/jmaleonard/threadsx/actions/workflows/ci.yml/badge.svg"></a>
+  <img alt="Node" src="https://img.shields.io/badge/node-%E2%89%A520-3c873a">
+  <img alt="Modules" src="https://img.shields.io/badge/modules-ESM%20%26%20CommonJS-f97316">
+  <img alt="TypeScript" src="https://img.shields.io/badge/TypeScript-ready-3178c6">
+  <img alt="License" src="https://img.shields.io/badge/license-MIT-blue">
+</p>
+
+<p align="center">
+  A maintained, modernized fork of <a href="https://github.com/andywer/threads.js">threads.js</a> · <a href="https://threadsx.jmaleonard.com">threadsx.jmaleonard.com</a>
+</p>
+
+<br />
+
+Offload CPU-intensive tasks to worker threads in node.js and web browsers using one uniform API. Uses [web workers](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API) in the browser and native [`worker_threads`](https://nodejs.org/api/worker_threads.html) in node.
+
+### Features
+
+* First-class support for **async functions** & **observables**
+* Write code once, run it **in the browser and in node**
+* Manage bulk task executions with **thread pools**
+* Use **`require()`** and **`import`/`export`** in workers
+* Ships **ESM and CommonJS** builds with **up-to-date TypeScript types**
+* Works with modern bundlers (**webpack 5, Vite, esbuild, rollup**) out of the box
+
+### About this fork
+
+`threadsx` continues [andywer/threads.js](https://github.com/andywer/threads.js), which is no longer actively maintained. It modernizes the toolchain and dependencies, targets **Node.js 20+** with native `worker_threads`, drops the legacy `tiny-worker` fallback, and supports the `new Worker(new URL(…, import.meta.url))` pattern emitted by modern bundlers. The public API is unchanged.
+
+## Installation
+
+```
+npm install threadsx
+```
+
+Requires **Node.js 20 or newer**.
+
+## Platform support
+
+<details>
+<summary>Run on node.js</summary>
+
+<p></p>
+
+Running code using threadsx in node works out of the box.
+
+Note that we wrap the native `Worker`, so `new Worker("./foo/bar")` will resolve the path relative to the module that calls it, not relative to the current working directory. That aligns it with the behavior when bundling the code.
+
+During development you can also point a worker at a TypeScript file directly — threadsx runs it through [`tsx`](https://github.com/privatenumber/tsx) (or `ts-node`) when either is installed.
+
+</details>
+
+<details>
+<summary>Bundlers (webpack 5, Vite, esbuild, rollup)</summary>
+
+<p></p>
+
+Modern bundlers detect workers from the standard URL form, so **no extra plugin is required**:
+
+```js
+import { spawn, Worker } from "threadsx"
+
+const worker = new Worker(new URL("./workers/auth", import.meta.url))
+const auth = await spawn(worker)
+```
+
+This replaces the old `threads-plugin` flow, which is no longer needed.
+
+When using TypeScript, make sure the compiler keeps the `import` / `export` statements intact (e.g. `"module": "esnext"` on the worker entry) so the bundler can resolve `new Worker(new URL(...))`.
+
+</details>
+
+<details>
+<summary>Making <code>Worker</code> global (Parcel and similar)</summary>
+
+<p></p>
+
+If your bundler only recognizes `new Worker()` when `Worker` is the global, import `threadsx/register` once at the start of your master code:
+
+```diff
+  import { spawn } from "threadsx"
++ import "threadsx/register"
+
+  // ...
+
+  const work = await spawn(new Worker("./worker"))
+```
+
+This registers the library's `Worker` implementation as the global `Worker`. Be aware this affects any code that instantiates a plain web worker `Worker`.
+
+</details>
+
+## Getting started
+
+```js
+// master.js
+import { spawn, Thread, Worker } from "threadsx"
+
+const auth = await spawn(new Worker("./workers/auth"))
+const hashed = await auth.hashPassword("Super secret password", "1234")
+
+console.log("Hashed password:", hashed)
+
+await Thread.terminate(auth)
+```
+
+```js
+// workers/auth.js
+import sha256 from "js-sha256"
+import { expose } from "threadsx/worker"
+
+expose({
+  hashPassword(password, salt) {
+    return sha256(password + salt)
+  }
+})
+```
+
+### spawn()
+
+The `hashPassword()` function of the `auth` object in the master code proxies the call to the `hashPassword()` function in the worker.
+
+If the worker's function returns a promise or an observable then you can use the return value as such in the master code. If the function returns a primitive value, expect the master function to return a promise resolving to that value.
+
+### expose()
+
+Use `expose()` to make a function or an object containing methods callable from the master thread.
+
+When exposing an object, `spawn()` asynchronously returns an object exposing all the object's functions. If you `expose()` a function, `spawn()` returns a callable function instead.
+
+## Documentation
+
+Find the full documentation on the [website](https://threadsx.jmaleonard.com):
+
+- [**Quick start**](https://threadsx.jmaleonard.com/getting-started)
+- [**Basic usage**](https://threadsx.jmaleonard.com/usage)
+- [**Using observables**](https://threadsx.jmaleonard.com/usage-observables)
+- [**Thread pools**](https://threadsx.jmaleonard.com/usage-pool)
+- [**Advanced**](https://threadsx.jmaleonard.com/usage-advanced)
+
+## Debug
+
+We use the [`debug`](https://github.com/debug-js/debug) package to provide opt-in debug logging. All debug messages have a scope starting with `threads:`, with different sub-scopes:
+
+- `threads:master:messages`
+- `threads:master:spawn`
+- `threads:master:thread-utils`
+- `threads:pool:${poolName || poolID}`
+
+Set `DEBUG=threads:*` to enable all of the library's debug logging:
+
+```
+DEBUG=threads:* npm test
+```
+
+## License
+
+MIT — see [LICENSE](./LICENSE). Originally created by [Andy Wermke](https://github.com/andywer) as [threads.js](https://github.com/andywer/threads.js).

package/dist/common.d.ts

@@ -0,0 +1,4 @@
+import { JsonSerializable, SerializerImplementation } from "./serializers";
+export declare function registerSerializer(serializer: SerializerImplementation<JsonSerializable>): void;
+export declare function deserialize(message: JsonSerializable): any;
+export declare function serialize(input: any): JsonSerializable;

package/dist/common.js

@@ -0,0 +1,16 @@
+"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);
+}
+function deserialize(message) {
+    return registeredSerializer.deserialize(message);
+}
+function serialize(input) {
+    return registeredSerializer.serialize(input);
+}

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export { registerSerializer } from "./common";
+export * from "./master/index";
+export { expose } from "./worker/index";
+export { DefaultSerializer, JsonSerializable, Serializer, SerializerImplementation } from "./serializers";
+export { Transfer, TransferDescriptor } from "./transferable";
+export { ExposedToThreadType as ExposedAs } from "./master/spawn";
+export { QueuedTask } from "./master/pool";

package/dist/index.js

@@ -0,0 +1,26 @@
+"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.Transfer = exports.DefaultSerializer = exports.expose = 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 index_1 = require("./worker/index");
+Object.defineProperty(exports, "expose", { enumerable: true, get: function () { return index_1.expose; } });
+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; } });

package/dist/master/get-bundle-url.browser.d.ts

@@ -0,0 +1,3 @@
+declare function getBundleURLCached(): string;
+declare function getBaseURL(url: string): string;
+export { getBaseURL, getBundleURLCached as getBundleURL };

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

@@ -0,0 +1,28 @@
+"use strict";
+// Source: <https://github.com/parcel-bundler/parcel/blob/master/packages/core/parcel-bundler/src/builtins/bundle-url.js>
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBaseURL = getBaseURL;
+exports.getBundleURL = getBundleURLCached;
+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;
+    }
+    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') + '/';
+}

package/dist/master/implementation.browser.d.ts

@@ -0,0 +1,4 @@
+import { ImplementationExport } from "../types/master";
+export declare const defaultPoolSize: number;
+export declare function getWorkerImplementation(): ImplementationExport;
+export declare function isWorkerRuntime(): boolean;

package/dist/master/implementation.browser.js

@@ -0,0 +1,72 @@
+"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][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) && (0, get_bundle_url_browser_1.getBundleURL)().match(/^file:\/\//i)) {
+                url = new URL(url, (0, get_bundle_url_browser_1.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;
+function getWorkerImplementation() {
+    if (!implementation) {
+        implementation = selectWorkerImplementation();
+    }
+    return implementation;
+}
+function isWorkerRuntime() {
+    const isWindowContext = typeof self !== "undefined" && typeof Window !== "undefined" && self instanceof Window;
+    return typeof self !== "undefined" && typeof self.postMessage === "function" && !isWindowContext;
+}

package/dist/master/implementation.d.ts

@@ -0,0 +1,6 @@
+import * as BrowserImplementation from "./implementation.browser";
+/** Default size of pools. Depending on the platform the value might vary from device to device. */
+export declare const defaultPoolSize: number;
+export declare const getWorkerImplementation: typeof BrowserImplementation.getWorkerImplementation;
+/** Returns `true` if this code is currently running in a worker. */
+export declare const isWorkerRuntime: typeof BrowserImplementation.isWorkerRuntime;

package/dist/master/implementation.js

@@ -0,0 +1,51 @@
+"use strict";
+/*
+ * This file is only a stub to make './implementation' resolve to the right module.
+ */
+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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isWorkerRuntime = exports.getWorkerImplementation = exports.defaultPoolSize = void 0;
+// 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
+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;
+/** Default size of pools. Depending on the platform the value might vary from device to device. */
+exports.defaultPoolSize = implementation.defaultPoolSize;
+exports.getWorkerImplementation = implementation.getWorkerImplementation;
+/** Returns `true` if this code is currently running in a worker. */
+exports.isWorkerRuntime = implementation.isWorkerRuntime;

package/dist/master/implementation.node.d.ts

@@ -0,0 +1,4 @@
+import { ImplementationExport } from "../types/master";
+export declare const defaultPoolSize: number;
+export declare function getWorkerImplementation(): ImplementationExport;
+export declare function isWorkerRuntime(): boolean;

package/dist/master/implementation.node.js

@@ -0,0 +1,196 @@
+"use strict";
+/// <reference lib="dom" />
+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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+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 callsites_1 = __importDefault(require("callsites"));
+const os_1 = require("os");
+const path = __importStar(require("path"));
+const url_1 = require("url");
+let detectedTsRuntime;
+exports.defaultPoolSize = (0, os_1.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 = (0, callsites_1.default)().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 = (0, url_1.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 ? (0, url_1.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();
+}
+function getWorkerImplementation() {
+    if (!implementation) {
+        implementation = selectWorkerImplementation();
+    }
+    return implementation;
+}
+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/master/index.d.ts

@@ -0,0 +1,14 @@
+import type { BlobWorker as BlobWorkerClass } from "../types/master";
+import { Worker as WorkerType } from "../types/master";
+import { isWorkerRuntime } from "./implementation";
+export { FunctionThread, ModuleThread } from "../types/master";
+export { Pool } from "./pool";
+export { spawn } from "./spawn";
+export { Thread } from "./thread";
+export { isWorkerRuntime };
+export type BlobWorker = typeof BlobWorkerClass;
+export type Worker = WorkerType;
+/** Separate class to spawn workers from source code blobs or strings. */
+export declare const BlobWorker: typeof BlobWorkerClass;
+/** Worker implementation. Either web worker or a node.js Worker class. */
+export declare const Worker: typeof import("../types/master").WorkerImplementation;

package/dist/master/index.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Worker = exports.BlobWorker = exports.isWorkerRuntime = exports.Thread = exports.spawn = exports.Pool = void 0;
+const implementation_1 = require("./implementation");
+Object.defineProperty(exports, "isWorkerRuntime", { enumerable: true, get: function () { return implementation_1.isWorkerRuntime; } });
+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; } });
+/** Separate class to spawn workers from source code blobs or strings. */
+exports.BlobWorker = (0, implementation_1.getWorkerImplementation)().blob;
+/** Worker implementation. Either web worker or a node.js Worker class. */
+exports.Worker = (0, implementation_1.getWorkerImplementation)().default;

package/dist/master/invocation-proxy.d.ts

@@ -0,0 +1,3 @@
+import { ModuleMethods, ModuleProxy, ProxyableFunction, Worker as WorkerType } from "../types/master";
+export declare function createProxyFunction<Args extends any[], ReturnType>(worker: WorkerType, method?: string): ProxyableFunction<Args, ReturnType>;
+export declare function createProxyModule<Methods extends ModuleMethods>(worker: WorkerType, methodNames: string[]): ModuleProxy<Methods>;