@xylabs/threads 3.5.1 → 3.5.2

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

@@ -1,7 +1,7 @@
 "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.getBundleURL = exports.getBaseURL = void 0;
+exports.getBaseURL = getBaseURL;
+exports.getBundleURL = getBundleURLCached;
 let bundleURL;
 function getBundleURLCached() {
     if (!bundleURL) {
@@ -9,9 +9,7 @@ function getBundleURLCached() {
     }
     return bundleURL;
 }
-exports.getBundleURL = getBundleURLCached;
 function getBundleURL() {
-    // Attempt to find the URL of the current script and use that as the base URL
     try {
         throw new Error('getBundleURL failed');
     }
@@ -26,4 +24,3 @@ function getBundleURL() {
 function getBaseURL(url) {
     return ('' + url).replace(/^((?:https?|file|ftp|chrome-extension|moz-extension):\/\/.+)?\/[^/]+(?:\?.*)?$/, '$1') + '/';
 }
-exports.getBaseURL = getBaseURL;

package/dist/master/implementation.browser.js

@@ -1,7 +1,8 @@
 "use strict";
-// tslint:disable max-classes-per-file
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isWorkerRuntime = exports.getWorkerImplementation = exports.defaultPoolSize = void 0;
+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);
@@ -11,8 +12,6 @@ function createSourceBlobURL(code) {
 }
 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.");
@@ -31,8 +30,7 @@ function selectWorkerImplementation() {
                 }
             }
             if (typeof url === 'string' &&
-                isAbsoluteURL(url) && // Create source code blob loading JS file via `importScripts()`
-                // to circumvent worker CORS restrictions
+                isAbsoluteURL(url) &&
                 (options?.CORSWorkaround ?? true)) {
                 url = createSourceBlobURL(`importScripts(${JSON.stringify(url)});`);
             }
@@ -61,9 +59,7 @@ function getWorkerImplementation() {
     }
     return implementation;
 }
-exports.getWorkerImplementation = getWorkerImplementation;
 function isWorkerRuntime() {
     const isWindowContext = typeof self !== 'undefined' && typeof Window !== 'undefined' && self instanceof Window;
     return typeof self !== 'undefined' && self['postMessage'] && !isWindowContext ? true : false;
 }
-exports.isWorkerRuntime = isWorkerRuntime;

package/dist/master/implementation.d.ts

@@ -1,6 +1,4 @@
 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

@@ -1,7 +1,4 @@
 "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);
@@ -27,15 +24,10 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 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

@@ -1,4 +1,3 @@
-/// <reference lib="dom" />
 import { ImplementationExport } from '../types/master';
 export declare const defaultPoolSize: number;
 export declare function getWorkerImplementation(): ImplementationExport;

package/dist/master/implementation.node.js

@@ -1,18 +1,11 @@
 "use strict";
