@xylabs/threads
Version:
Web workers & worker threads as simple as a function call
1 lines • 28.3 kB
Source Map (JSON)
{"version":3,"sources":["../../../src/master/pool-browser.ts","../../../src/master/implementation.browser.ts","../../../src/master/pool-types.ts","../../../src/symbols.ts","../../../src/master/thread.ts"],"sourcesContent":["/* eslint-disable import-x/export */\n/* eslint-disable unicorn/no-thenable */\n\n/* eslint-disable @typescript-eslint/member-ordering */\n/* eslint-disable unicorn/no-array-reduce */\n/* eslint-disable @typescript-eslint/no-explicit-any */\n/* eslint-disable @typescript-eslint/no-namespace */\n\n/// <reference lib=\"esnext\" />\n\nimport DebugLogger from 'debug'\nimport {\n multicast, Observable, Subject,\n} from 'observable-fns'\n\nimport { defaultPoolSize } from './implementation.browser.ts'\nimport type {\n PoolEvent, QueuedTask, TaskRunFunction, WorkerDescriptor,\n} from './pool-types.ts'\nimport { PoolEventType } from './pool-types.ts'\nimport { Thread } from './thread.ts'\n\nexport declare namespace Pool {\n type Event<ThreadType extends Thread = any> = PoolEvent<ThreadType>\n type EventType = PoolEventType\n}\n\nlet nextPoolID = 1\n\nfunction createArray(size: number): number[] {\n const array: number[] = []\n for (let index = 0; index < size; index++) {\n array.push(index)\n }\n return array\n}\n\nfunction delay(ms: number) {\n return new Promise(resolve => setTimeout(resolve, ms))\n}\n\nfunction flatMap<In, Out>(array: In[], mapper: (element: In) => Out[]): Out[] {\n return array.reduce<Out[]>((flattened, element) => [...flattened, ...mapper(element)], [])\n}\n\nfunction slugify(text: string) {\n return text.replaceAll(/\\W/g, ' ').trim().replaceAll(/\\s+/g, '-')\n}\n\nfunction spawnWorkers<ThreadType extends Thread>(spawnWorker: () => Promise<ThreadType>, count: number): Array<WorkerDescriptor<ThreadType>> {\n return createArray(count).map(\n (): WorkerDescriptor<ThreadType> => ({\n init: spawnWorker(),\n runningTasks: [],\n }),\n )\n}\n\n/**\n * Thread pool managing a set of worker threads.\n * Use it to queue tasks that are run on those threads with limited\n * concurrency.\n */\nexport interface Pool<ThreadType extends Thread> {\n /**\n * Returns a promise that resolves once the task queue is emptied.\n * Promise will be rejected if any task fails.\n *\n * @param allowResolvingImmediately Set to `true` to resolve immediately if task queue is currently empty.\n */\n completed(allowResolvingImmediately?: boolean): Promise<any>\n\n /**\n * Returns a promise that resolves once the task queue is emptied.\n * Failing tasks will not cause the promise to be rejected.\n *\n * @param allowResolvingImmediately Set to `true` to resolve immediately if task queue is currently empty.\n */\n settled(allowResolvingImmediately?: boolean): Promise<Error[]>\n\n /**\n * Returns an observable that yields pool events.\n */\n events(): Observable<PoolEvent<ThreadType>>\n\n /**\n * Queue a task and return a promise that resolves once the task has been dequeued,\n * started and finished.\n *\n * @param task An async function that takes a thread instance and invokes it.\n */\n queue<Return>(task: TaskRunFunction<ThreadType, Return>): QueuedTask<ThreadType, Return>\n\n /**\n * Terminate all pool threads.\n *\n * @param force Set to `true` to kill the thread even if it cannot be stopped gracefully.\n */\n terminate(force?: boolean): Promise<void>\n}\n\ninterface PoolOptions {\n /** Maximum no. of tasks to run on one worker thread at a time. Defaults to one. */\n concurrency?: number\n\n /** Maximum no. of jobs to be queued for execution before throwing an error. */\n maxQueuedJobs?: number\n\n /** Gives that pool a name to be used for debug logging, letting you distinguish between log output of different pools. */\n name?: string\n\n /** No. of worker threads to spawn and to be managed by the pool. */\n size?: number\n}\n\nclass WorkerPool<ThreadType extends Thread> implements Pool<ThreadType> {\n static EventType = PoolEventType\n\n private readonly debug: DebugLogger.Debugger\n private readonly eventObservable: Observable<PoolEvent<ThreadType>>\n private readonly options: PoolOptions\n private readonly workers: Array<WorkerDescriptor<ThreadType>>\n\n private readonly eventSubject = new Subject<PoolEvent<ThreadType>>()\n private initErrors: Error[] = []\n private isClosing = false\n private nextTaskID = 1\n private taskQueue: Array<QueuedTask<ThreadType, any>> = []\n\n constructor(spawnWorker: () => Promise<ThreadType>, optionsOrSize?: number | PoolOptions) {\n const options: PoolOptions = typeof optionsOrSize === 'number' ? { size: optionsOrSize } : optionsOrSize || {}\n\n const { size = defaultPoolSize } = options\n\n this.debug = DebugLogger(`threads:pool:${slugify(options.name || String(nextPoolID++))}`)\n this.options = options\n this.workers = spawnWorkers(spawnWorker, size)\n\n this.eventObservable = multicast(Observable.from(this.eventSubject))\n\n Promise.all(this.workers.map(worker => worker.init)).then(\n () =>\n this.eventSubject.next({\n size: this.workers.length,\n type: PoolEventType.initialized,\n }),\n (error) => {\n this.debug('Error while initializing pool worker:', error)\n this.eventSubject.error(error)\n this.initErrors.push(error)\n },\n )\n }\n\n private findIdlingWorker(): WorkerDescriptor<ThreadType> | undefined {\n const { concurrency = 1 } = this.options\n return this.workers.find(worker => worker.runningTasks.length < concurrency)\n }\n\n private async runPoolTask(worker: WorkerDescriptor<ThreadType>, task: QueuedTask<ThreadType, any>) {\n const workerID = this.workers.indexOf(worker) + 1\n\n this.debug(`Running task #${task.id} on worker #${workerID}...`)\n this.eventSubject.next({\n taskID: task.id,\n type: PoolEventType.taskStart,\n workerID,\n })\n\n try {\n const returnValue = await task.run(await worker.init)\n\n this.debug(`Task #${task.id} completed successfully`)\n this.eventSubject.next({\n returnValue,\n taskID: task.id,\n type: PoolEventType.taskCompleted,\n workerID,\n })\n } catch (ex) {\n const error = ex as Error\n this.debug(`Task #${task.id} failed`)\n this.eventSubject.next({\n error,\n taskID: task.id,\n type: PoolEventType.taskFailed,\n workerID,\n })\n }\n }\n\n private run(worker: WorkerDescriptor<ThreadType>, task: QueuedTask<ThreadType, any>) {\n const runPromise = (async () => {\n const removeTaskFromWorkersRunningTasks = () => {\n worker.runningTasks = worker.runningTasks.filter(someRunPromise => someRunPromise !== runPromise)\n }\n\n // Defer task execution by one tick to give handlers time to subscribe\n await delay(0)\n\n try {\n await this.runPoolTask(worker, task)\n } finally {\n removeTaskFromWorkersRunningTasks()\n\n if (!this.isClosing) {\n this.scheduleWork()\n }\n }\n })()\n\n worker.runningTasks.push(runPromise)\n }\n\n private scheduleWork() {\n this.debug('Attempt de-queueing a task in order to run it...')\n\n const availableWorker = this.findIdlingWorker()\n if (!availableWorker) return\n\n const nextTask = this.taskQueue.shift()\n if (!nextTask) {\n this.debug('Task queue is empty')\n this.eventSubject.next({ type: PoolEventType.taskQueueDrained })\n return\n }\n\n this.run(availableWorker, nextTask)\n }\n\n private taskCompletion(taskID: number) {\n return new Promise<any>((resolve, reject) => {\n const eventSubscription = this.events().subscribe((event) => {\n if (event.type === PoolEventType.taskCompleted && event.taskID === taskID) {\n eventSubscription.unsubscribe()\n resolve(event.returnValue)\n } else if (event.type === PoolEventType.taskFailed && event.taskID === taskID) {\n eventSubscription.unsubscribe()\n reject(event.error)\n } else if (event.type === PoolEventType.terminated) {\n eventSubscription.unsubscribe()\n reject(new Error('Pool has been terminated before task was run.'))\n }\n })\n })\n }\n\n async settled(allowResolvingImmediately: boolean = false): Promise<Error[]> {\n const getCurrentlyRunningTasks = () => flatMap(this.workers, worker => worker.runningTasks)\n\n const taskFailures: Error[] = []\n\n const failureSubscription = this.eventObservable.subscribe((event) => {\n if (event.type === PoolEventType.taskFailed) {\n taskFailures.push(event.error)\n }\n })\n\n if (this.initErrors.length > 0) {\n throw this.initErrors[0]\n }\n if (allowResolvingImmediately && this.taskQueue.length === 0) {\n await Promise.allSettled(getCurrentlyRunningTasks())\n return taskFailures\n }\n\n await new Promise<void>((resolve, reject) => {\n const subscription = this.eventObservable.subscribe({\n error: reject,\n next(event) {\n if (event.type === PoolEventType.taskQueueDrained) {\n subscription.unsubscribe()\n resolve(void 0)\n }\n }, // make a pool-wide error reject the completed() result promise\n })\n })\n\n await Promise.allSettled(getCurrentlyRunningTasks())\n failureSubscription.unsubscribe()\n\n return taskFailures\n }\n\n async completed(allowResolvingImmediately: boolean = false) {\n const settlementPromise = this.settled(allowResolvingImmediately)\n\n const earlyExitPromise = new Promise<Error[]>((resolve, reject) => {\n const subscription = this.eventObservable.subscribe({\n error: reject,\n next(event) {\n if (event.type === PoolEventType.taskQueueDrained) {\n subscription.unsubscribe()\n resolve(settlementPromise)\n } else if (event.type === PoolEventType.taskFailed) {\n subscription.unsubscribe()\n reject(event.error)\n }\n }, // make a pool-wide error reject the completed() result promise\n })\n })\n\n const errors = await Promise.race([settlementPromise, earlyExitPromise])\n\n if (errors.length > 0) {\n throw errors[0]\n }\n }\n\n events() {\n return this.eventObservable\n }\n\n queue(taskFunction: TaskRunFunction<ThreadType, any>) {\n const { maxQueuedJobs = Number.POSITIVE_INFINITY } = this.options\n\n if (this.isClosing) {\n throw new Error('Cannot schedule pool tasks after terminate() has been called.')\n }\n if (this.initErrors.length > 0) {\n throw this.initErrors[0]\n }\n\n const taskID = this.nextTaskID++\n const taskCompletion = this.taskCompletion(taskID)\n\n taskCompletion.catch((error) => {\n // Prevent unhandled rejections here as we assume the user will use\n // `pool.completed()`, `pool.settled()` or `task.catch()` to handle errors\n this.debug(`Task #${taskID} errored:`, error)\n })\n\n const task: QueuedTask<ThreadType, any> = {\n cancel: () => {\n if (!this.taskQueue.includes(task)) return\n this.taskQueue = this.taskQueue.filter(someTask => someTask !== task)\n this.eventSubject.next({\n taskID: task.id,\n type: PoolEventType.taskCanceled,\n })\n },\n id: taskID,\n run: taskFunction,\n then: taskCompletion.then.bind(taskCompletion),\n }\n\n if (this.taskQueue.length >= maxQueuedJobs) {\n throw new Error(\n 'Maximum number of pool tasks queued. Refusing to queue another one.\\n'\n + 'This usually happens for one of two reasons: We are either at peak '\n + \"workload right now or some tasks just won't finish, thus blocking the pool.\",\n )\n }\n\n this.debug(`Queueing task #${task.id}...`)\n this.taskQueue.push(task)\n\n this.eventSubject.next({\n taskID: task.id,\n type: PoolEventType.taskQueued,\n })\n\n this.scheduleWork()\n return task\n }\n\n async terminate(force?: boolean) {\n this.isClosing = true\n if (!force) {\n await this.completed(true)\n }\n this.eventSubject.next({\n remainingQueue: [...this.taskQueue],\n type: PoolEventType.terminated,\n })\n this.eventSubject.complete()\n await Promise.all(this.workers.map(async worker => Thread.terminate(await worker.init)))\n }\n}\n\n/**\n * Thread pool constructor. Creates a new pool and spawns its worker threads.\n */\nfunction PoolConstructor<ThreadType extends Thread>(spawnWorker: () => Promise<ThreadType>, optionsOrSize?: number | PoolOptions) {\n // The function exists only so we don't need to use `new` to create a pool (we still can, though).\n // If the Pool is a class or not is an implementation detail that should not concern the user.\n return new WorkerPool(spawnWorker, optionsOrSize)\n}\n\n;(PoolConstructor as any).EventType = PoolEventType\n\n/**\n * Thread pool constructor. Creates a new pool and spawns its worker threads.\n */\nexport const Pool = PoolConstructor as typeof PoolConstructor & { EventType: typeof PoolEventType }\n\nexport type { PoolEvent, QueuedTask } from './pool-types.ts'\nexport { PoolEventType } from './pool-types.ts'\nexport { Thread } from './thread.ts'\n","/* eslint-disable @stylistic/max-len */\n/* eslint-disable import-x/no-internal-modules */\n// tslint:disable max-classes-per-file\n\nimport type { ImplementationExport, ThreadsWorkerOptions } from '../types/master.ts'\nimport { getBundleURL } from './get-bundle-url.browser.ts'\n\nexport const defaultPoolSize = typeof navigator !== 'undefined' && navigator.hardwareConcurrency ? navigator.hardwareConcurrency : 4\n\nconst isAbsoluteURL = (value: string) => /^[A-Za-z][\\d+.A-Za-z\\-]*:/.test(value)\n\nfunction createSourceBlobURL(code: string): string {\n const blob = new Blob([code], { type: 'application/javascript' })\n return URL.createObjectURL(blob)\n}\n\nfunction selectWorkerImplementation(): ImplementationExport {\n if (typeof Worker === 'undefined') {\n // Might happen on Safari, for instance\n // The idea is to only fail if the constructor is actually used\n return class NoWebWorker {\n constructor() {\n throw new Error(\n \"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.\",\n )\n }\n } as unknown as ImplementationExport\n }\n\n class WebWorker extends Worker {\n constructor(url: string | URL, options?: ThreadsWorkerOptions) {\n if (typeof url === 'string' && options && options._baseURL) {\n url = new URL(url, options._baseURL)\n } else if (typeof url === 'string' && !isAbsoluteURL(url) && /^file:\\/\\//i.test(getBundleURL())) {\n url = new URL(url, getBundleURL().replace(/\\/[^/]+$/, '/'))\n if (options?.CORSWorkaround ?? true) {\n url = createSourceBlobURL(`importScripts(${JSON.stringify(url)});`)\n }\n }\n if (\n typeof url === 'string'\n && isAbsoluteURL(url) // Create source code blob loading JS file via `importScripts()`\n // to circumvent worker CORS restrictions\n && (options?.CORSWorkaround ?? true)\n ) {\n url = createSourceBlobURL(`importScripts(${JSON.stringify(url)});`)\n }\n super(url, options)\n }\n }\n\n class BlobWorker extends WebWorker {\n constructor(blob: Blob, options?: ThreadsWorkerOptions) {\n const url = globalThis.URL.createObjectURL(blob)\n super(url, options)\n }\n\n static fromText(source: string, options?: ThreadsWorkerOptions): WebWorker {\n const blob = new globalThis.Blob([source], { type: 'text/javascript' })\n return new BlobWorker(blob, options)\n }\n }\n\n return {\n blob: BlobWorker,\n default: WebWorker,\n }\n}\n\nlet implementation: ImplementationExport\n\nexport function getWorkerImplementation(): ImplementationExport {\n if (!implementation) {\n implementation = selectWorkerImplementation()\n }\n return implementation\n}\n\nexport function isWorkerRuntime() {\n const isWindowContext = typeof globalThis !== 'undefined' && typeof Window !== 'undefined' && globalThis instanceof Window\n return typeof globalThis !== 'undefined' && self['postMessage'] && !isWindowContext ? true : false\n}\n","/* eslint-disable @typescript-eslint/no-explicit-any */\n/* eslint-disable @typescript-eslint/member-ordering */\nimport type { Thread } from './thread.ts'\n\n/** Pool event type. Specifies the type of each `PoolEvent`. */\nexport enum PoolEventType {\n initialized = 'initialized',\n taskCanceled = 'taskCanceled',\n taskCompleted = 'taskCompleted',\n taskFailed = 'taskFailed',\n taskQueued = 'taskQueued',\n taskQueueDrained = 'taskQueueDrained',\n taskStart = 'taskStart',\n terminated = 'terminated',\n}\n\nexport type TaskRunFunction<ThreadType extends Thread, Return> = (worker: ThreadType) => Promise<Return>\n\n/** Pool event. Subscribe to those events using `pool.events()`. Useful for debugging. */\nexport type PoolEvent<ThreadType extends Thread> =\n | {\n type: PoolEventType.initialized\n size: number\n }\n | {\n type: PoolEventType.taskQueued\n taskID: number\n }\n | {\n type: PoolEventType.taskQueueDrained\n }\n | {\n type: PoolEventType.taskStart\n taskID: number\n workerID: number\n }\n | {\n type: PoolEventType.taskCompleted\n returnValue: any\n taskID: number\n workerID: number\n }\n | {\n type: PoolEventType.taskFailed\n error: Error\n taskID: number\n workerID: number\n }\n | {\n type: PoolEventType.taskCanceled\n taskID: number\n }\n | {\n type: PoolEventType.terminated\n remainingQueue: Array<QueuedTask<ThreadType, any>>\n }\n\nexport interface WorkerDescriptor<ThreadType extends Thread> {\n init: Promise<ThreadType>\n runningTasks: Array<Promise<any>>\n}\n\n/**\n * Task that has been `pool.queued()`-ed.\n */\nexport interface QueuedTask<ThreadType extends Thread, Return> {\n /** @private */\n id: number\n\n /** @private */\n run: TaskRunFunction<ThreadType, Return>\n\n /**\n * Queued tasks can be cancelled until the pool starts running them on a worker thread.\n */\n cancel(): void\n\n /**\n * `QueuedTask` is thenable, so you can `await` it.\n * Resolves when the task has successfully been executed. Rejects if the task fails.\n */\n then: Promise<Return>['then']\n}\n","export const $errors = Symbol('thread.errors')\nexport const $events = Symbol('thread.events')\nexport const $terminate = Symbol('thread.terminate')\nexport const $transferable = Symbol('thread.transferable')\nexport const $worker = Symbol('thread.worker')\n","/* eslint-disable import-x/no-internal-modules */\nimport type { Observable } from 'observable-fns'\n\nimport {\n $errors, $events, $terminate,\n} from '../symbols.ts'\nimport type { Thread as ThreadType, WorkerEvent } from '../types/master.ts'\n\nfunction fail(message: string): never {\n throw new Error(message)\n}\n\nexport type Thread = ThreadType\n\n/** Thread utility functions. Use them to manage or inspect a `spawn()`-ed thread. */\nexport const Thread = {\n /** Return an observable that can be used to subscribe to all errors happening in the thread. */\n errors<ThreadT extends ThreadType>(thread: ThreadT): Observable<Error> {\n return thread[$errors] || fail('Error observable not found. Make sure to pass a thread instance as returned by the spawn() promise.')\n },\n /** Return an observable that can be used to subscribe to internal events happening in the thread. Useful for debugging. */\n events<ThreadT extends ThreadType>(thread: ThreadT): Observable<WorkerEvent> {\n return thread[$events] || fail('Events observable not found. Make sure to pass a thread instance as returned by the spawn() promise.')\n },\n /** Terminate a thread. Remember to terminate every thread when you are done using it. */\n terminate<ThreadT extends ThreadType>(thread: ThreadT) {\n return thread[$terminate]()\n },\n}\n"],"mappings":";;;;AAUA,OAAOA,iBAAiB;AACxB,SACEC,WAAWC,YAAYC,eAClB;;;ACNA,IAAMC,kBAAkB,OAAOC,cAAc,eAAeA,UAAUC,sBAAsBD,UAAUC,sBAAsB;;;ACF5H,IAAKC,gBAAAA,yBAAAA,gBAAAA;;;;;;;;;SAAAA;;;;ACLL,IAAMC,UAAUC,OAAO,eAAA;AACvB,IAAMC,UAAUD,OAAO,eAAA;AACvB,IAAME,aAAaF,OAAO,kBAAA;AAC1B,IAAMG,gBAAgBH,OAAO,qBAAA;AAC7B,IAAMI,UAAUJ,OAAO,eAAA;;;ACI9B,SAASK,KAAKC,SAAe;AAC3B,QAAM,IAAIC,MAAMD,OAAAA;AAClB;AAFSD;AAOF,IAAMG,SAAS;;EAEpBC,OAAmCC,QAAe;AAChD,WAAOA,OAAOC,OAAAA,KAAYN,KAAK,qGAAA;EACjC;;EAEAO,OAAmCF,QAAe;AAChD,WAAOA,OAAOG,OAAAA,KAAYR,KAAK,sGAAA;EACjC;;EAEAS,UAAsCJ,QAAe;AACnD,WAAOA,OAAOK,UAAAA,EAAW;EAC3B;AACF;;;AJDA,IAAIC,aAAa;AAEjB,SAASC,YAAYC,MAAY;AAC/B,QAAMC,QAAkB,CAAA;AACxB,WAASC,QAAQ,GAAGA,QAAQF,MAAME,SAAS;AACzCD,UAAME,KAAKD,KAAAA;EACb;AACA,SAAOD;AACT;AANSF;AAQT,SAASK,MAAMC,IAAU;AACvB,SAAO,IAAIC,QAAQC,CAAAA,YAAWC,WAAWD,SAASF,EAAAA,CAAAA;AACpD;AAFSD;AAIT,SAASK,QAAiBR,OAAaS,QAA8B;AACnE,SAAOT,MAAMU,OAAc,CAACC,WAAWC,YAAY;OAAID;OAAcF,OAAOG,OAAAA;KAAW,CAAA,CAAE;AAC3F;AAFSJ;AAIT,SAASK,QAAQC,MAAY;AAC3B,SAAOA,KAAKC,WAAW,OAAO,GAAA,EAAKC,KAAI,EAAGD,WAAW,QAAQ,GAAA;AAC/D;AAFSF;AAIT,SAASI,aAAwCC,aAAwCC,OAAa;AACpG,SAAOrB,YAAYqB,KAAAA,EAAOC,IACxB,OAAqC;IACnCC,MAAMH,YAAAA;IACNI,cAAc,CAAA;EAChB,EAAA;AAEJ;AAPSL;AAkET,IAAMM,aAAN,MAAMA,YAAAA;EAnHN,OAmHMA;;;EACJ,OAAOC,YAAYC;EAEFC;EACAC;EACAC;EACAC;EAEAC,eAAe,IAAIC,QAAAA;EAC5BC,aAAsB,CAAA;EACtBC,YAAY;EACZC,aAAa;EACbC,YAAgD,CAAA;EAExD,YAAYjB,aAAwCkB,eAAsC;AACxF,UAAMR,UAAuB,OAAOQ,kBAAkB,WAAW;MAAErC,MAAMqC;IAAc,IAAIA,iBAAiB,CAAC;AAE7G,UAAM,EAAErC,OAAOsC,gBAAe,IAAKT;AAEnC,SAAKF,QAAQY,YAAY,gBAAgBzB,QAAQe,QAAQW,QAAQC,OAAO3C,YAAAA,CAAAA,CAAAA,EAAgB;AACxF,SAAK+B,UAAUA;AACf,SAAKC,UAAUZ,aAAaC,aAAanB,IAAAA;AAEzC,SAAK4B,kBAAkBc,UAAUC,WAAWC,KAAK,KAAKb,YAAY,CAAA;AAElEzB,YAAQuC,IAAI,KAAKf,QAAQT,IAAIyB,CAAAA,WAAUA,OAAOxB,IAAI,CAAA,EAAGyB,KACnD,MACE,KAAKhB,aAAaiB,KAAK;MACrBhD,MAAM,KAAK8B,QAAQmB;MACnBC,MAAMxB,cAAcyB;IACtB,CAAA,GACF,CAACC,UAAAA;AACC,WAAKzB,MAAM,yCAAyCyB,KAAAA;AACpD,WAAKrB,aAAaqB,MAAMA,KAAAA;AACxB,WAAKnB,WAAW9B,KAAKiD,KAAAA;IACvB,CAAA;EAEJ;EAEQC,mBAA6D;AACnE,UAAM,EAAEC,cAAc,EAAC,IAAK,KAAKzB;AACjC,WAAO,KAAKC,QAAQyB,KAAKT,CAAAA,WAAUA,OAAOvB,aAAa0B,SAASK,WAAAA;EAClE;EAEA,MAAcE,YAAYV,QAAsCW,MAAmC;AACjG,UAAMC,WAAW,KAAK5B,QAAQ6B,QAAQb,MAAAA,IAAU;AAEhD,SAAKnB,MAAM,iBAAiB8B,KAAKG,EAAE,eAAeF,QAAAA,KAAa;AAC/D,SAAK3B,aAAaiB,KAAK;MACrBa,QAAQJ,KAAKG;MACbV,MAAMxB,cAAcoC;MACpBJ;IACF,CAAA;AAEA,QAAI;AACF,YAAMK,cAAc,MAAMN,KAAKO,IAAI,MAAMlB,OAAOxB,IAAI;AAEpD,WAAKK,MAAM,SAAS8B,KAAKG,EAAE,yBAAyB;AACpD,WAAK7B,aAAaiB,KAAK;QACrBe;QACAF,QAAQJ,KAAKG;QACbV,MAAMxB,cAAcuC;QACpBP;MACF,CAAA;IACF,SAASQ,IAAI;AACX,YAAMd,QAAQc;AACd,WAAKvC,MAAM,SAAS8B,KAAKG,EAAE,SAAS;AACpC,WAAK7B,aAAaiB,KAAK;QACrBI;QACAS,QAAQJ,KAAKG;QACbV,MAAMxB,cAAcyC;QACpBT;MACF,CAAA;IACF;EACF;EAEQM,IAAIlB,QAAsCW,MAAmC;AACnF,UAAMW,cAAc,YAAA;AAClB,YAAMC,oCAAoC,6BAAA;AACxCvB,eAAOvB,eAAeuB,OAAOvB,aAAa+C,OAAOC,CAAAA,mBAAkBA,mBAAmBH,UAAAA;MACxF,GAF0C;AAK1C,YAAMhE,MAAM,CAAA;AAEZ,UAAI;AACF,cAAM,KAAKoD,YAAYV,QAAQW,IAAAA;MACjC,UAAA;AACEY,0CAAAA;AAEA,YAAI,CAAC,KAAKnC,WAAW;AACnB,eAAKsC,aAAY;QACnB;MACF;IACF,GAAA;AAEA1B,WAAOvB,aAAapB,KAAKiE,UAAAA;EAC3B;EAEQI,eAAe;AACrB,SAAK7C,MAAM,kDAAA;AAEX,UAAM8C,kBAAkB,KAAKpB,iBAAgB;AAC7C,QAAI,CAACoB,gBAAiB;AAEtB,UAAMC,WAAW,KAAKtC,UAAUuC,MAAK;AACrC,QAAI,CAACD,UAAU;AACb,WAAK/C,MAAM,qBAAA;AACX,WAAKI,aAAaiB,KAAK;QAAEE,MAAMxB,cAAckD;MAAiB,CAAA;AAC9D;IACF;AAEA,SAAKZ,IAAIS,iBAAiBC,QAAAA;EAC5B;EAEQG,eAAehB,QAAgB;AACrC,WAAO,IAAIvD,QAAa,CAACC,SAASuE,WAAAA;AAChC,YAAMC,oBAAoB,KAAKC,OAAM,EAAGC,UAAU,CAACC,UAAAA;AACjD,YAAIA,MAAMhC,SAASxB,cAAcuC,iBAAiBiB,MAAMrB,WAAWA,QAAQ;AACzEkB,4BAAkBI,YAAW;AAC7B5E,kBAAQ2E,MAAMnB,WAAW;QAC3B,WAAWmB,MAAMhC,SAASxB,cAAcyC,cAAce,MAAMrB,WAAWA,QAAQ;AAC7EkB,4BAAkBI,YAAW;AAC7BL,iBAAOI,MAAM9B,KAAK;QACpB,WAAW8B,MAAMhC,SAASxB,cAAc0D,YAAY;AAClDL,4BAAkBI,YAAW;AAC7BL,iBAAO,IAAIO,MAAM,+CAAA,CAAA;QACnB;MACF,CAAA;IACF,CAAA;EACF;EAEA,MAAMC,QAAQC,4BAAqC,OAAyB;AAC1E,UAAMC,2BAA2B,6BAAM/E,QAAQ,KAAKqB,SAASgB,CAAAA,WAAUA,OAAOvB,YAAY,GAAzD;AAEjC,UAAMkE,eAAwB,CAAA;AAE9B,UAAMC,sBAAsB,KAAK9D,gBAAgBqD,UAAU,CAACC,UAAAA;AAC1D,UAAIA,MAAMhC,SAASxB,cAAcyC,YAAY;AAC3CsB,qBAAatF,KAAK+E,MAAM9B,KAAK;MAC/B;IACF,CAAA;AAEA,QAAI,KAAKnB,WAAWgB,SAAS,GAAG;AAC9B,YAAM,KAAKhB,WAAW,CAAA;IACxB;AACA,QAAIsD,6BAA6B,KAAKnD,UAAUa,WAAW,GAAG;AAC5D,YAAM3C,QAAQqF,WAAWH,yBAAAA,CAAAA;AACzB,aAAOC;IACT;AAEA,UAAM,IAAInF,QAAc,CAACC,SAASuE,WAAAA;AAChC,YAAMc,eAAe,KAAKhE,gBAAgBqD,UAAU;QAClD7B,OAAO0B;QACP9B,KAAKkC,OAAK;AACR,cAAIA,MAAMhC,SAASxB,cAAckD,kBAAkB;AACjDgB,yBAAaT,YAAW;AACxB5E,oBAAQ,MAAK;UACf;QACF;MACF,CAAA;IACF,CAAA;AAEA,UAAMD,QAAQqF,WAAWH,yBAAAA,CAAAA;AACzBE,wBAAoBP,YAAW;AAE/B,WAAOM;EACT;EAEA,MAAMI,UAAUN,4BAAqC,OAAO;AAC1D,UAAMO,oBAAoB,KAAKR,QAAQC,yBAAAA;AAEvC,UAAMQ,mBAAmB,IAAIzF,QAAiB,CAACC,SAASuE,WAAAA;AACtD,YAAMc,eAAe,KAAKhE,gBAAgBqD,UAAU;QAClD7B,OAAO0B;QACP9B,KAAKkC,OAAK;AACR,cAAIA,MAAMhC,SAASxB,cAAckD,kBAAkB;AACjDgB,yBAAaT,YAAW;AACxB5E,oBAAQuF,iBAAAA;UACV,WAAWZ,MAAMhC,SAASxB,cAAcyC,YAAY;AAClDyB,yBAAaT,YAAW;AACxBL,mBAAOI,MAAM9B,KAAK;UACpB;QACF;MACF,CAAA;IACF,CAAA;AAEA,UAAM4C,SAAS,MAAM1F,QAAQ2F,KAAK;MAACH;MAAmBC;KAAiB;AAEvE,QAAIC,OAAO/C,SAAS,GAAG;AACrB,YAAM+C,OAAO,CAAA;IACf;EACF;EAEAhB,SAAS;AACP,WAAO,KAAKpD;EACd;EAEAsE,MAAMC,cAAgD;AACpD,UAAM,EAAEC,gBAAgBC,OAAOC,kBAAiB,IAAK,KAAKzE;AAE1D,QAAI,KAAKK,WAAW;AAClB,YAAM,IAAImD,MAAM,+DAAA;IAClB;AACA,QAAI,KAAKpD,WAAWgB,SAAS,GAAG;AAC9B,YAAM,KAAKhB,WAAW,CAAA;IACxB;AAEA,UAAM4B,SAAS,KAAK1B;AACpB,UAAM0C,iBAAiB,KAAKA,eAAehB,MAAAA;AAE3CgB,mBAAe0B,MAAM,CAACnD,UAAAA;AAGpB,WAAKzB,MAAM,SAASkC,MAAAA,aAAmBT,KAAAA;IACzC,CAAA;AAEA,UAAMK,OAAoC;MACxC+C,QAAQ,6BAAA;AACN,YAAI,CAAC,KAAKpE,UAAUqE,SAAShD,IAAAA,EAAO;AACpC,aAAKrB,YAAY,KAAKA,UAAUkC,OAAOoC,CAAAA,aAAYA,aAAajD,IAAAA;AAChE,aAAK1B,aAAaiB,KAAK;UACrBa,QAAQJ,KAAKG;UACbV,MAAMxB,cAAciF;QACtB,CAAA;MACF,GAPQ;MAQR/C,IAAIC;MACJG,KAAKmC;MACLpD,MAAM8B,eAAe9B,KAAK6D,KAAK/B,cAAAA;IACjC;AAEA,QAAI,KAAKzC,UAAUa,UAAUmD,eAAe;AAC1C,YAAM,IAAIf,MACR,qNAEE;IAEN;AAEA,SAAK1D,MAAM,kBAAkB8B,KAAKG,EAAE,KAAK;AACzC,SAAKxB,UAAUjC,KAAKsD,IAAAA;AAEpB,SAAK1B,aAAaiB,KAAK;MACrBa,QAAQJ,KAAKG;MACbV,MAAMxB,cAAcmF;IACtB,CAAA;AAEA,SAAKrC,aAAY;AACjB,WAAOf;EACT;EAEA,MAAMqD,UAAUC,OAAiB;AAC/B,SAAK7E,YAAY;AACjB,QAAI,CAAC6E,OAAO;AACV,YAAM,KAAKlB,UAAU,IAAA;IACvB;AACA,SAAK9D,aAAaiB,KAAK;MACrBgE,gBAAgB;WAAI,KAAK5E;;MACzBc,MAAMxB,cAAc0D;IACtB,CAAA;AACA,SAAKrD,aAAakF,SAAQ;AAC1B,UAAM3G,QAAQuC,IAAI,KAAKf,QAAQT,IAAI,OAAMyB,WAAUoE,OAAOJ,UAAU,MAAMhE,OAAOxB,IAAI,CAAA,CAAA;EACvF;AACF;AAKA,SAAS6F,gBAA2ChG,aAAwCkB,eAAoC;AAG9H,SAAO,IAAIb,WAAWL,aAAakB,aAAAA;AACrC;AAJS8E;AAMPA,gBAAwB1F,YAAYC;AAK/B,IAAM0F,OAAOD;","names":["DebugLogger","multicast","Observable","Subject","defaultPoolSize","navigator","hardwareConcurrency","PoolEventType","$errors","Symbol","$events","$terminate","$transferable","$worker","fail","message","Error","Thread","errors","thread","$errors","events","$events","terminate","$terminate","nextPoolID","createArray","size","array","index","push","delay","ms","Promise","resolve","setTimeout","flatMap","mapper","reduce","flattened","element","slugify","text","replaceAll","trim","spawnWorkers","spawnWorker","count","map","init","runningTasks","WorkerPool","EventType","PoolEventType","debug","eventObservable","options","workers","eventSubject","Subject","initErrors","isClosing","nextTaskID","taskQueue","optionsOrSize","defaultPoolSize","DebugLogger","name","String","multicast","Observable","from","all","worker","then","next","length","type","initialized","error","findIdlingWorker","concurrency","find","runPoolTask","task","workerID","indexOf","id","taskID","taskStart","returnValue","run","taskCompleted","ex","taskFailed","runPromise","removeTaskFromWorkersRunningTasks","filter","someRunPromise","scheduleWork","availableWorker","nextTask","shift","taskQueueDrained","taskCompletion","reject","eventSubscription","events","subscribe","event","unsubscribe","terminated","Error","settled","allowResolvingImmediately","getCurrentlyRunningTasks","taskFailures","failureSubscription","allSettled","subscription","completed","settlementPromise","earlyExitPromise","errors","race","queue","taskFunction","maxQueuedJobs","Number","POSITIVE_INFINITY","catch","cancel","includes","someTask","taskCanceled","bind","taskQueued","terminate","force","remainingQueue","complete","Thread","PoolConstructor","Pool"]}