@xylabs/threads 3.5.0 → 3.5.2

package/dist/common.js

@@ -1,18 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.serialize = exports.deserialize = exports.registerSerializer = void 0;
-/* eslint-disable @typescript-eslint/no-explicit-any */
+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);
 }
-exports.registerSerializer = registerSerializer;
 function deserialize(message) {
     return registeredSerializer.deserialize(message);
 }
-exports.deserialize = deserialize;
 function serialize(input) {
     return registeredSerializer.serialize(input);
 }
-exports.serialize = serialize;

package/{dist-esm → dist/esm}/common.js

@@ -1,4 +1,3 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
 import { DefaultSerializer, extendSerializer } from './serializers';
 let registeredSerializer = DefaultSerializer;
 export function registerSerializer(serializer) {

package/{dist-esm → dist/esm}/index.js

@@ -1,4 +1,3 @@
-/* eslint-disable import/no-internal-modules */
 export { registerSerializer } from './common';
 export * from './master/index';
 export { DefaultSerializer } from './serializers';

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

@@ -1,4 +1,3 @@
-// Source: <https://github.com/parcel-bundler/parcel/blob/master/packages/core/parcel-bundler/src/builtins/bundle-url.js>
 let bundleURL;
 function getBundleURLCached() {
     if (!bundleURL) {
@@ -7,7 +6,6 @@ function getBundleURLCached() {
     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');
     }

package/{dist-esm → dist/esm}/master/implementation.browser.js

@@ -1,4 +1,3 @@
-// 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);
@@ -8,8 +7,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.");
@@ -28,8 +25,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)});`);
             }

package/{dist-esm → dist/esm}/master/implementation.js

@@ -1,15 +1,7 @@
-/*
- * 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 → dist/esm}/master/implementation.node.js

@@ -1,22 +1,12 @@
-/* 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 path from 'node:path';
 import { fileURLToPath } from 'node:url';
-import getCallsites from 'callsites';
+import getCallsites from 'callsites-3-1-0';
 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) {
@@ -31,7 +21,6 @@ function detectTsNode() {
             tsNodeAvailable = false;
         }
         else {
-            // Re-throw
             throw error;
         }
     }
@@ -59,7 +48,6 @@ function rebaseScriptPath(scriptPath, ignoreRegex) {
 }
 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' ?
@@ -68,7 +56,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 {
@@ -76,7 +63,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 });
             }
@@ -84,7 +70,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 {
@@ -106,11 +91,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 {
@@ -132,13 +115,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 });
             }
@@ -146,7 +126,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 {
@@ -169,12 +148,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 {
@@ -198,7 +174,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();
@@ -215,7 +190,6 @@ export function isWorkerRuntime() {
         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;

package/{dist-esm → dist/esm}/master/index.js

@@ -2,8 +2,6 @@ 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';

package/{dist-esm → dist/esm}/master/invocation-proxy.js

@@ -1,10 +1,3 @@
-/* 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…
- */
 import DebugLogger from 'debug';
 import { multicast, Observable } from 'observable-fns';
 import { deserialize, serialize } from '../common';
@@ -71,7 +64,6 @@ function createObservableForJob(worker, jobUID) {
 }
 function prepareArguments(rawArgs) {
     if (rawArgs.length === 0) {
-        // Exit early if possible
         return {
             args: [],
             transferables: [],

package/{dist-esm → dist/esm}/master/pool-types.js

@@ -1,4 +1,3 @@
-/** Pool event type. Specifies the type of each `PoolEvent`. */
 export var PoolEventType;
 (function (PoolEventType) {
     PoolEventType["initialized"] = "initialized";

package/{dist-esm → dist/esm}/master/pool.js

@@ -1,11 +1,3 @@
-/* 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 */
 import DebugLogger from 'debug';
 import { multicast, Observable, Subject } from 'observable-fns';
 import { allSettled } from '../ponyfills';
@@ -99,7 +91,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);
@@ -167,7 +158,7 @@ class WorkerPool {
                         subscription.unsubscribe();
                         resolve(void 0);
                     }
-                }, // make a pool-wide error reject the completed() result promise
+                },
             });
         });
         await allSettled(getCurrentlyRunningTasks());
@@ -188,7 +179,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]);
@@ -210,8 +201,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 = {
@@ -255,19 +244,11 @@ class WorkerPool {
         await Promise.all(this.workers.map(async (worker) => 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 = PoolEventType;
-/**
- * Thread pool constructor. Creates a new pool and spawns its worker threads.
- */
 export const Pool = PoolConstructor;
 export { PoolEventType } from './pool-types';
 export { Thread } from './thread';

package/{dist-esm → dist/esm}/master/register.js

@@ -1,4 +1,3 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
 import { Worker as WorkerImplementation } from './index';
 if (typeof global !== 'undefined') {
     ;

package/{dist-esm → dist/esm}/master/spawn.js

@@ -1,5 +1,3 @@
-/* eslint-disable @typescript-eslint/no-floating-promises */
-/* eslint-disable @typescript-eslint/no-explicit-any */
 import DebugLogger from 'debug';
 import { Observable } from 'observable-fns';
 import { deserialize } from '../common';
@@ -74,7 +72,6 @@ function createTerminator(worker) {
     const [termination, resolver] = createPromiseWithResolver();
     const terminate = async () => {
         debugThreadUtils('Terminating worker');
-        // Newer versions of worker_threads workers return a promise
         await worker.terminate();
         resolver();
     };
@@ -84,7 +81,6 @@ function setPrivateThreadProps(raw, worker, workerEvents, terminate) {
     const workerErrors = workerEvents
         .filter((event) => event.type === WorkerEventType.internalError)
         .map((errorEvent) => errorEvent.error);
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     return Object.assign(raw, {
         [$errors]: workerErrors,
         [$events]: workerEvents,
@@ -92,15 +88,6 @@ function setPrivateThreadProps(raw, worker, workerEvents, terminate) {
         [$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.
- */
 export async function spawn(worker, options) {
     debugSpawn('Initializing new thread');
     const timeout = options && options.timeout ? options.timeout : initMessageTimeout;

package/{dist-esm → dist/esm}/master/thread.js

@@ -2,17 +2,13 @@ import { $errors, $events, $terminate } from '../symbols';
 function fail(message) {
     throw new Error(message);
 }
-/** Thread utility functions. Use them to manage or inspect a `spawn()`-ed thread. */
 export const Thread = {
-    /** Return an observable that can be used to subscribe to all errors happening in the thread. */
     errors(thread) {
         return thread[$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[$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[$terminate]();
     },

package/{dist-esm → dist/esm}/observable-promise.js

@@ -1,9 +1,3 @@
-/* eslint-disable unicorn/no-thenable */
-/* eslint-disable @typescript-eslint/member-ordering */
-/* eslint-disable @typescript-eslint/no-floating-promises */
-/* eslint-disable @typescript-eslint/no-explicit-any */
-/* eslint-disable @typescript-eslint/no-this-alias */
-/* eslint-disable unicorn/no-this-assignment */
 import { Observable } from 'observable-fns';
 const doNothing = () => { };
 const returnInput = (input) => input;
@@ -14,19 +8,6 @@ function fail(error) {
 function isThenable(thing) {
     return thing && typeof thing.then === 'function';
 }
-/**
- * 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 class ObservablePromise extends Observable {
     [Symbol.toStringTag] = '[object ObservablePromise]';
     initHasRun = false;
@@ -38,7 +19,6 @@ export class ObservablePromise extends Observable {
     state = 'pending';
     constructor(init) {
         super((originalObserver) => {
-            // tslint:disable-next-line no-this-assignment
             const self = this;
             const observer = {
                 ...originalObserver,
@@ -74,16 +54,12 @@ export class ObservablePromise extends Observable {
         this.state = 'rejected';
         this.rejection = error;
         for (const onRejected of this.rejectionCallbacks) {
-            // Promisifying the call to turn errors into unhandled promise rejections
-            // instead of them failing sync and cancelling the iteration
             runDeferred(() => onRejected(error));
         }
     }
     onCompletion() {
         this.state = 'fulfilled';
         for (const onFulfilled of this.fulfillmentCallbacks) {
-            // Promisifying the call to turn errors into unhandled promise rejections
-            // instead of them failing sync and cancelling the iteration
             runDeferred(() => onFulfilled(this.firstValue));
         }
     }

package/{dist-esm → dist/esm}/observable.js

@@ -1,15 +1,5 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
 import { Observable } from 'observable-fns';
 const $observers = Symbol('observers');
-/**
- * Observable subject. Implements the Observable interface, but also exposes
- * the `next()`, `error()`, `complete()` methods to initiate observable
- * updates "from the outside".
- *
- * Use `Observable.from(subject)` to derive an observable that proxies all
- * values, errors and the completion raised on this subject, but does not
- * expose the `next()`, `error()`, `complete()` methods.
- */
 export class Subject extends Observable {
     [$observers];
     constructor() {

package/{dist-esm → dist/esm}/ponyfills.js

@@ -1,4 +1,3 @@
-// Based on <https://github.com/es-shims/Promise.allSettled/blob/master/implementation.js>
 export function allSettled(values) {
     return Promise.all(values.map((item) => {
         const onFulfill = (value) => {

package/{dist-esm → dist/esm}/promise.js

@@ -1,9 +1,4 @@
-// eslint-disable-next-line unicorn/no-useless-undefined
 const doNothing = () => undefined;
-/**
- * Creates a new promise and exposes its resolver function.
- * Use with care!
- */
 export function createPromiseWithResolver() {
     let alreadyResolved = false;
     let resolvedTo;

package/{dist-esm → dist/esm}/transferable.js

@@ -1,9 +1,7 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
 import { $transferable } from './symbols';
 function isTransferable(thing) {
     if (!thing || typeof thing !== 'object')
         return false;
-    // Don't check too thoroughly, since the list of transferable things in JS might grow over time
     return true;
 }
 export function isTransferDescriptor(thing) {

package/{dist-esm → dist/esm}/types/master.js

@@ -1,8 +1,4 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-/// <reference lib="dom" />
-// tslint:disable max-classes-per-file
 import { $errors, $events, $terminate, $worker } from '../symbols';
-/** Event as emitted by worker thread. Subscribe to using `Thread.events(thread)`. */
 export var WorkerEventType;
 (function (WorkerEventType) {
     WorkerEventType["internalError"] = "internalError";

package/{dist-esm → dist/esm}/types/messages.js

@@ -1,12 +1,8 @@
-/////////////////////////////
-// Messages sent by master:
 export var MasterMessageType;
 (function (MasterMessageType) {
     MasterMessageType["cancel"] = "cancel";
     MasterMessageType["run"] = "run";
 })(MasterMessageType || (MasterMessageType = {}));
-////////////////////////////
-// Messages sent by worker:
 export var WorkerMessageType;
 (function (WorkerMessageType) {
     WorkerMessageType["error"] = "error";

package/{dist-esm → dist/esm}/worker/bundle-entry.js

@@ -1,4 +1,3 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
 import { expose } from './index';
 export * from './index';
 if (typeof global !== 'undefined') {

package/{dist-esm → dist/esm}/worker/implementation.browser.js

@@ -1,7 +1,3 @@
-/* eslint-disable import/no-default-export */
-/* eslint-disable @typescript-eslint/no-explicit-any */
-/// <reference lib="dom" />
-// tslint:disable no-shadowed-variable
 const isWorkerRuntime = function isWorkerRuntime() {
     const isWindowContext = self !== undefined && typeof Window !== 'undefined' && self instanceof Window;
     return self !== undefined && self['postMessage'] && !isWindowContext ? true : false;

package/{dist-esm → dist/esm}/worker/implementation.js

@@ -1,8 +1,3 @@
-/* eslint-disable import/no-default-export */
-// tslint:disable no-var-requires
-/*
- * This file is only a stub to make './implementation' resolve to the right module.
- */
 import WebWorkerImplementation from './implementation.browser';
 import TinyWorkerImplementation from './implementation.tiny-worker';
 import WorkerThreadsImplementation from './implementation.worker_threads';

package/{dist-esm → dist/esm}/worker/implementation.tiny-worker.js

@@ -1,7 +1,3 @@
-/* eslint-disable import/no-default-export */
-/* eslint-disable @typescript-eslint/no-explicit-any */
-/// <reference lib="dom" />
-// tslint:disable no-shadowed-variable
 try {
     if (self === undefined) {
         ;
@@ -16,15 +12,12 @@ const isWorkerRuntime = function isWorkerRuntime() {
     return self !== undefined && self['postMessage'] ? true : false;
 };
 const postMessageToMaster = function postMessageToMaster(data) {
-    // TODO: Warn that Transferables are not supported on first attempt to use feature
     self.postMessage(data);
 };
 let muxingHandlerSetUp = false;
 const messageHandlers = new Set();
 const subscribeToMasterMessages = function subscribeToMasterMessages(onMessage) {
     if (!muxingHandlerSetUp) {
-        // We have one multiplexing message handler as tiny-worker's
-        // addEventListener() only allows you to set a single message handler
         self.addEventListener('message', ((event) => {
             for (const handler of messageHandlers)
                 handler(event.data);

package/{dist-esm → dist/esm}/worker/implementation.worker_threads.js

@@ -26,7 +26,6 @@ const subscribeToMasterMessages = function subscribeToMasterMessages(onMessage)
     return unsubscribe;
 };
 function testImplementation() {
-    // Will throw if `worker_threads` are not available
     WorkerThreads();
 }
 export default {

package/{dist-esm → dist/esm}/worker/index.js

@@ -1,22 +1,15 @@
-/* eslint-disable @typescript-eslint/no-floating-promises */
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import isSomeObservable from 'is-observable';
+import isSomeObservable from 'is-observable-2-1-0';
 import { deserialize, serialize } from '../common';
 import { isTransferDescriptor } from '../transferable';
 import { MasterMessageType, WorkerMessageType, } from '../types/messages';
 import Implementation from './implementation';
 export { registerSerializer } from '../common';
 export { Transfer } from '../transferable';
-/** Returns `true` if this code is currently running in a worker. */
 export const isWorkerRuntime = Implementation.isWorkerRuntime;
 let exposeCalled = false;
 const activeSubscriptions = new Map();
 const isMasterJobCancelMessage = (thing) => thing && thing.type === MasterMessageType.cancel;
 const isMasterJobRunMessage = (thing) => thing && thing.type === 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) => isSomeObservable(thing) || isZenObservable(thing);
 function isZenObservable(thing) {
     return thing && typeof thing === 'object' && typeof thing.subscribe === 'function';
@@ -79,7 +72,6 @@ function postUncaughtErrorMessage(error) {
         Implementation.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);
     }
 }
@@ -113,13 +105,6 @@ async function runFunction(jobUID, fn, args) {
         }
     }
 }
-/**
- * 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 function expose(exposed) {
     if (!Implementation.isWorkerRuntime()) {
         throw new Error('expose() called in the master thread.');
@@ -161,25 +146,21 @@ export function expose(exposed) {
 }
 if (typeof self !== 'undefined' && typeof self.addEventListener === 'function' && Implementation.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.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-esm → dist/esm}/worker_threads.js

@@ -1,7 +1,3 @@
-/* eslint-disable import/no-default-export */
-/* eslint-disable @typescript-eslint/no-explicit-any */
-// Webpack hack
-// tslint:disable no-eval
 let implementation;
 function selectImplementation() {
     return typeof __non_webpack_require__ === 'function' ? __non_webpack_require__('worker_threads') : eval('require')('worker_threads');

package/dist/index.js

@@ -15,7 +15,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.expose = exports.Transfer = exports.DefaultSerializer = exports.registerSerializer = void 0;
-/* eslint-disable import/no-internal-modules */
 var common_1 = require("./common");
 Object.defineProperty(exports, "registerSerializer", { enumerable: true, get: function () { return common_1.registerSerializer; } });
 __exportStar(require("./master/index"), exports);