-/* 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" />
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isWorkerRuntime = exports.getWorkerImplementation = exports.defaultPoolSize = void 0;
+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"));
@@ -22,7 +15,6 @@ let tsNodeAvailable;
 exports.defaultPoolSize = (0, node_os_1.cpus)().length;
 function detectTsNode() {
     if (typeof __non_webpack_require__ === 'function') {
-        // Webpack build: => No ts-node required or possible
         return false;
     }
     if (tsNodeAvailable) {
@@ -37,7 +29,6 @@ function detectTsNode() {
             tsNodeAvailable = false;
         }
         else {
-            // Re-throw
             throw error;
         }
     }
@@ -65,7 +56,6 @@ function rebaseScriptPath(scriptPath, ignoreRegex) {
 }
 function resolveScriptPath(scriptPath, baseURL) {
     const makeRelative = (filePath) => {
-        // eval() hack is also webpack-related
         return node_path_1.default.isAbsolute(filePath) ? filePath : node_path_1.default.join(baseURL || eval('__dirname'), filePath);
     };
     const workerFilePath = typeof __non_webpack_require__ === 'function' ?
@@ -74,7 +64,6 @@ function resolveScriptPath(scriptPath, baseURL) {
     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 {
@@ -82,7 +71,6 @@ function initWorkerThreadsWorker() {
         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 });
             }
@@ -90,7 +78,6 @@ function initWorkerThreadsWorker() {
                 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 {
@@ -112,11 +99,9 @@ function initWorkerThreadsWorker() {
         }
     }
     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 {
@@ -138,13 +123,10 @@ function initTinyWorker() {
     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 });
             }
@@ -152,7 +134,6 @@ function initTinyWorker() {
                 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 {
@@ -175,12 +156,9 @@ function initTinyWorker() {
         }
     }
     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 {
@@ -204,7 +182,6 @@ function selectWorkerImplementation() {
         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();
@@ -216,17 +193,14 @@ function getWorkerImplementation() {
     }
     return implementation;
 }
-exports.getWorkerImplementation = getWorkerImplementation;
 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;
     }
 }
-exports.isWorkerRuntime = isWorkerRuntime;

package/dist/master/index.d.ts

@@ -6,8 +6,6 @@ export { spawn } from './spawn';
 export { Thread } from './thread';
 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;
 export { isWorkerRuntime } from './implementation';

package/dist/master/index.js

@@ -8,9 +8,7 @@ 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;
 var implementation_2 = require("./implementation");
 Object.defineProperty(exports, "isWorkerRuntime", { enumerable: true, get: function () { return implementation_2.isWorkerRuntime; } });

package/dist/master/invocation-proxy.js

@@ -1,16 +1,10 @@
 "use strict";
-/* eslint-disable @typescript-eslint/no-explicit-any */
-/*
- * 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…
- */
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createProxyModule = exports.createProxyFunction = void 0;
+exports.createProxyFunction = createProxyFunction;
+exports.createProxyModule = createProxyModule;
 const debug_1 = __importDefault(require("debug"));
 const observable_fns_1 = require("observable-fns");
 const common_1 = require("../common");
