@tanstack/pacer 0.21.1 → 0.23.0

package/dist/async-queuer.js

@@ -1,6 +1,6 @@
 import { parseFunctionOrValue } from "./utils.js";
-import { emitChange, pacerEventClient } from "./event-client.js";
 import { AsyncRetryer } from "./async-retryer.js";
+import { emitChange, pacerEventClient } from "./event-client.js";
 import { Store } from "@tanstack/store";
 
 //#region src/async-queuer.ts
@@ -9,7 +9,7 @@ function getDefaultAsyncQueuerState() {
 		activeItems: [],
 		addItemCount: 0,
 		errorCount: 0,
-		executeCount: 0,
+		executionCount: 0,
 		expirationCount: 0,
 		isEmpty: true,
 		isExecuting: false,
@@ -21,7 +21,7 @@ function getDefaultAsyncQueuerState() {
 		lastResult: null,
 		pendingTick: false,
 		rejectionCount: 0,
-		settledCount: 0,
+		settleCount: 0,
 		size: 0,
 		status: "idle",
 		successCount: 0
@@ -111,255 +111,14 @@ const defaultOptions = {
 * ```
 */
 var AsyncQueuer = class {
-	#timeoutIds;
+	fn;
+	store = new Store(getDefaultAsyncQueuerState());
+	key;
+	options;
+	asyncRetryers = /* @__PURE__ */ new Map();
+	#timeoutIds = /* @__PURE__ */ new Set();
 	constructor(fn, initialOptions = {}) {
 		this.fn = fn;
-		this.store = new Store(getDefaultAsyncQueuerState());
-		this.asyncRetryers = /* @__PURE__ */ new Map();
-		this.#timeoutIds = /* @__PURE__ */ new Set();
-		this.setOptions = (newOptions) => {
-			this.options = {
-				...this.options,
-				...newOptions
-			};
-		};
-		this.#setState = (newState) => {
-			this.store.setState((state) => {
-				const combinedState = {
-					...state,
-					...newState
-				};
-				const { activeItems, items, isRunning } = combinedState;
-				const size = items.length;
-				const isFull = size >= (this.options.maxSize ?? Infinity);
-				const isEmpty = size === 0;
-				const isIdle = isRunning && isEmpty && activeItems.length === 0;
-				const status = isIdle ? "idle" : isRunning ? "running" : "stopped";
-				return {
-					...combinedState,
-					isEmpty,
-					isFull,
-					isIdle,
-					size,
-					status
-				};
-			});
-			emitChange("AsyncQueuer", this);
-		};
-		this.#getWait = () => {
-			return parseFunctionOrValue(this.options.wait ?? 0, this);
-		};
-		this.#getConcurrency = () => {
-			return parseFunctionOrValue(this.options.concurrency ?? 1, this);
-		};
-		this.#tick = () => {
-			if (!this.store.state.isRunning) {
-				this.#setState({ pendingTick: false });
-				return;
-			}
-			this.#setState({ pendingTick: true });
-			this.#checkExpiredItems();
-			const activeItems = this.store.state.activeItems;
-			while (activeItems.length < this.#getConcurrency() && this.store.state.items.length > 0) {
-				const nextItem = this.peekNextItem();
-				if (!nextItem) break;
-				activeItems.push(nextItem);
-				this.#setState({ activeItems });
-				(async () => {
-					await this.execute();
-					const wait = this.#getWait();
-					if (wait > 0) {
-						const timeoutId = setTimeout(() => this.#tick(), wait);
-						this.#timeoutIds.add(timeoutId);
-						return;
-					}
-					this.#tick();
-				})();
-			}
-			this.#setState({ pendingTick: false });
-		};
-		this.addItem = (item, position = this.options.addItemsTo ?? "back", runOnItemsChange = true) => {
-			this.#setState({ addItemCount: this.store.state.addItemCount + 1 });
-			if (this.store.state.items.length >= (this.options.maxSize ?? Infinity)) {
-				this.#setState({ rejectionCount: this.store.state.rejectionCount + 1 });
-				this.options.onReject?.(item, this);
-				return false;
-			}
-			const priority = this.options.getPriority !== defaultOptions.getPriority ? this.options.getPriority(item) : item.priority;
-			const items = this.store.state.items;
-			const itemTimestamps = this.store.state.itemTimestamps;
-			if (priority !== void 0) {
-				const insertIndex = items.findIndex((existing) => {
-					return (this.options.getPriority !== defaultOptions.getPriority ? this.options.getPriority(existing) : existing.priority) < priority;
-				});
-				if (insertIndex === -1) {
-					items.push(item);
-					itemTimestamps.push(Date.now());
-				} else {
-					items.splice(insertIndex, 0, item);
-					itemTimestamps.splice(insertIndex, 0, Date.now());
-				}
-			} else if (position === "front") {
-				items.unshift(item);
-				itemTimestamps.unshift(Date.now());
-			} else {
-				items.push(item);
-				itemTimestamps.push(Date.now());
-			}
-			this.#setState({
-				items,
-				itemTimestamps
-			});
-			if (runOnItemsChange) this.options.onItemsChange?.(this);
-			if (this.store.state.isRunning && !this.store.state.pendingTick) this.#tick();
-			return true;
-		};
-		this.getNextItem = (position = this.options.getItemsFrom ?? "front") => {
-			const { items, itemTimestamps } = this.store.state;
-			let item;
-			if (this.options.getPriority !== defaultOptions.getPriority || position === "front") {
-				item = items[0];
-				if (item !== void 0) this.#setState({
-					items: items.slice(1),
-					itemTimestamps: itemTimestamps.slice(1)
-				});
-			} else {
-				item = items[items.length - 1];
-				if (item !== void 0) this.#setState({
-					items: items.slice(0, -1),
-					itemTimestamps: itemTimestamps.slice(0, -1)
-				});
-			}
-			if (item !== void 0) this.options.onItemsChange?.(this);
-			return item;
-		};
-		this.#getAllItems = () => {
-			const items = this.peekAllItems();
-			this.clear();
-			return items;
-		};
-		this.execute = async (position) => {
-			const item = this.getNextItem(position);
-			if (item !== void 0) {
-				const currentExecuteCount = this.store.state.executeCount + 1;
-				this.#setState({
-					executeCount: currentExecuteCount,
-					isExecuting: true
-				});
-				try {
-					const currentAsyncRetryer = new AsyncRetryer(this.fn, {
-						...this.options.asyncRetryerOptions,
-						key: `${this.key}-retryer-${currentExecuteCount}`
-					});
-					this.asyncRetryers.set(currentExecuteCount, currentAsyncRetryer);
-					const lastResult = await currentAsyncRetryer.execute(item);
-					this.#setState({
-						successCount: this.store.state.successCount + 1,
-						lastResult
-					});
-					this.options.onSuccess?.(lastResult, item, this);
-				} catch (error) {
-					this.#setState({ errorCount: this.store.state.errorCount + 1 });
-					this.options.onError?.(error, item, this);
-					if (this.options.throwOnError) throw error;
-				} finally {
-					this.asyncRetryers.delete(currentExecuteCount);
-					this.#setState({
-						activeItems: this.store.state.activeItems.filter((activeItem) => activeItem !== item),
-						isExecuting: false,
-						settledCount: this.store.state.settledCount + 1
-					});
-					this.options.onSettled?.(item, this);
-				}
-			}
-			return item;
-		};
-		this.flush = async (numberOfItems = this.store.state.items.length, position) => {
-			this.#clearTimeouts();
-			await Promise.all(Array.from({ length: numberOfItems }, () => this.execute(position)));
-		};
-		this.flushAsBatch = async (batchFunction) => {
-			this.#clearTimeouts();
-			await batchFunction(this.#getAllItems());
-		};
-		this.#checkExpiredItems = () => {
-			if ((this.options.expirationDuration ?? Infinity) === Infinity && this.options.getIsExpired === defaultOptions.getIsExpired) return;
-			const now = Date.now();
-			const expiredIndices = [];
-			for (let i = 0; i < this.store.state.items.length; i++) {
-				const timestamp = this.store.state.itemTimestamps[i];
-				if (timestamp === void 0) continue;
-				const item = this.store.state.items[i];
-				if (item === void 0) continue;
-				if (this.options.getIsExpired !== defaultOptions.getIsExpired ? this.options.getIsExpired(item, timestamp) : now - timestamp > (this.options.expirationDuration ?? Infinity)) expiredIndices.push(i);
-			}
-			for (let i = expiredIndices.length - 1; i >= 0; i--) {
-				const index = expiredIndices[i];
-				if (index === void 0) continue;
-				const expiredItem = this.store.state.items[index];
-				if (expiredItem === void 0) continue;
-				const newItems = [...this.store.state.items];
-				const newTimestamps = [...this.store.state.itemTimestamps];
-				newItems.splice(index, 1);
-				newTimestamps.splice(index, 1);
-				this.#setState({
-					items: newItems,
-					itemTimestamps: newTimestamps,
-					expirationCount: this.store.state.expirationCount + 1
-				});
-				this.options.onExpire?.(expiredItem, this);
-			}
-			if (expiredIndices.length > 0) this.options.onItemsChange?.(this);
-		};
-		this.peekNextItem = (position = "front") => {
-			if (position === "front") return this.store.state.items[0];
-			return this.store.state.items[this.store.state.items.length - 1];
-		};
-		this.peekAllItems = () => {
-			return [...this.peekActiveItems(), ...this.peekPendingItems()];
-		};
-		this.peekActiveItems = () => {
-			return [...this.store.state.activeItems];
-		};
-		this.peekPendingItems = () => {
-			return [...this.store.state.items];
-		};
-		this.start = () => {
-			this.#setState({ isRunning: true });
-			if (!this.store.state.pendingTick && this.store.state.items.length > 0) this.#tick();
-		};
-		this.stop = () => {
-			this.#clearTimeouts();
-			this.#setState({
-				isRunning: false,
-				pendingTick: false
-			});
-		};
-		this.#clearTimeouts = () => {
-			this.#timeoutIds.forEach((timeoutId) => clearTimeout(timeoutId));
-			this.#timeoutIds.clear();
-		};
-		this.clear = () => {
-			this.#setState({
-				items: [],
-				itemTimestamps: []
-			});
-			this.options.onItemsChange?.(this);
-		};
-		this.getAbortSignal = (executeCount) => {
-			const count = executeCount ?? this.store.state.executeCount;
-			return this.asyncRetryers.get(count)?.getAbortSignal() ?? null;
-		};
-		this.abort = () => {
-			this.asyncRetryers.forEach((retryer) => retryer.abort());
-			this.asyncRetryers.clear();
-			this.#setState({ isExecuting: false });
-		};
-		this.reset = () => {
-			this.#setState(getDefaultAsyncQueuerState());
-			this.options.onItemsChange?.(this);
-			this.asyncRetryers.forEach((retryer) => retryer.reset());
-		};
 		this.key = initialOptions.key;
 		this.options = {
 			...defaultOptions,
@@ -384,28 +143,395 @@ var AsyncQueuer = class {
 			this.setOptions(e.payload.options);
 		});
 	}
-	#setState;
+	/**
+	* Updates the queuer options. New options are merged with existing options.
+	*/
+	setOptions = (newOptions) => {
+		this.options = {
+			...this.options,
+			...newOptions
+		};
+	};
+	#setState = (newState) => {
+		this.store.setState((state) => {
+			const combinedState = {
+				...state,
+				...newState
+			};
+			const { activeItems, items, isRunning } = combinedState;
+			const size = items.length;
+			const isFull = size >= (this.options.maxSize ?? Infinity);
+			const isEmpty = size === 0;
+			const isIdle = isRunning && isEmpty && activeItems.length === 0;
+			const status = isIdle ? "idle" : isRunning ? "running" : "stopped";
+			return {
+				...combinedState,
+				isEmpty,
+				isFull,
+				isIdle,
+				size,
+				status
+			};
+		});
+		emitChange("AsyncQueuer", this);
+	};
 	/**
 	* Returns the current wait time (in milliseconds) between processing items.
 	* If a function is provided, it is called with the queuer instance.
 	*/
-	#getWait;
+	#getWait = () => {
+		return parseFunctionOrValue(this.options.wait ?? 0, this);
+	};
 	/**
 	* Returns the current concurrency limit for processing items.
 	* If a function is provided, it is called with the queuer instance.
 	*/
-	#getConcurrency;
+	#getConcurrency = () => {
+		return parseFunctionOrValue(this.options.concurrency ?? 1, this);
+	};
 	/**
 	* Processes items in the queue up to the concurrency limit. Internal use only.
 	*/
-	#tick;
-	#getAllItems;
+	#tick = () => {
+		if (!this.store.state.isRunning) {
+			this.#setState({ pendingTick: false });
+			return;
+		}
+		this.#setState({ pendingTick: true });
+		this.#checkExpiredItems();
+		let scheduledAsyncWork = false;
+		const activeItems = [...this.store.state.activeItems];
+		while (activeItems.length < this.#getConcurrency() && this.store.state.items.length > 0) {
+			const nextItem = this.peekNextItem();
+			if (nextItem === void 0) break;
+			activeItems.push(nextItem);
+			this.#setState({ activeItems: [...activeItems] });
+			scheduledAsyncWork = true;
+			(async () => {
+				try {
+					await this.execute();
+				} catch {}
+				const wait = this.#getWait();
+				if (wait > 0) {
+					const timeoutId = setTimeout(() => {
+						this.#timeoutIds.delete(timeoutId);
+						this.#tick();
+					}, wait);
+					this.#timeoutIds.add(timeoutId);
+					return;
+				}
+				this.#tick();
+			})();
+		}
+		if (!scheduledAsyncWork) this.#setState({ pendingTick: false });
+	};
+	/**
+	* Adds an item to the queue. If the queue is full, the item is rejected and onReject is called.
+	* Items can be inserted based on priority or at the front/back depending on configuration.
+	* `undefined` cannot be queued (it is the internal "no item" sentinel) and is always rejected.
+	*
+	* @example
+	* ```ts
+	* queuer.addItem({ value: 'task', priority: 10 });
+	* queuer.addItem('task2', 'front');
+	* ```
+	*/
+	addItem = (item, position = this.options.addItemsTo ?? "back", runOnItemsChange = true) => {
+		this.#setState({ addItemCount: this.store.state.addItemCount + 1 });
+		if (item === void 0) {
+			this.#setState({ rejectionCount: this.store.state.rejectionCount + 1 });
+			this.options.onReject?.(item, this);
+			return false;
+		}
+		if (this.store.state.items.length >= (this.options.maxSize ?? Infinity)) {
+			this.#setState({ rejectionCount: this.store.state.rejectionCount + 1 });
+			this.options.onReject?.(item, this);
+			return false;
+		}
+		const priority = this.options.getPriority !== defaultOptions.getPriority ? this.options.getPriority(item) : item?.priority;
+		const items = this.store.state.items;
+		const itemTimestamps = this.store.state.itemTimestamps;
+		if (priority !== void 0) {
+			const insertIndex = items.findIndex((existing) => {
+				return (this.options.getPriority !== defaultOptions.getPriority ? this.options.getPriority(existing) : existing?.priority) < priority;
+			});
+			if (insertIndex === -1) {
+				items.push(item);
+				itemTimestamps.push(Date.now());
+			} else {
+				items.splice(insertIndex, 0, item);
+				itemTimestamps.splice(insertIndex, 0, Date.now());
+			}
+		} else if (position === "front") {
+			items.unshift(item);
+			itemTimestamps.unshift(Date.now());
+		} else {
+			items.push(item);
+			itemTimestamps.push(Date.now());
+		}
+		this.#setState({
+			items,
+			itemTimestamps
+		});
+		if (runOnItemsChange) this.options.onItemsChange?.(this);
+		if (this.store.state.isRunning && !this.store.state.pendingTick) this.#tick();
+		return true;
+	};
+	/**
+	* Removes and returns the next item from the queue without executing the task function.
+	* Use for manual queue management. Normally, use execute() to process items.
+	*
+	* @example
+	* ```ts
+	* // FIFO
+	* queuer.getNextItem();
+	* // LIFO
+	* queuer.getNextItem('back');
+	* ```
+	*/
+	getNextItem = (position = this.options.getItemsFrom ?? "front") => {
+		const { items, itemTimestamps } = this.store.state;
+		let item;
+		if (this.options.getPriority !== defaultOptions.getPriority || position === "front") {
+			item = items[0];
+			if (item !== void 0) this.#setState({
+				items: items.slice(1),
+				itemTimestamps: itemTimestamps.slice(1)
+			});
+		} else {
+			item = items[items.length - 1];
+			if (item !== void 0) this.#setState({
+				items: items.slice(0, -1),
+				itemTimestamps: itemTimestamps.slice(0, -1)
+			});
+		}
+		if (item !== void 0) this.options.onItemsChange?.(this);
+		return item;
+	};
+	#getAllItems = () => {
+		const items = this.peekAllItems();
+		this.clear();
+		return items;
+	};
+	/**
+	* Removes and returns the next item from the queue and executes the task function with it.
+	*
+	* @example
+	* ```ts
+	* queuer.execute();
+	* // LIFO
+	* queuer.execute('back');
+	* ```
+	*/
+	execute = async (position) => {
+		const item = this.getNextItem(position);
+		if (item !== void 0) {
+			const currentExecutionCount = this.store.state.executionCount + 1;
+			this.#setState({
+				executionCount: currentExecutionCount,
+				isExecuting: true
+			});
+			try {
+				const currentAsyncRetryer = new AsyncRetryer(this.fn, this.options.asyncRetryerOptions);
+				this.asyncRetryers.set(currentExecutionCount, currentAsyncRetryer);
+				const lastResult = await currentAsyncRetryer.execute(item);
+				this.#setState({
+					successCount: this.store.state.successCount + 1,
+					lastResult
+				});
+				this.options.onSuccess?.(lastResult, item, this);
+			} catch (error) {
+				this.#setState({ errorCount: this.store.state.errorCount + 1 });
+				this.options.onError?.(error, item, this);
+				if (this.options.throwOnError) throw error;
+			} finally {
+				this.asyncRetryers.delete(currentExecutionCount);
+				const remainingActiveItems = [...this.store.state.activeItems];
+				const activeItemIndex = remainingActiveItems.indexOf(item);
+				if (activeItemIndex !== -1) remainingActiveItems.splice(activeItemIndex, 1);
+				this.#setState({
+					activeItems: remainingActiveItems,
+					isExecuting: this.asyncRetryers.size > 0,
+					settleCount: this.store.state.settleCount + 1
+				});
+				this.options.onSettled?.(item, this);
+			}
+		}
+		return item;
+	};
+	/**
+	* Processes a specified number of items to execute immediately with no wait time
+	* If no numberOfItems is provided, all items will be processed
+	*/
+	flush = async (numberOfItems = this.store.state.items.length, position) => {
+		this.#clearTimeouts();
+		const results = await Promise.allSettled(Array.from({ length: numberOfItems }, () => this.execute(position)));
+		this.#setState({ pendingTick: false });
+		if (this.store.state.isRunning && this.store.state.items.length > 0) {
+			const wait = this.#getWait();
+			if (wait > 0) {
+				this.#setState({ pendingTick: true });
+				const timeoutId = setTimeout(() => {
+					this.#timeoutIds.delete(timeoutId);
+					this.#tick();
+				}, wait);
+				this.#timeoutIds.add(timeoutId);
+			} else this.#tick();
+		}
+		const failure = results.find((result) => result.status === "rejected");
+		if (failure) throw failure.reason;
+	};
+	/**
+	* Processes all items in the queue as a batch using the provided function as an argument
+	* The queue is cleared after processing
+	*/
+	flushAsBatch = async (batchFunction) => {
+		this.#clearTimeouts();
+		const items = this.#getAllItems();
+		try {
+			await batchFunction(items);
+		} finally {
+			this.#setState({ pendingTick: false });
+			if (this.store.state.isRunning && this.store.state.items.length > 0) this.#tick();
+		}
+	};
 	/**
 	* Checks for expired items in the queue and removes them. Calls onExpire for each expired item.
 	* Internal use only.
 	*/
-	#checkExpiredItems;
-	#clearTimeouts;
+	#checkExpiredItems = () => {
+		if ((this.options.expirationDuration ?? Infinity) === Infinity && this.options.getIsExpired === defaultOptions.getIsExpired) return;
+		const now = Date.now();
+		const expiredIndices = [];
+		for (let i = 0; i < this.store.state.items.length; i++) {
+			const timestamp = this.store.state.itemTimestamps[i];
+			if (timestamp === void 0) continue;
+			const item = this.store.state.items[i];
+			if (item === void 0) continue;
+			if (this.options.getIsExpired !== defaultOptions.getIsExpired ? this.options.getIsExpired(item, timestamp) : now - timestamp > (this.options.expirationDuration ?? Infinity)) expiredIndices.push(i);
+		}
+		for (let i = expiredIndices.length - 1; i >= 0; i--) {
+			const index = expiredIndices[i];
+			if (index === void 0) continue;
+			const expiredItem = this.store.state.items[index];
+			if (expiredItem === void 0) continue;
+			const newItems = [...this.store.state.items];
+			const newTimestamps = [...this.store.state.itemTimestamps];
+			newItems.splice(index, 1);
+			newTimestamps.splice(index, 1);
+			this.#setState({
+				items: newItems,
+				itemTimestamps: newTimestamps,
+				expirationCount: this.store.state.expirationCount + 1
+			});
+			this.options.onExpire?.(expiredItem, this);
+		}
+		if (expiredIndices.length > 0) this.options.onItemsChange?.(this);
+	};
+	/**
+	* Returns the next item in the queue without removing it.
+	*
+	* @example
+	* ```ts
+	* queuer.peekNextItem(); // front
+	* queuer.peekNextItem('back'); // back
+	* ```
+	*/
+	peekNextItem = (position = "front") => {
+		if (position === "front") return this.store.state.items[0];
+		return this.store.state.items[this.store.state.items.length - 1];
+	};
+	/**
+	* Returns a copy of all items in the queue, including active and pending items.
+	*/
+	peekAllItems = () => {
+		return [...this.peekActiveItems(), ...this.peekPendingItems()];
+	};
+	/**
+	* Returns the items currently being processed (active tasks).
+	*/
+	peekActiveItems = () => {
+		return [...this.store.state.activeItems];
+	};
+	/**
+	* Returns the items waiting to be processed (pending tasks).
+	*/
+	peekPendingItems = () => {
+		return [...this.store.state.items];
+	};
+	/**
+	* Starts processing items in the queue. If already running, does nothing.
+	*/
+	start = () => {
+		this.#setState({ isRunning: true });
+		if (!this.store.state.pendingTick && this.store.state.items.length > 0) this.#tick();
+	};
+	/**
+	* Stops processing items in the queue. Does not clear the queue.
+	*/
+	stop = () => {
+		this.#clearTimeouts();
+		this.#setState({
+			isRunning: false,
+			pendingTick: false
+		});
+	};
+	#clearTimeouts = () => {
+		this.#timeoutIds.forEach((timeoutId) => clearTimeout(timeoutId));
+		this.#timeoutIds.clear();
+	};
+	/**
+	* Removes all pending items from the queue.
+	* Does NOT affect active tasks.
+	*/
+	clear = () => {
+		this.#setState({
+			items: [],
+			itemTimestamps: []
+		});
+		this.options.onItemsChange?.(this);
+	};
+	/**
+	* Returns the AbortSignal for a specific execution.
+	* If no executionCount is provided, returns the signal for the most recent execution.
+	* Returns null if no execution is found or not currently executing.
+	*
+	* @param executionCount - Optional specific execution to get signal for
+	* @example
+	* ```typescript
+	* const queuer = new AsyncQueuer(
+	*   async (item: string) => {
+	*     const signal = queuer.getAbortSignal()
+	*     if (signal) {
+	*       const response = await fetch(`/api/process/${item}`, { signal })
+	*       return response.json()
+	*     }
+	*   },
+	*   { concurrency: 2 }
+	* )
+	* ```
+	*/
+	getAbortSignal = (executionCount) => {
+		const count = executionCount ?? this.store.state.executionCount;
+		return this.asyncRetryers.get(count)?.getAbortSignal() ?? null;
+	};
+	/**
+	* Aborts all ongoing executions with the internal abort controllers.
+	* Does NOT clear out the items.
+	*/
+	abort = () => {
+		this.asyncRetryers.forEach((retryer) => retryer.abort());
+		this.asyncRetryers.clear();
+		this.#setState({ isExecuting: false });
+	};
+	/**
+	* Resets the queuer state to its default values
+	*/
+	reset = () => {
+		this.#setState(getDefaultAsyncQueuerState());
+		this.options.onItemsChange?.(this);
+		this.asyncRetryers.forEach((retryer) => retryer.reset());
+	};
 };
 /**
 * Creates a new AsyncQueuer instance and returns a bound addItem function for adding tasks.
@@ -477,5 +603,4 @@ function asyncQueue(fn, initialOptions) {
 }
 
 //#endregion
-export { AsyncQueuer, asyncQueue, asyncQueuerOptions };
-//# sourceMappingURL=async-queuer.js.map
+export { AsyncQueuer, asyncQueue, asyncQueuerOptions };