@idlebox/common 1.3.24 → 1.3.27

package/src/error/pretty.ts

@@ -0,0 +1,253 @@
+import { isAbsolute } from '../path/isAbsolute';
+import { relativePath } from '../path/normalizePath';
+import { globalObject } from '../platform/globalObject';
+import { isNative } from '../platform/os';
+
+const regNormal = /^\s+at ([^\/\s]+)(?: \[as ([^\]]+)])? \(((?:node|file):\/*)?([^:]+)(:\d+)?(:\d+)\)$/;
+const process = globalObject.process;
+const window = globalObject.window;
+
+const enum regNormalMatch {
+	fn = 1,
+	fnAlias,
+	fileSchema,
+	file,
+	row,
+	column,
+}
+
+const regFunctionOnly = /^\s+at ([^\/\\\s]+(?: \[as ([^\]]+)])?)$/;
+
+const enum regFunctionMatch {
+	fn = 1,
+	fnAlias,
+}
+
+const regFileOnly = /^\s+at ([^:]+)(:\d+)?(:\d+)$/;
+
+const enum regFileOnlyMatch {
+	file = 1,
+	row,
+	column,
+}
+
+const regSimpleFrame = /^\s+at ([^(]+) \(<anonymous>\)$/;
+
+const enum regSimpleFrameMatch {
+	fn = 1,
+}
+
+let root = process?.cwd() ?? window?.location?.domain ?? '/';
+
+export function setErrorLogRoot(_root: string) {
+	root = _root;
+}
+
+interface IInternalData {
+	raw?: string;
+	fn?: string;
+	as?: string;
+	file?: string;
+	fileSchema?: string; // 'node' | 'file';
+	line?: number;
+	col?: number;
+	abs?: boolean;
+}
+
+let notify_printed = false;
+export function prettyPrintError(type: string, e: Error) {
+	if (!e.stack || e.stack === e.message) {
+		return console.error(e.message);
+	}
+
+	if (globalObject.process?.env?.DISABLE_PRETTY_ERROR) {
+		console.error('[%s] %s', type, e.stack || e.message);
+		return;
+	}
+	console.error(`------------------------------------------
+[${type}] ${prettyFormatError(e)}`);
+
+	if (!notify_printed) {
+		notify_printed = true;
+		console.error('\x1B[2muse env.DISABLE_PRETTY_ERROR=yes to see original error stack\x1B[0m');
+	}
+}
+
+function red(s: string) {
+	return isNative ? `\x1B[38;5;9m${s}\x1B[0m` : s;
+}
+
+export function prettyFormatError(e: Error, withMessage = true) {
+	if (!e || typeof e.message !== 'string') {
+		console.error(e);
+		return red('Unknown Error') + '\n' + new Error().stack?.split('\n').slice(3).join('\n');
+	}
+	if (!e.stack) {
+		return red(e.message + '\n  No stack trace');
+	}
+	const stackStr = e.stack.replace(/file:\/\//, '').split(/\n/g);
+
+	let first = stackStr.shift()!;
+	const stack: IInternalData[] = stackStr.map((line) => {
+		if (regNormal.test(line)) {
+			const m = regNormal.exec(line)!;
+			return {
+				fn: m[regNormalMatch.fn],
+				as: m[regNormalMatch.fnAlias],
+				fileSchema: m[regNormalMatch.fileSchema],
+				file: m[regNormalMatch.file],
+				line: parseInt(m[regNormalMatch.row].slice(1)),
+				col: parseInt(m[regNormalMatch.column].slice(1)),
+				abs: isAbsolute(m[regNormalMatch.file]),
+			};
+		} else if (regFunctionOnly.test(line)) {
+			const m = regFunctionOnly.exec(line)!;
+			return {
+				fn: m[regFunctionMatch.fn],
+				as: m[regFunctionMatch.fnAlias],
+				file: undefined,
+				line: undefined,
+				col: undefined,
+				abs: false,
+			};
+		} else if (regFileOnly.test(line)) {
+			const m = regFileOnly.exec(line)!;
+			return {
+				fn: undefined,
+				as: undefined,
+				file: m[regFileOnlyMatch.file],
+				line: parseInt(m[regFileOnlyMatch.row].slice(1)),
+				col: parseInt(m[regFileOnlyMatch.column].slice(1)),
+				abs: isAbsolute(m[regFileOnlyMatch.file]),
+			};
+		} else if (regSimpleFrame.test(line)) {
+			const m = regSimpleFrame.exec(line)!;
+			return {
+				fn: m[regSimpleFrameMatch.fn],
+				as: undefined,
+				file: '<anonymous>',
+				line: undefined,
+				col: undefined,
+				abs: false,
+			};
+		} else {
+			return { raw: line.replace(/^  /, '') };
+		}
+	});
+	const stackOutput = stack
+		.filter(ignoreSomeFiles)
+		.map(translateFunction)
+		.map(({ raw, fn, file, as, abs, line, col, fileSchema }) => {
+			let ret;
+			if (raw) {
+				return raw;
+			}
+
+			if (abs) {
+				const isNodeModule = file?.includes('/node_modules/');
+				const color = fn ? (isNodeModule ? '4' : '14') : '8';
+				ret = `  at \x1b[38;5;${color}m`;
+				if (as && fn && fn.startsWith('Object.')) {
+					ret += as + ' [export]';
+				} else {
+					ret += formatFunctionName(fn, as);
+				}
+				ret += '\x1b[0m';
+				if (file) {
+					ret += ' (';
+					if (!isNodeModule) {
+						ret += '\x1b[38;5;2m';
+					}
+					ret += formatFileLine(fileSchema, file, line, col);
+					ret += '\x1B[0m)';
+				}
+			} else {
+				ret = '\x1B[2m  at ';
+				if (fn) {
+					ret += fn;
+				}
+				if (file) {
+					if (fn) {
+						ret += ' (';
+					}
+					ret += formatFileLine(fileSchema, file, line, col);
+					if (fn) {
+						ret += ')';
+					}
+				}
+				ret += '\x1B[0m';
+			}
+			return ret;
+		});
+
+	if (withMessage) {
+		if ((e as any).code) {
+			first = first.replace(/^(\S+):/, (_, name) => {
+				return `${name}(code ${(e as any).code}):`;
+			});
+		}
+
+		return first + '\n' + stackOutput.join('\n');
+	} else {
+		return stackOutput.join('\n');
+	}
+}
+
+function formatFileLine(schema: string | undefined, file: string, row?: number, col?: number) {
+	let rel = file;
+
+	if (schema !== 'node:') {
+		rel = relativePath(root, file);
+		if (rel.startsWith('..')) {
+			rel = file;
+		} else if (!rel.startsWith('.')) {
+			rel = './' + rel;
+		}
+	}
+
+	return `${schema || ''}${rel}${row ? `:${row}` : ''}${col ? `:${col}` : ''}`;
+}
+
+function formatFunctionName(fn?: string, as?: string) {
+	if (fn) {
+		if (as) {
+			return `${fn} [as ${as}]`;
+		} else {
+			return fn;
+		}
+	} else {
+		return '[anonymous]';
+	}
+}
+
+function translateFunction(data: IInternalData): IInternalData {
+	if (!data.fn) {
+		return data;
+	}
+	if (data.fn === 'Timeout._onTimeout') {
+		data.fn = 'setTimeout';
+	}
+	if (data.fn.startsWith('Timeout.') && data.as === '_onTimeout') {
+		data.fn = 'setTimeout->' + data.fn.slice(8);
+		delete data.as;
+	}
+	return data;
+}
+
+function ignoreSomeFiles({ file }: IInternalData): boolean {
+	if (!file) {
+		return true;
+	}
+	if (file === 'internal/timers.js') {
+		return false;
+	}
+	if (file.startsWith('internal/modules/cjs/loader')) {
+		return false;
+	}
+	if (!file.includes('/')) {
+		if (file.startsWith('_stream_')) {
+			return false;
+		}
+	}
+	return true;
+}

package/src/lifecycle/dispose/disposedError.ts

@@ -1,13 +1,30 @@
-import { getErrorFrame } from '../../error/getFrame';
 import { tryInspect } from '../../debugging/tryInspect';
+import { getErrorFrame } from '../../error/getFrame';
+import { prettyFormatError } from '../../error/pretty';
 
 /**
  * Error when call dispose() twice
  */
 export class DisposedError extends Error {
-	constructor(object: any, previous: Error) {
-		super(`Object [${tryInspect(object)}] has already disposed at ${getErrorFrame(previous, 2)}.`);
+	public readonly inspectString: string;
+	constructor(
+		object: any,
+		public readonly previous: Error,
+	) {
+		const insp = tryInspect(object);
+		super(`Object [${insp}] has already disposed ${getErrorFrame(previous, 2)}.`);
+
+		this.inspectString = insp;
 		this.name = 'Warning';
+
+		this.tryCreateConsoleWarning().catch(() => {});
+	}
+
+	public async tryCreateConsoleWarning() {
+		console.error('DisposedWarning: duplicate dispose.');
+		console.error(' * first   dispose:\n%s', prettyFormatError(this.previous, false));
+		console.error(' * current dispose:\n%s', prettyFormatError(this, false));
+		console.error(' * Object: %s', this.inspectString);
 	}
 }
 

package/src/lifecycle/dispose/lifecycle.async.ts

@@ -1,13 +1,13 @@
 import { convertCatchedError } from '../../error/convertUnknown';
 import { Emitter, EventRegister } from '../event/event';
 import { DisposedError } from './disposedError';
-import { IAsyncDisposable, IDisposableBaseInternal } from './lifecycle';
+import { IAsyncDisposable, IDisposableEvents } from './lifecycle';
 
 /**
  * Async version of Disposable
  * @public
  */
-export class AsyncDisposable implements IAsyncDisposable, IDisposableBaseInternal {
+export class AsyncDisposable implements IAsyncDisposable, IDisposableEvents {
 	private readonly _disposables: IAsyncDisposable[] = [];
 
 	protected readonly _onDisposeError = new Emitter<Error>();
@@ -34,12 +34,23 @@ export class AsyncDisposable implements IAsyncDisposable, IDisposableBaseInterna
 	/**
 	 * register a disposable object
 	 */
-	public _register<T extends IAsyncDisposable>(d: T): T {
+	public _register<T extends IAsyncDisposable>(d: T): T;
+	public _register<T extends IAsyncDisposable & IDisposableEvents>(d: T, autoDereference?: boolean): T;
+	public _register<T extends IAsyncDisposable | (IAsyncDisposable & IDisposableEvents)>(d: T, deref?: boolean): T {
 		this.assertNotDisposed();
 		this._disposables.unshift(d);
+		if (deref) {
+			(d as IDisposableEvents).onBeforeDispose(() => {
+				this._unregister(d);
+			});
+		}
 		return d;
 	}
 
+	public _unregister(d: IAsyncDisposable) {
+		return this._disposables.splice(this._disposables.indexOf(d), 1).length > 0;
+	}
+
 	public async dispose(): Promise<void> {
 		if (this._disposed) {
 			console.warn(new DisposedError(this, this._disposed).message);

package/src/lifecycle/dispose/lifecycle.sync.ts

@@ -1,6 +1,6 @@
-import { DisposedError } from './disposedError';
 import { Emitter, EventRegister } from '../event/event';
-import { IDisposable, IDisposableBaseInternal } from './lifecycle';
+import { DisposedError } from './disposedError';
+import { IDisposable, IDisposableEvents } from './lifecycle';
 
 export abstract class DisposableOnce implements IDisposable {
 	private _disposed?: Error;
@@ -23,7 +23,7 @@ export abstract class DisposableOnce implements IDisposable {
 /**
  * Standalone disposable class, can use as instance or base class.
  */
-export class Disposable implements IDisposable, IDisposableBaseInternal {
+export class Disposable implements IDisposable, IDisposableEvents {
 	private readonly _disposables: IDisposable[] = [];
 
 	protected readonly _onDisposeError = new Emitter<Error>();
@@ -47,12 +47,26 @@ export class Disposable implements IDisposable, IDisposableBaseInternal {
 		}
 	}
 
-	public _register<T extends IDisposable>(d: T): T {
+	/**
+	 * register a disposable object
+	 */
+	public _register<T extends IDisposable>(d: T): T;
+	public _register<T extends IDisposable & IDisposableEvents>(d: T, autoDereference?: boolean): T;
+	public _register<T extends IDisposable | (IDisposable & IDisposableEvents)>(d: T, autoDereference?: boolean): T {
 		this.assertNotDisposed();
 		this._disposables.unshift(d);
+		if (autoDereference) {
+			(d as IDisposableEvents).onBeforeDispose(() => {
+				this._unregister(d);
+			});
+		}
 		return d;
 	}
 
+	public _unregister(d: IDisposable) {
+		return this._disposables.splice(this._disposables.indexOf(d), 1).length > 0;
+	}
+
 	public dispose(): void {
 		if (this._disposed) {
 			console.warn(new DisposedError(this, this._disposed).message);

package/src/lifecycle/dispose/lifecycle.ts

@@ -3,7 +3,7 @@ import { EventRegister } from '../event/event';
 /**
  * @private
  */
-export interface IDisposableBaseInternal {
+export interface IDisposableEvents {
 	onDisposeError: EventRegister<Error>;
 	onBeforeDispose: EventRegister<void>;
 	readonly hasDisposed: boolean;

package/src/path/normalizePath.ts

@@ -1,11 +1,134 @@
+const schema = /^[a-z]{2,}:\/\//i;
+const unc = /^[\/\\]{1,2}\?[\/\\]UNC[\/\\]/i;
+const winSp = /^[\/\\]{1,2}\?[\/\\]([a-z]:[\/\\])/i;
+const winLetter = /^[a-z]:\//i;
+const doubleSlash = /^[\/\\]{2}[^\/\\]/i;
+
+export enum PathKind {
+	url,
+	unc,
+	win,
+	cifs,
+	unix,
+	relative,
+}
+export interface IPathInfo {
+	kind: PathKind;
+	prefix?: string;
+	path: string;
+	url?: URL;
+}
+
+export function analyzePath(p: string) {
+	const inp = p;
+	let r: IPathInfo;
+	if (schema.test(p)) {
+		const u = new URL(p);
+		r = {
+			kind: PathKind.url,
+			prefix: u.protocol + '//' + u.host,
+			path: u.pathname.slice(1),
+			url: u,
+		};
+	} else if (unc.test(p)) {
+		p = p.replace(unc, '').replace(/^[\/\\]+/, '');
+		const i = /[\///]/.exec(p)?.index ?? -1;
+		if (i <= 0) throw new Error('invalid unc path: ' + inp);
+
+		r = {
+			kind: PathKind.unc,
+			prefix: '//?/UNC/' + p.slice(0, i),
+			path: p.slice(i + 1),
+		};
+	} else if (winSp.test(p) || winLetter.test(p)) {
+		p = p.replace(winSp, '$1');
+
+		r = {
+			kind: PathKind.win,
+			prefix: p.slice(0, 2),
+			path: p.slice(4),
+		};
+	} else if (doubleSlash.test(p)) {
+		p = p.replace(/^[\/\\]+/, '');
+		const i = /[\///]/.exec(p)?.index ?? -1;
+		if (i <= 0) throw new Error('invalid cifs url: ' + inp);
+
+		r = {
+			kind: PathKind.cifs,
+			prefix: '//' + p.slice(0, i),
+			path: p.slice(i + 1),
+		};
+	} else if (p.startsWith('/')) {
+		r = {
+			kind: PathKind.unix,
+			prefix: '',
+			path: p,
+		};
+	} else {
+		const st = p.startsWith('..') ? '..' : '.';
+		r = {
+			kind: PathKind.relative,
+			prefix: st,
+			path: p,
+		};
+	}
+
+	const path = r.path.replace(/\\/g, '/');
+	const st = [];
+	for (const item of path.split('/')) {
+		if (!item || item === '.') continue;
+		if (item === '..') {
+			st.pop();
+		} else {
+			st.push(item);
+		}
+	}
+	r.path = st.join('/');
+
+	return r;
+}
+
 /**
  * replace // to /
  * replace \ to /
  * remove ending /
  */
 export function normalizePath(p: string) {
-	if (p.startsWith('file:')) {
-		throw new Error('normalizePath not support file url.');
+	const r = analyzePath(p);
+
+	if (r.prefix === undefined) {
+		return r.path;
+	} else {
+		return `${r.prefix}/${r.path}`;
 	}
-	return p.replace(/\\+/g, '/').replace(/\/\/+/g, '/').replace(/\/+$/, '');
+}
+
+export function relativePath(from: string, to: string) {
+	const r1 = analyzePath(from);
+	const r2 = analyzePath(to);
+	if (r1.kind !== r2.kind)
+		throw new Error(
+			`cannot relative path between different kind: "${PathKind[r1.kind]}::${r1.prefix}" * "${
+				PathKind[r2.kind]
+			}::${r2.prefix}"`,
+		);
+
+	if (r1.prefix !== r2.prefix) return to;
+
+	const p1arr = r1.path.split('/');
+	const p2arr = r2.path.split('/');
+
+	// find same prefix
+	let i = 0;
+	while (i < p1arr.length && i < p2arr.length && p1arr[i] === p2arr[i]) i++;
+
+	// remove same prefix
+	p1arr.splice(0, i);
+	p2arr.splice(0, i);
+
+	// add ..
+	const p1 = p1arr.length > 0 ? p1arr.map(() => '..').join('/') + '/' : '';
+	const p2 = p2arr.join('/');
+
+	return p1 + p2;
 }

package/src/promise/{promisePool.ts → promiseCollection.ts}

@@ -1,7 +1,7 @@
 import { CanceledError } from '../lifecycle/promise/cancel';
 import { DeferredPromise } from '../lifecycle/promise/deferredPromise';
 
-export class PromisePool {
+export class PromiseCollection {
 	protected readonly promiseList: Record<string, DeferredPromise<any>> = {};
 
 	size() {

package/src/promise/{timeoutPromisePool.ts → timeoutPromiseCollection.ts}

@@ -1,7 +1,7 @@
 import { TimeoutError } from '../lifecycle/timeout/timeoutError';
-import { PromisePool } from './promisePool';
+import { PromiseCollection } from './promiseCollection';
 
-export class TimeoutPromisePool extends PromisePool {
+export class TimeoutPromiseCollection extends PromiseCollection {
 	constructor(private readonly defaultTimeoutMs = 50000) {
 		super();
 	}

package/src/state/StateMachine.ts

@@ -0,0 +1,52 @@
+import { Emitter } from '../lifecycle/event/event';
+
+// type StateType = string | number;
+// type EventType = string | number;
+
+export type IFsmRuleMap<StateType, EventType> = MapLike<StateType, MapLike<EventType, StateType>>;
+
+type MapLike<K, V> = Pick<Map<K, V>, 'get' | 'has' | 'keys'>;
+
+export interface IStateChangeEvent<StateType, EventType> {
+	from: StateType;
+	to: StateType;
+	reason: EventType;
+}
+
+export class SimpleStateMachine<StateType, EventType> {
+	protected declare currentState: StateType;
+	protected readonly rules: IFsmRuleMap<StateType, EventType>;
+
+	private readonly _onStateChange = new Emitter<IStateChangeEvent<StateType, EventType>>();
+	public readonly onStateChange = this._onStateChange.register;
+
+	constructor(rules: IFsmRuleMap<StateType, EventType>, init_state: StateType) {
+		this.rules = rules;
+		this.moveTo(init_state);
+	}
+
+	protected moveTo(state: StateType) {
+		if (!this.rules.has(state)) throw new Error(`missing state "${state}"`);
+
+		this.currentState = state;
+	}
+
+	getName() {
+		return this.currentState;
+	}
+
+	change(event: EventType) {
+		const state = this.rules.get(this.currentState)!;
+		const next = state.get(event);
+		if (typeof next === 'undefined') {
+			throw new Error(
+				`no event "${event} (${typeof event})" on state "${this.currentState} (${typeof this
+					.currentState})" (has ${[...state.keys()].map((v) => `"${v} (${typeof v})"`).join(', ')})`
+			);
+		}
+
+		const last = this.currentState;
+		this.moveTo(next);
+		this._onStateChange.fireNoError({ from: last, to: next, reason: event });
+	}
+}

package/lib/cjs/promise/promisePool.cjs.map

@@ -1,10 +0,0 @@
-{
-    "version": 3,
-    "file": "promisePool.cjs",
-    "sourceRoot": "",
-    "sources": [
-        "../../../src/promise/promisePool.ts"
-    ],
-    "names": [],
-    "mappings": ";;;AAAA,4DAA4D;AAC5D,8EAAuE;AAEvE,MAAa,WAAW;IACJ,WAAW,GAAyC,EAAE,CAAC;IAE1E,IAAI;QACH,OAAO,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,MAAM,CAAC;IAC7C,CAAC;IAED,MAAM,CAAC,EAAU;QAChB,IAAI,IAAI,CAAC,WAAW,CAAC,EAAE,CAAC,EAAE;YACzB,MAAM,IAAI,KAAK,CAAC,4BAA4B,GAAG,EAAE,CAAC,CAAC;SACnD;QACD,MAAM,GAAG,GAAG,IAAI,iCAAe,EAAO,CAAC;QACvC,IAAI,CAAC,WAAW,CAAC,EAAE,CAAC,GAAG,GAAG,CAAC;QAC3B,OAAO,GAAG,CAAC,CAAC,CAAC;IACd,CAAC;IAED,GAAG,CAAC,EAAU;QACb,OAAO,IAAI,CAAC,WAAW,CAAC,cAAc,CAAC,EAAE,CAAC,CAAC;IAC5C,CAAC;IAED,IAAI,CAAC,EAAU,EAAE,IAAS;QACzB,IAAI,CAAC,WAAW,CAAC,EAAE,CAAE,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;QACrC,OAAO,IAAI,CAAC,WAAW,CAAC,EAAE,CAAC,CAAC;IAC7B,CAAC;IAED,KAAK,CAAC,EAAU,EAAE,CAAQ;QACzB,IAAI,CAAC,WAAW,CAAC,EAAE,CAAE,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QAC/B,OAAO,IAAI,CAAC,WAAW,CAAC,EAAE,CAAC,CAAC;IAC7B,CAAC;IAED,OAAO;QACN,MAAM,CAAC,GAAG,IAAI,sBAAa,EAAE,CAAC;QAC9B,KAAK,MAAM,EAAE,IAAI,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,EAAE;YAC/C,IAAI,CAAC,KAAK,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC;SAClB;IACF,CAAC;CACD;AApCD,kCAoCC"
-}

package/lib/cjs/promise/timeoutPromisePool.cjs.map

@@ -1,10 +0,0 @@
-{
-    "version": 3,
-    "file": "timeoutPromisePool.cjs",
-    "sourceRoot": "",
-    "sources": [
-        "../../../src/promise/timeoutPromisePool.ts"
-    ],
-    "names": [],
-    "mappings": ";;;AAAA,wEAAiE;AACjE,mDAA4C;AAE5C,MAAa,kBAAmB,SAAQ,yBAAW;IACrB;IAA7B,YAA6B,mBAAmB,KAAK;QACpD,KAAK,EAAE,CAAC;QADoB,qBAAgB,GAAhB,gBAAgB,CAAQ;IAErD,CAAC;IAEQ,MAAM,CAAC,EAAU,EAAE,YAAoB,IAAI,CAAC,gBAAgB,EAAE,UAAmB;QACzF,MAAM,CAAC,GAAG,KAAK,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;QAE3B,MAAM,EAAE,GAAG,UAAU,CAAC,GAAG,EAAE;YAC1B,IAAI,CAAC,KAAK,CAAC,EAAE,EAAE,IAAI,2BAAY,CAAC,SAAS,EAAE,UAAU,CAAC,CAAC,CAAC;QACzD,CAAC,EAAE,SAAS,CAAC,CAAC;QAEd,CAAC,CAAC,OAAO,CAAC,GAAG,EAAE;YACd,YAAY,CAAC,EAAE,CAAC,CAAC;QAClB,CAAC,CAAC,CAAC;QAEH,OAAO,CAAC,CAAC;IACV,CAAC;CACD;AAlBD,gDAkBC"
-}

package/lib/esm/promise/promisePool.mjs.map

@@ -1,10 +0,0 @@
-{
-    "version": 3,
-    "file": "promisePool.mjs",
-    "sourceRoot": "",
-    "sources": [
-        "../../../src/promise/promisePool.ts"
-    ],
-    "names": [],
-    "mappings": "AAAA,OAAO,EAAE,aAAa,EAAE,wCAAoC;AAC5D,OAAO,EAAE,eAAe,EAAE,iDAA6C;AAEvE,MAAM,OAAO,WAAW;IACJ,WAAW,GAAyC,EAAE,CAAC;IAE1E,IAAI;QACH,OAAO,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,MAAM,CAAC;IAC7C,CAAC;IAED,MAAM,CAAC,EAAU;QAChB,IAAI,IAAI,CAAC,WAAW,CAAC,EAAE,CAAC,EAAE;YACzB,MAAM,IAAI,KAAK,CAAC,4BAA4B,GAAG,EAAE,CAAC,CAAC;SACnD;QACD,MAAM,GAAG,GAAG,IAAI,eAAe,EAAO,CAAC;QACvC,IAAI,CAAC,WAAW,CAAC,EAAE,CAAC,GAAG,GAAG,CAAC;QAC3B,OAAO,GAAG,CAAC,CAAC,CAAC;IACd,CAAC;IAED,GAAG,CAAC,EAAU;QACb,OAAO,IAAI,CAAC,WAAW,CAAC,cAAc,CAAC,EAAE,CAAC,CAAC;IAC5C,CAAC;IAED,IAAI,CAAC,EAAU,EAAE,IAAS;QACzB,IAAI,CAAC,WAAW,CAAC,EAAE,CAAE,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;QACrC,OAAO,IAAI,CAAC,WAAW,CAAC,EAAE,CAAC,CAAC;IAC7B,CAAC;IAED,KAAK,CAAC,EAAU,EAAE,CAAQ;QACzB,IAAI,CAAC,WAAW,CAAC,EAAE,CAAE,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QAC/B,OAAO,IAAI,CAAC,WAAW,CAAC,EAAE,CAAC,CAAC;IAC7B,CAAC;IAED,OAAO;QACN,MAAM,CAAC,GAAG,IAAI,aAAa,EAAE,CAAC;QAC9B,KAAK,MAAM,EAAE,IAAI,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,EAAE;YAC/C,IAAI,CAAC,KAAK,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC;SAClB;IACF,CAAC;CACD"
-}

package/lib/esm/promise/timeoutPromisePool.mjs.map

@@ -1,10 +0,0 @@
-{
-    "version": 3,
-    "file": "timeoutPromisePool.mjs",
-    "sourceRoot": "",
-    "sources": [
-        "../../../src/promise/timeoutPromisePool.ts"
-    ],
-    "names": [],
-    "mappings": "AAAA,OAAO,EAAE,YAAY,EAAE,8CAA0C;AACjE,OAAO,EAAE,WAAW,EAAE,0BAAsB;AAE5C,MAAM,OAAO,kBAAmB,SAAQ,WAAW;IACrB;IAA7B,YAA6B,mBAAmB,KAAK;QACpD,KAAK,EAAE,CAAC;QADoB,qBAAgB,GAAhB,gBAAgB,CAAQ;IAErD,CAAC;IAEQ,MAAM,CAAC,EAAU,EAAE,YAAoB,IAAI,CAAC,gBAAgB,EAAE,UAAmB;QACzF,MAAM,CAAC,GAAG,KAAK,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;QAE3B,MAAM,EAAE,GAAG,UAAU,CAAC,GAAG,EAAE;YAC1B,IAAI,CAAC,KAAK,CAAC,EAAE,EAAE,IAAI,YAAY,CAAC,SAAS,EAAE,UAAU,CAAC,CAAC,CAAC;QACzD,CAAC,EAAE,SAAS,CAAC,CAAC;QAEd,CAAC,CAAC,OAAO,CAAC,GAAG,EAAE;YACd,YAAY,CAAC,EAAE,CAAC,CAAC;QAClB,CAAC,CAAC,CAAC;QAEH,OAAO,CAAC,CAAC;IACV,CAAC;CACD"
-}