@@ -77,7 +71,6 @@ function createObservableForJob(worker, jobUID) {
 }
 function prepareArguments(rawArgs) {
     if (rawArgs.length === 0) {
-        // Exit early if possible
         return {
             args: [],
             transferables: [],
@@ -119,7 +112,6 @@ function createProxyFunction(worker, method) {
         return observable_promise_1.ObservablePromise.from((0, observable_fns_1.multicast)(createObservableForJob(worker, uid)));
     });
 }
-exports.createProxyFunction = createProxyFunction;
 function createProxyModule(worker, methodNames) {
     const proxy = {};
     for (const methodName of methodNames) {
@@ -127,4 +119,3 @@ function createProxyModule(worker, methodNames) {
     }
     return proxy;
 }
-exports.createProxyModule = createProxyModule;

package/dist/master/pool-types.d.ts

@@ -1,5 +1,4 @@
 import { Thread } from './thread';
-/** Pool event type. Specifies the type of each `PoolEvent`. */
 export declare enum PoolEventType {
     initialized = "initialized",
     taskCanceled = "taskCanceled",
@@ -11,7 +10,6 @@ export declare enum PoolEventType {
     terminated = "terminated"
 }
 export type TaskRunFunction<ThreadType extends Thread, Return> = (worker: ThreadType) => Promise<Return>;
-/** Pool event. Subscribe to those events using `pool.events()`. Useful for debugging. */
 export type PoolEvent<ThreadType extends Thread> = {
     type: PoolEventType.initialized;
     size: number;
@@ -45,21 +43,9 @@ export interface WorkerDescriptor<ThreadType extends Thread> {
     init: Promise<ThreadType>;
     runningTasks: Array<Promise<any>>;
 }
-/**
- * Task that has been `pool.queued()`-ed.
- */
 export interface QueuedTask<ThreadType extends Thread, Return> {
-    /** @private */
     id: number;
-    /** @private */
     run: TaskRunFunction<ThreadType, Return>;
-    /**
-     * Queued tasks can be cancelled until the pool starts running them on a worker thread.
-     */
     cancel(): void;
-    /**
-     * `QueuedTask` is thenable, so you can `await` it.
-     * Resolves when the task has successfully been executed. Rejects if the task fails.
-     */
     then: Promise<Return>['then'];
 }

package/dist/master/pool-types.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PoolEventType = void 0;
-/** Pool event type. Specifies the type of each `PoolEvent`. */
 var PoolEventType;
 (function (PoolEventType) {
     PoolEventType["initialized"] = "initialized";

package/dist/master/pool.d.ts

@@ -5,52 +5,17 @@ export declare namespace Pool {
     type Event<ThreadType extends Thread = any> = PoolEvent<ThreadType>;
     type EventType = PoolEventType;
 }
-/**
- * Thread pool managing a set of worker threads.
- * Use it to queue tasks that are run on those threads with limited
- * concurrency.
- */
 export interface Pool<ThreadType extends Thread> {
-    /**
-     * Returns a promise that resolves once the task queue is emptied.
-     * Promise will be rejected if any task fails.
-     *
-     * @param allowResolvingImmediately Set to `true` to resolve immediately if task queue is currently empty.
-     */
     completed(allowResolvingImmediately?: boolean): Promise<any>;
-    /**
-     * Returns a promise that resolves once the task queue is emptied.
-     * Failing tasks will not cause the promise to be rejected.
-     *
-     * @param allowResolvingImmediately Set to `true` to resolve immediately if task queue is currently empty.
-     */
     settled(allowResolvingImmediately?: boolean): Promise<Error[]>;
-    /**
-     * Returns an observable that yields pool events.
-     */
     events(): Observable<PoolEvent<ThreadType>>;
-    /**
-     * Queue a task and return a promise that resolves once the task has been dequeued,
-     * started and finished.
-     *
-     * @param task An async function that takes a thread instance and invokes it.
-     */
     queue<Return>(task: TaskRunFunction<ThreadType, Return>): QueuedTask<ThreadType, Return>;
-    /**
-     * Terminate all pool threads.
-     *
-     * @param force Set to `true` to kill the thread even if it cannot be stopped gracefully.
-     */
     terminate(force?: boolean): Promise<void>;
 }
 export interface PoolOptions {
-    /** Maximum no. of tasks to run on one worker thread at a time. Defaults to one. */
     concurrency?: number;
-    /** Maximum no. of jobs to be queued for execution before throwing an error. */
     maxQueuedJobs?: number;
-    /** Gives that pool a name to be used for debug logging, letting you distinguish between log output of different pools. */
     name?: string;
-    /** No. of worker threads to spawn and to be managed by the pool. */
     size?: number;
 }
 declare class WorkerPool<ThreadType extends Thread> implements Pool<ThreadType> {
@@ -76,13 +41,7 @@ declare class WorkerPool<ThreadType extends Thread> implements Pool<ThreadType>
     queue(taskFunction: TaskRunFunction<ThreadType, any>): QueuedTask<ThreadType, any>;
     terminate(force?: boolean): Promise<void>;
 }
-/**
- * Thread pool constructor. Creates a new pool and spawns its worker threads.
- */
 declare function PoolConstructor<ThreadType extends Thread>(spawnWorker: () => Promise<ThreadType>, optionsOrSize?: number | PoolOptions): WorkerPool<ThreadType>;
-/**
- * Thread pool constructor. Creates a new pool and spawns its worker threads.
- */
 export declare const Pool: typeof PoolConstructor & {
     EventType: typeof PoolEventType;
 };

package/dist/master/pool.js

@@ -4,14 +4,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Thread = exports.PoolEventType = exports.Pool = void 0;
-/* eslint-disable unicorn/no-thenable */
-/* eslint-disable @typescript-eslint/no-floating-promises */
-/* eslint-disable require-await */
-/* eslint-disable @typescript-eslint/member-ordering */
-/* eslint-disable unicorn/no-array-reduce */
-/* eslint-disable @typescript-eslint/no-explicit-any */
-/* eslint-disable import/export */
-/* eslint-disable @typescript-eslint/no-namespace */
 const debug_1 = __importDefault(require("debug"));
 const observable_fns_1 = require("observable-fns");
 const ponyfills_1 = require("../ponyfills");
@@ -105,7 +97,6 @@ class WorkerPool {
             const removeTaskFromWorkersRunningTasks = () => {
                 worker.runningTasks = worker.runningTasks.filter((someRunPromise) => someRunPromise !== runPromise);
             };
-            // Defer task execution by one tick to give handlers time to subscribe
             await delay(0);
             try {
                 await this.runPoolTask(worker, task);
@@ -173,7 +164,7 @@ class WorkerPool {
                         subscription.unsubscribe();
                         resolve(void 0);
                     }
-                }, // make a pool-wide error reject the completed() result promise
+                },
             });
         });
         await (0, ponyfills_1.allSettled)(getCurrentlyRunningTasks());
@@ -194,7 +185,7 @@ class WorkerPool {
                         subscription.unsubscribe();
                         reject(event.error);
                     }
-                }, // make a pool-wide error reject the completed() result promise
+                },
             });
         });
         const errors = await Promise.race([settlementPromise, earlyExitPromise]);
