likec4 1.48.0 → 1.50.0

package/dist/_chunks/libs/p-limit.mjs

@@ -1,120 +1 @@
-//#region ../../node_modules/.pnpm/yocto-queue@1.2.2/node_modules/yocto-queue/index.js
-var Node = class {
-	value;
-	next;
-	constructor(value) {
-		this.value = value;
-	}
-};
-var Queue = class {
-	#head;
-	#tail;
-	#size;
-	constructor() {
-		this.clear();
-	}
-	enqueue(value) {
-		const node = new Node(value);
-		if (this.#head) {
-			this.#tail.next = node;
-			this.#tail = node;
-		} else {
-			this.#head = node;
-			this.#tail = node;
-		}
-		this.#size++;
-	}
-	dequeue() {
-		const current = this.#head;
-		if (!current) return;
-		this.#head = this.#head.next;
-		this.#size--;
-		if (!this.#head) this.#tail = void 0;
-		return current.value;
-	}
-	peek() {
-		if (!this.#head) return;
-		return this.#head.value;
-	}
-	clear() {
-		this.#head = void 0;
-		this.#tail = void 0;
-		this.#size = 0;
-	}
-	get size() {
-		return this.#size;
-	}
-	*[Symbol.iterator]() {
-		let current = this.#head;
-		while (current) {
-			yield current.value;
-			current = current.next;
-		}
-	}
-	*drain() {
-		while (this.#head) yield this.dequeue();
-	}
-};
-
-//#endregion
-//#region ../../node_modules/.pnpm/p-limit@7.2.0/node_modules/p-limit/index.js
-function pLimit(concurrency) {
-	validateConcurrency(concurrency);
-	const queue = new Queue();
-	let activeCount = 0;
-	const resumeNext = () => {
-		if (activeCount < concurrency && queue.size > 0) {
-			activeCount++;
-			queue.dequeue()();
-		}
-	};
-	const next = () => {
-		activeCount--;
-		resumeNext();
-	};
-	const run = async (function_, resolve, arguments_) => {
-		const result = (async () => function_(...arguments_))();
-		resolve(result);
-		try {
-			await result;
-		} catch {}
-		next();
-	};
-	const enqueue = (function_, resolve, arguments_) => {
-		new Promise((internalResolve) => {
-			queue.enqueue(internalResolve);
-		}).then(run.bind(void 0, function_, resolve, arguments_));
-		if (activeCount < concurrency) resumeNext();
-	};
-	const generator = (function_, ...arguments_) => new Promise((resolve) => {
-		enqueue(function_, resolve, arguments_);
-	});
-	Object.defineProperties(generator, {
-		activeCount: { get: () => activeCount },
-		pendingCount: { get: () => queue.size },
-		clearQueue: { value() {
-			queue.clear();
-		} },
-		concurrency: {
-			get: () => concurrency,
-			set(newConcurrency) {
-				validateConcurrency(newConcurrency);
-				concurrency = newConcurrency;
-				queueMicrotask(() => {
-					while (activeCount < concurrency && queue.size > 0) resumeNext();
-				});
-			}
-		},
-		map: { async value(iterable, function_) {
-			const promises = Array.from(iterable, (value, index) => this(function_, value, index));
-			return Promise.all(promises);
-		} }
-	});
-	return generator;
-}
-function validateConcurrency(concurrency) {
-	if (!((Number.isInteger(concurrency) || concurrency === Number.POSITIVE_INFINITY) && concurrency > 0)) throw new TypeError("Expected `concurrency` to be a number from 1 and up");
-}
-
-//#endregion
-export { pLimit as t };
+var e=class{value;next;constructor(e){this.value=e}},t=class{#e;#t;#n;constructor(){this.clear()}enqueue(t){let n=new e(t);this.#e?(this.#t.next=n,this.#t=n):(this.#e=n,this.#t=n),this.#n++}dequeue(){let e=this.#e;if(e)return this.#e=this.#e.next,this.#n--,this.#e||(this.#t=void 0),e.value}peek(){if(this.#e)return this.#e.value}clear(){this.#e=void 0,this.#t=void 0,this.#n=0}get size(){return this.#n}*[Symbol.iterator](){let e=this.#e;for(;e;)yield e.value,e=e.next}*drain(){for(;this.#e;)yield this.dequeue()}};function n(e){let n=!1;if(typeof e==`object`&&({concurrency:e,rejectOnClear:n=!1}=e),r(e),typeof n!=`boolean`)throw TypeError("Expected `rejectOnClear` to be a boolean");let i=new t,a=0,o=()=>{a<e&&i.size>0&&(a++,i.dequeue().run())},s=()=>{a--,o()},c=async(e,t,n)=>{let r=(async()=>e(...n))();t(r);try{await r}catch{}s()},l=(t,n,r,s)=>{let l={reject:r};new Promise(e=>{l.run=e,i.enqueue(l)}).then(c.bind(void 0,t,n,s)),a<e&&o()},u=(e,...t)=>new Promise((n,r)=>{l(e,n,r,t)});return Object.defineProperties(u,{activeCount:{get:()=>a},pendingCount:{get:()=>i.size},clearQueue:{value(){if(!n){i.clear();return}let e=AbortSignal.abort().reason;for(;i.size>0;)i.dequeue().reject(e)}},concurrency:{get:()=>e,set(t){r(t),e=t,queueMicrotask(()=>{for(;a<e&&i.size>0;)o()})}},map:{async value(e,t){let n=Array.from(e,(e,n)=>this(t,e,n));return Promise.all(n)}}}),u}function r(e){if(!((Number.isInteger(e)||e===1/0)&&e>0))throw TypeError("Expected `concurrency` to be a number from 1 and up")}export{n as t};

package/dist/_chunks/libs/p-queue.mjs

@@ -1,449 +1 @@
-import { t as import_eventemitter3 } from "./eventemitter3.mjs";
-
-//#region ../../node_modules/.pnpm/p-timeout@6.1.4/node_modules/p-timeout/index.js
-var TimeoutError = class extends Error {
-	constructor(message) {
-		super(message);
-		this.name = "TimeoutError";
-	}
-};
-/**
-An error to be thrown when the request is aborted by AbortController.
-DOMException is thrown instead of this Error when DOMException is available.
-*/
-var AbortError = class extends Error {
-	constructor(message) {
-		super();
-		this.name = "AbortError";
-		this.message = message;
-	}
-};
-/**
-TODO: Remove AbortError and just throw DOMException when targeting Node 18.
-*/
-const getDOMException = (errorMessage) => globalThis.DOMException === void 0 ? new AbortError(errorMessage) : new DOMException(errorMessage);
-/**
-TODO: Remove below function and just 'reject(signal.reason)' when targeting Node 18.
-*/
-const getAbortedReason = (signal) => {
-	const reason = signal.reason === void 0 ? getDOMException("This operation was aborted.") : signal.reason;
-	return reason instanceof Error ? reason : getDOMException(reason);
-};
-function pTimeout(promise, options) {
-	const { milliseconds, fallback, message, customTimers = {
-		setTimeout,
-		clearTimeout
-	} } = options;
-	let timer;
-	let abortHandler;
-	const cancelablePromise = new Promise((resolve, reject) => {
-		if (typeof milliseconds !== "number" || Math.sign(milliseconds) !== 1) throw new TypeError(`Expected \`milliseconds\` to be a positive number, got \`${milliseconds}\``);
-		if (options.signal) {
-			const { signal } = options;
-			if (signal.aborted) reject(getAbortedReason(signal));
-			abortHandler = () => {
-				reject(getAbortedReason(signal));
-			};
-			signal.addEventListener("abort", abortHandler, { once: true });
-		}
-		if (milliseconds === Number.POSITIVE_INFINITY) {
-			promise.then(resolve, reject);
-			return;
-		}
-		const timeoutError = new TimeoutError();
-		timer = customTimers.setTimeout.call(void 0, () => {
-			if (fallback) {
-				try {
-					resolve(fallback());
-				} catch (error) {
-					reject(error);
-				}
-				return;
-			}
-			if (typeof promise.cancel === "function") promise.cancel();
-			if (message === false) resolve();
-			else if (message instanceof Error) reject(message);
-			else {
-				timeoutError.message = message ?? `Promise timed out after ${milliseconds} milliseconds`;
-				reject(timeoutError);
-			}
-		}, milliseconds);
-		(async () => {
-			try {
-				resolve(await promise);
-			} catch (error) {
-				reject(error);
-			}
-		})();
-	}).finally(() => {
-		cancelablePromise.clear();
-		if (abortHandler && options.signal) options.signal.removeEventListener("abort", abortHandler);
-	});
-	cancelablePromise.clear = () => {
-		customTimers.clearTimeout.call(void 0, timer);
-		timer = void 0;
-	};
-	return cancelablePromise;
-}
-
-//#endregion
-//#region ../../node_modules/.pnpm/p-queue@8.1.1/node_modules/p-queue/dist/lower-bound.js
-function lowerBound(array, value, comparator) {
-	let first = 0;
-	let count = array.length;
-	while (count > 0) {
-		const step = Math.trunc(count / 2);
-		let it = first + step;
-		if (comparator(array[it], value) <= 0) {
-			first = ++it;
-			count -= step + 1;
-		} else count = step;
-	}
-	return first;
-}
-
-//#endregion
-//#region ../../node_modules/.pnpm/p-queue@8.1.1/node_modules/p-queue/dist/priority-queue.js
-var PriorityQueue = class {
-	#queue = [];
-	enqueue(run, options) {
-		options = {
-			priority: 0,
-			...options
-		};
-		const element = {
-			priority: options.priority,
-			id: options.id,
-			run
-		};
-		if (this.size === 0 || this.#queue[this.size - 1].priority >= options.priority) {
-			this.#queue.push(element);
-			return;
-		}
-		const index = lowerBound(this.#queue, element, (a, b) => b.priority - a.priority);
-		this.#queue.splice(index, 0, element);
-	}
-	setPriority(id, priority) {
-		const index = this.#queue.findIndex((element) => element.id === id);
-		if (index === -1) throw new ReferenceError(`No promise function with the id "${id}" exists in the queue.`);
-		const [item] = this.#queue.splice(index, 1);
-		this.enqueue(item.run, {
-			priority,
-			id
-		});
-	}
-	dequeue() {
-		return this.#queue.shift()?.run;
-	}
-	filter(options) {
-		return this.#queue.filter((element) => element.priority === options.priority).map((element) => element.run);
-	}
-	get size() {
-		return this.#queue.length;
-	}
-};
-
-//#endregion
-//#region ../../node_modules/.pnpm/p-queue@8.1.1/node_modules/p-queue/dist/index.js
-/**
-Promise queue with concurrency control.
-*/
-var PQueue = class extends import_eventemitter3.default {
-	#carryoverConcurrencyCount;
-	#isIntervalIgnored;
-	#intervalCount = 0;
-	#intervalCap;
-	#interval;
-	#intervalEnd = 0;
-	#intervalId;
-	#timeoutId;
-	#queue;
-	#queueClass;
-	#pending = 0;
-	#concurrency;
-	#isPaused;
-	#throwOnTimeout;
-	#idAssigner = 1n;
-	/**
-	Per-operation timeout in milliseconds. Operations fulfill once `timeout` elapses if they haven't already.
-	
-	Applies to each future operation.
-	*/
-	timeout;
-	constructor(options) {
-		super();
-		options = {
-			carryoverConcurrencyCount: false,
-			intervalCap: Number.POSITIVE_INFINITY,
-			interval: 0,
-			concurrency: Number.POSITIVE_INFINITY,
-			autoStart: true,
-			queueClass: PriorityQueue,
-			...options
-		};
-		if (!(typeof options.intervalCap === "number" && options.intervalCap >= 1)) throw new TypeError(`Expected \`intervalCap\` to be a number from 1 and up, got \`${options.intervalCap?.toString() ?? ""}\` (${typeof options.intervalCap})`);
-		if (options.interval === void 0 || !(Number.isFinite(options.interval) && options.interval >= 0)) throw new TypeError(`Expected \`interval\` to be a finite number >= 0, got \`${options.interval?.toString() ?? ""}\` (${typeof options.interval})`);
-		this.#carryoverConcurrencyCount = options.carryoverConcurrencyCount;
-		this.#isIntervalIgnored = options.intervalCap === Number.POSITIVE_INFINITY || options.interval === 0;
-		this.#intervalCap = options.intervalCap;
-		this.#interval = options.interval;
-		this.#queue = new options.queueClass();
-		this.#queueClass = options.queueClass;
-		this.concurrency = options.concurrency;
-		this.timeout = options.timeout;
-		this.#throwOnTimeout = options.throwOnTimeout === true;
-		this.#isPaused = options.autoStart === false;
-	}
-	get #doesIntervalAllowAnother() {
-		return this.#isIntervalIgnored || this.#intervalCount < this.#intervalCap;
-	}
-	get #doesConcurrentAllowAnother() {
-		return this.#pending < this.#concurrency;
-	}
-	#next() {
-		this.#pending--;
-		this.#tryToStartAnother();
-		this.emit("next");
-	}
-	#onResumeInterval() {
-		this.#onInterval();
-		this.#initializeIntervalIfNeeded();
-		this.#timeoutId = void 0;
-	}
-	get #isIntervalPaused() {
-		const now = Date.now();
-		if (this.#intervalId === void 0) {
-			const delay = this.#intervalEnd - now;
-			if (delay < 0) this.#intervalCount = this.#carryoverConcurrencyCount ? this.#pending : 0;
-			else {
-				if (this.#timeoutId === void 0) this.#timeoutId = setTimeout(() => {
-					this.#onResumeInterval();
-				}, delay);
-				return true;
-			}
-		}
-		return false;
-	}
-	#tryToStartAnother() {
-		if (this.#queue.size === 0) {
-			if (this.#intervalId) clearInterval(this.#intervalId);
-			this.#intervalId = void 0;
-			this.emit("empty");
-			if (this.#pending === 0) this.emit("idle");
-			return false;
-		}
-		if (!this.#isPaused) {
-			const canInitializeInterval = !this.#isIntervalPaused;
-			if (this.#doesIntervalAllowAnother && this.#doesConcurrentAllowAnother) {
-				const job = this.#queue.dequeue();
-				if (!job) return false;
-				this.emit("active");
-				job();
-				if (canInitializeInterval) this.#initializeIntervalIfNeeded();
-				return true;
-			}
-		}
-		return false;
-	}
-	#initializeIntervalIfNeeded() {
-		if (this.#isIntervalIgnored || this.#intervalId !== void 0) return;
-		this.#intervalId = setInterval(() => {
-			this.#onInterval();
-		}, this.#interval);
-		this.#intervalEnd = Date.now() + this.#interval;
-	}
-	#onInterval() {
-		if (this.#intervalCount === 0 && this.#pending === 0 && this.#intervalId) {
-			clearInterval(this.#intervalId);
-			this.#intervalId = void 0;
-		}
-		this.#intervalCount = this.#carryoverConcurrencyCount ? this.#pending : 0;
-		this.#processQueue();
-	}
-	/**
-	Executes all queued functions until it reaches the limit.
-	*/
-	#processQueue() {
-		while (this.#tryToStartAnother());
-	}
-	get concurrency() {
-		return this.#concurrency;
-	}
-	set concurrency(newConcurrency) {
-		if (!(typeof newConcurrency === "number" && newConcurrency >= 1)) throw new TypeError(`Expected \`concurrency\` to be a number from 1 and up, got \`${newConcurrency}\` (${typeof newConcurrency})`);
-		this.#concurrency = newConcurrency;
-		this.#processQueue();
-	}
-	async #throwOnAbort(signal) {
-		return new Promise((_resolve, reject) => {
-			signal.addEventListener("abort", () => {
-				reject(signal.reason);
-			}, { once: true });
-		});
-	}
-	/**
-	Updates the priority of a promise function by its id, affecting its execution order. Requires a defined concurrency limit to take effect.
-	
-	For example, this can be used to prioritize a promise function to run earlier.
-	
-	```js
-	import PQueue from 'p-queue';
-	
-	const queue = new PQueue({concurrency: 1});
-	
-	queue.add(async () => '🦄', {priority: 1});
-	queue.add(async () => '🦀', {priority: 0, id: '🦀'});
-	queue.add(async () => '🦄', {priority: 1});
-	queue.add(async () => '🦄', {priority: 1});
-	
-	queue.setPriority('🦀', 2);
-	```
-	
-	In this case, the promise function with `id: '🦀'` runs second.
-	
-	You can also deprioritize a promise function to delay its execution:
-	
-	```js
-	import PQueue from 'p-queue';
-	
-	const queue = new PQueue({concurrency: 1});
-	
-	queue.add(async () => '🦄', {priority: 1});
-	queue.add(async () => '🦀', {priority: 1, id: '🦀'});
-	queue.add(async () => '🦄');
-	queue.add(async () => '🦄', {priority: 0});
-	
-	queue.setPriority('🦀', -1);
-	```
-	Here, the promise function with `id: '🦀'` executes last.
-	*/
-	setPriority(id, priority) {
-		this.#queue.setPriority(id, priority);
-	}
-	async add(function_, options = {}) {
-		options.id ??= (this.#idAssigner++).toString();
-		options = {
-			timeout: this.timeout,
-			throwOnTimeout: this.#throwOnTimeout,
-			...options
-		};
-		return new Promise((resolve, reject) => {
-			this.#queue.enqueue(async () => {
-				this.#pending++;
-				try {
-					options.signal?.throwIfAborted();
-					this.#intervalCount++;
-					let operation = function_({ signal: options.signal });
-					if (options.timeout) operation = pTimeout(Promise.resolve(operation), { milliseconds: options.timeout });
-					if (options.signal) operation = Promise.race([operation, this.#throwOnAbort(options.signal)]);
-					const result = await operation;
-					resolve(result);
-					this.emit("completed", result);
-				} catch (error) {
-					if (error instanceof TimeoutError && !options.throwOnTimeout) {
-						resolve();
-						return;
-					}
-					reject(error);
-					this.emit("error", error);
-				} finally {
-					this.#next();
-				}
-			}, options);
-			this.emit("add");
-			this.#tryToStartAnother();
-		});
-	}
-	async addAll(functions, options) {
-		return Promise.all(functions.map(async (function_) => this.add(function_, options)));
-	}
-	/**
-	Start (or resume) executing enqueued tasks within concurrency limit. No need to call this if queue is not paused (via `options.autoStart = false` or by `.pause()` method.)
-	*/
-	start() {
-		if (!this.#isPaused) return this;
-		this.#isPaused = false;
-		this.#processQueue();
-		return this;
-	}
-	/**
-	Put queue execution on hold.
-	*/
-	pause() {
-		this.#isPaused = true;
-	}
-	/**
-	Clear the queue.
-	*/
-	clear() {
-		this.#queue = new this.#queueClass();
-	}
-	/**
-	Can be called multiple times. Useful if you for example add additional items at a later time.
-	
-	@returns A promise that settles when the queue becomes empty.
-	*/
-	async onEmpty() {
-		if (this.#queue.size === 0) return;
-		await this.#onEvent("empty");
-	}
-	/**
-	@returns A promise that settles when the queue size is less than the given limit: `queue.size < limit`.
-	
-	If you want to avoid having the queue grow beyond a certain size you can `await queue.onSizeLessThan()` before adding a new item.
-	
-	Note that this only limits the number of items waiting to start. There could still be up to `concurrency` jobs already running that this call does not include in its calculation.
-	*/
-	async onSizeLessThan(limit) {
-		if (this.#queue.size < limit) return;
-		await this.#onEvent("next", () => this.#queue.size < limit);
-	}
-	/**
-	The difference with `.onEmpty` is that `.onIdle` guarantees that all work from the queue has finished. `.onEmpty` merely signals that the queue is empty, but it could mean that some promises haven't completed yet.
-	
-	@returns A promise that settles when the queue becomes empty, and all promises have completed; `queue.size === 0 && queue.pending === 0`.
-	*/
-	async onIdle() {
-		if (this.#pending === 0 && this.#queue.size === 0) return;
-		await this.#onEvent("idle");
-	}
-	async #onEvent(event, filter) {
-		return new Promise((resolve) => {
-			const listener = () => {
-				if (filter && !filter()) return;
-				this.off(event, listener);
-				resolve();
-			};
-			this.on(event, listener);
-		});
-	}
-	/**
-	Size of the queue, the number of queued items waiting to run.
-	*/
-	get size() {
-		return this.#queue.size;
-	}
-	/**
-	Size of the queue, filtered by the given options.
-	
-	For example, this can be used to find the number of items remaining in the queue with a specific priority level.
-	*/
-	sizeBy(options) {
-		return this.#queue.filter(options).length;
-	}
-	/**
-	Number of running items (no longer in the queue).
-	*/
-	get pending() {
-		return this.#pending;
-	}
-	/**
-	Whether the queue is currently paused.
-	*/
-	get isPaused() {
-		return this.#isPaused;
-	}
-};
-
-//#endregion
-export { PQueue as t };
+import{t as e}from"./eventemitter3.mjs";var t=class extends Error{constructor(e){super(e),this.name=`TimeoutError`}},n=class extends Error{constructor(e){super(),this.name=`AbortError`,this.message=e}};const r=e=>globalThis.DOMException===void 0?new n(e):new DOMException(e),i=e=>{let t=e.reason===void 0?r(`This operation was aborted.`):e.reason;return t instanceof Error?t:r(t)};function a(e,n){let{milliseconds:r,fallback:a,message:o,customTimers:s={setTimeout,clearTimeout}}=n,c,l,u=new Promise((u,d)=>{if(typeof r!=`number`||Math.sign(r)!==1)throw TypeError(`Expected \`milliseconds\` to be a positive number, got \`${r}\``);if(n.signal){let{signal:e}=n;e.aborted&&d(i(e)),l=()=>{d(i(e))},e.addEventListener(`abort`,l,{once:!0})}if(r===1/0){e.then(u,d);return}let f=new t;c=s.setTimeout.call(void 0,()=>{if(a){try{u(a())}catch(e){d(e)}return}typeof e.cancel==`function`&&e.cancel(),o===!1?u():o instanceof Error?d(o):(f.message=o??`Promise timed out after ${r} milliseconds`,d(f))},r),(async()=>{try{u(await e)}catch(e){d(e)}})()}).finally(()=>{u.clear(),l&&n.signal&&n.signal.removeEventListener(`abort`,l)});return u.clear=()=>{s.clearTimeout.call(void 0,c),c=void 0},u}function o(e,t,n){let r=0,i=e.length;for(;i>0;){let a=Math.trunc(i/2),o=r+a;n(e[o],t)<=0?(r=++o,i-=a+1):i=a}return r}var s=class{#e=[];enqueue(e,t){t={priority:0,...t};let n={priority:t.priority,id:t.id,run:e};if(this.size===0||this.#e[this.size-1].priority>=t.priority){this.#e.push(n);return}let r=o(this.#e,n,(e,t)=>t.priority-e.priority);this.#e.splice(r,0,n)}setPriority(e,t){let n=this.#e.findIndex(t=>t.id===e);if(n===-1)throw ReferenceError(`No promise function with the id "${e}" exists in the queue.`);let[r]=this.#e.splice(n,1);this.enqueue(r.run,{priority:t,id:e})}dequeue(){return this.#e.shift()?.run}filter(e){return this.#e.filter(t=>t.priority===e.priority).map(e=>e.run)}get size(){return this.#e.length}},c=class extends e.default{#e;#t;#n=0;#r;#i;#a=0;#o;#s;#c;#l;#u=0;#d;#f;#p;#m=1n;timeout;constructor(e){if(super(),e={carryoverConcurrencyCount:!1,intervalCap:1/0,interval:0,concurrency:1/0,autoStart:!0,queueClass:s,...e},!(typeof e.intervalCap==`number`&&e.intervalCap>=1))throw TypeError(`Expected \`intervalCap\` to be a number from 1 and up, got \`${e.intervalCap?.toString()??``}\` (${typeof e.intervalCap})`);if(e.interval===void 0||!(Number.isFinite(e.interval)&&e.interval>=0))throw TypeError(`Expected \`interval\` to be a finite number >= 0, got \`${e.interval?.toString()??``}\` (${typeof e.interval})`);this.#e=e.carryoverConcurrencyCount,this.#t=e.intervalCap===1/0||e.interval===0,this.#r=e.intervalCap,this.#i=e.interval,this.#c=new e.queueClass,this.#l=e.queueClass,this.concurrency=e.concurrency,this.timeout=e.timeout,this.#p=e.throwOnTimeout===!0,this.#f=e.autoStart===!1}get#h(){return this.#t||this.#n<this.#r}get#g(){return this.#u<this.#d}#_(){this.#u--,this.#b(),this.emit(`next`)}#v(){this.#S(),this.#x(),this.#s=void 0}get#y(){let e=Date.now();if(this.#o===void 0){let t=this.#a-e;if(t<0)this.#n=this.#e?this.#u:0;else return this.#s===void 0&&(this.#s=setTimeout(()=>{this.#v()},t)),!0}return!1}#b(){if(this.#c.size===0)return this.#o&&clearInterval(this.#o),this.#o=void 0,this.emit(`empty`),this.#u===0&&this.emit(`idle`),!1;if(!this.#f){let e=!this.#y;if(this.#h&&this.#g){let t=this.#c.dequeue();return t?(this.emit(`active`),t(),e&&this.#x(),!0):!1}}return!1}#x(){this.#t||this.#o!==void 0||(this.#o=setInterval(()=>{this.#S()},this.#i),this.#a=Date.now()+this.#i)}#S(){this.#n===0&&this.#u===0&&this.#o&&(clearInterval(this.#o),this.#o=void 0),this.#n=this.#e?this.#u:0,this.#C()}#C(){for(;this.#b(););}get concurrency(){return this.#d}set concurrency(e){if(!(typeof e==`number`&&e>=1))throw TypeError(`Expected \`concurrency\` to be a number from 1 and up, got \`${e}\` (${typeof e})`);this.#d=e,this.#C()}async#w(e){return new Promise((t,n)=>{e.addEventListener(`abort`,()=>{n(e.reason)},{once:!0})})}setPriority(e,t){this.#c.setPriority(e,t)}async add(e,n={}){return n.id??=(this.#m++).toString(),n={timeout:this.timeout,throwOnTimeout:this.#p,...n},new Promise((r,i)=>{this.#c.enqueue(async()=>{this.#u++;try{n.signal?.throwIfAborted(),this.#n++;let t=e({signal:n.signal});n.timeout&&(t=a(Promise.resolve(t),{milliseconds:n.timeout})),n.signal&&(t=Promise.race([t,this.#w(n.signal)]));let i=await t;r(i),this.emit(`completed`,i)}catch(e){if(e instanceof t&&!n.throwOnTimeout){r();return}i(e),this.emit(`error`,e)}finally{this.#_()}},n),this.emit(`add`),this.#b()})}async addAll(e,t){return Promise.all(e.map(async e=>this.add(e,t)))}start(){return this.#f?(this.#f=!1,this.#C(),this):this}pause(){this.#f=!0}clear(){this.#c=new this.#l}async onEmpty(){this.#c.size!==0&&await this.#T(`empty`)}async onSizeLessThan(e){this.#c.size<e||await this.#T(`next`,()=>this.#c.size<e)}async onIdle(){this.#u===0&&this.#c.size===0||await this.#T(`idle`)}async#T(e,t){return new Promise(n=>{let r=()=>{t&&!t()||(this.off(e,r),n())};this.on(e,r)})}get size(){return this.#c.size}sizeBy(e){return this.#c.filter(e).length}get pending(){return this.#u}get isPaused(){return this.#f}};export{c as t};