@@ -216,8 +207,6 @@ class WorkerPool {
         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 = {
@@ -261,19 +250,11 @@ class WorkerPool {
         await Promise.all(this.workers.map(async (worker) => thread_1.Thread.terminate(await worker.init)));
     }
 }
-/**
- * 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 = pool_types_1.PoolEventType;
-/**
- * Thread pool constructor. Creates a new pool and spawns its worker threads.
- */
 exports.Pool = PoolConstructor;
 var pool_types_2 = require("./pool-types");
 Object.defineProperty(exports, "PoolEventType", { enumerable: true, get: function () { return pool_types_2.PoolEventType; } });

package/dist/master/register.js

@@ -1,6 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-/* eslint-disable @typescript-eslint/no-explicit-any */
 const index_1 = require("./index");
 if (typeof global !== 'undefined') {
     ;

package/dist/master/spawn.d.ts

@@ -5,15 +5,6 @@ type ArbitraryWorkerInterface = WorkerFunction & WorkerModule<string> & {
 };
 type ArbitraryThreadType = FunctionThread<any, any> & ModuleThread<any>;
 export type ExposedToThreadType<Exposed extends WorkerFunction | WorkerModule<any>> = Exposed extends ArbitraryWorkerInterface ? ArbitraryThreadType : Exposed extends WorkerFunction ? FunctionThread<Parameters<Exposed>, StripAsync<ReturnType<Exposed>>> : Exposed extends WorkerModule<any> ? ModuleThread<Exposed> : never;
-/**
- * Spawn a new thread. Takes a fresh worker instance, wraps it in a thin
- * abstraction layer to provide the transparent API and verifies that
- * the worker has initialized successfully.
- *
- * @param worker Instance of `Worker`. Either a web worker, `worker_threads` worker or `tiny-worker` worker.
- * @param [options]
- * @param [options.timeout] Init message timeout. Default: 10000 or set by environment variable.
- */
 export declare function spawn<Exposed extends WorkerFunction | WorkerModule<any> = ArbitraryWorkerInterface>(worker: WorkerType, options?: {
     timeout?: number;
 }): Promise<ExposedToThreadType<Exposed>>;

package/dist/master/spawn.js

@@ -3,9 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.spawn = void 0;
-/* eslint-disable @typescript-eslint/no-floating-promises */
-/* eslint-disable @typescript-eslint/no-explicit-any */
+exports.spawn = spawn;
 const debug_1 = __importDefault(require("debug"));
 const observable_fns_1 = require("observable-fns");
 const common_1 = require("../common");
@@ -80,7 +78,6 @@ function createTerminator(worker) {
     const [termination, resolver] = (0, promise_1.createPromiseWithResolver)();
     const terminate = async () => {
         debugThreadUtils('Terminating worker');
-        // Newer versions of worker_threads workers return a promise
         await worker.terminate();
         resolver();
     };
@@ -90,7 +87,6 @@ function setPrivateThreadProps(raw, worker, workerEvents, terminate) {
     const workerErrors = workerEvents
         .filter((event) => event.type === master_1.WorkerEventType.internalError)
         .map((errorEvent) => errorEvent.error);
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     return Object.assign(raw, {
         [symbols_1.$errors]: workerErrors,
         [symbols_1.$events]: workerEvents,
@@ -98,15 +94,6 @@ function setPrivateThreadProps(raw, worker, workerEvents, terminate) {
         [symbols_1.$worker]: worker,
     });
 }
-/**
- * Spawn a new thread. Takes a fresh worker instance, wraps it in a thin
- * abstraction layer to provide the transparent API and verifies that
- * the worker has initialized successfully.
- *
- * @param worker Instance of `Worker`. Either a web worker, `worker_threads` worker or `tiny-worker` worker.
- * @param [options]
- * @param [options.timeout] Init message timeout. Default: 10000 or set by environment variable.
- */
 async function spawn(worker, options) {
     debugSpawn('Initializing new thread');
     const timeout = options && options.timeout ? options.timeout : initMessageTimeout;
@@ -127,4 +114,3 @@ async function spawn(worker, options) {
         throw new Error(`Worker init message states unexpected type of expose(): ${type}`);
     }
 }
-exports.spawn = spawn;

package/dist/master/thread.d.ts

@@ -1,12 +1,8 @@
 import { Observable } from 'observable-fns';
 import { Thread as ThreadType, WorkerEvent } from '../types/master';
 export type Thread = ThreadType;
-/** Thread utility functions. Use them to manage or inspect a `spawn()`-ed thread. */
 export declare const Thread: {
-    /** Return an observable that can be used to subscribe to all errors happening in the thread. */
     errors<ThreadT extends ThreadType>(thread: ThreadT): Observable<Error>;
-    /** Return an observable that can be used to subscribe to internal events happening in the thread. Useful for debugging. */
-    events<ThreadT_1 extends ThreadType>(thread: ThreadT_1): Observable<WorkerEvent>;
-    /** Terminate a thread. Remember to terminate every thread when you are done using it. */
-    terminate<ThreadT_2 extends ThreadType>(thread: ThreadT_2): Promise<void>;
+    events<ThreadT extends ThreadType>(thread: ThreadT): Observable<WorkerEvent>;
+    terminate<ThreadT extends ThreadType>(thread: ThreadT): Promise<void>;
 };

package/dist/master/thread.js

@@ -5,17 +5,13 @@ const symbols_1 = require("../symbols");
 function fail(message) {
     throw new Error(message);
 }
-/** Thread utility functions. Use them to manage or inspect a `spawn()`-ed thread. */
 exports.Thread = {
-    /** Return an observable that can be used to subscribe to all errors happening in the thread. */
     errors(thread) {
         return thread[symbols_1.$errors] || fail('Error observable not found. Make sure to pass a thread instance as returned by the spawn() promise.');
     },
-    /** Return an observable that can be used to subscribe to internal events happening in the thread. Useful for debugging. */
     events(thread) {
         return thread[symbols_1.$events] || fail('Events observable not found. Make sure to pass a thread instance as returned by the spawn() promise.');
     },
-    /** Terminate a thread. Remember to terminate every thread when you are done using it. */
     terminate(thread) {
         return thread[symbols_1.$terminate]();
     },

package/dist/observable-promise.d.ts

@@ -4,19 +4,6 @@ type Thenable<T> = {
     then: (onFulfilled?: (value: T) => any, onRejected?: (error: any) => any) => any;
 };
 type UnsubscribeFn = () => void;
-/**
- * Creates a hybrid, combining the APIs of an Observable and a Promise.
- *
- * It is used to proxy async process states when we are initially not sure
- * if that async process will yield values once (-> Promise) or multiple
- * times (-> Observable).
- *
- * Note that the observable promise inherits some of the observable's characteristics:
- * The `init` function will be called *once for every time anyone subscribes to it*.
- *
- * If this is undesired, derive a hot observable from it using `makeHot()` and
- * subscribe to that.
- */
 export declare class ObservablePromise<T> extends Observable<T> implements Promise<T> {
     readonly [Symbol.toStringTag] = "[object ObservablePromise]";
     private initHasRun;