@alivault/pico 0.14.0 → 0.16.1

package/.output/server/_libs/tanstack__pacer.mjs

@@ -1,1111 +0,0 @@
-import { n as Store } from "./@tanstack/hotkeys+[...].mjs";
-import { t as EventClient } from "./@tanstack/devtools-event-client+[...].mjs";
-//#region node_modules/.pnpm/@tanstack+pacer@0.21.0/node_modules/@tanstack/pacer/dist/utils.js
-function isFunction(value) {
-	return typeof value === "function";
-}
-function parseFunctionOrValue(value, ...args) {
-	return isFunction(value) ? value(...args) : value;
-}
-//#endregion
-//#region node_modules/.pnpm/@tanstack+pacer@0.21.0/node_modules/@tanstack/pacer/dist/event-client.js
-var pacerDevtoolsInstancesByKey = /* @__PURE__ */ new Map();
-function registerPacerDevtoolsInstance(key, instance) {
-	pacerDevtoolsInstancesByKey.set(key, instance);
-}
-function cloneJsonSafe(value) {
-	if (value === void 0) return;
-	try {
-		return JSON.parse(JSON.stringify(value));
-	} catch {
-		return null;
-	}
-}
-function readStoreSnapshot(store) {
-	if (typeof store.get === "function") return store.get();
-	return store.state;
-}
-function toPacerDevtoolsWirePayload(instance) {
-	return {
-		key: instance.key,
-		store: { state: cloneJsonSafe(readStoreSnapshot(instance.store)) },
-		options: cloneJsonSafe(instance.options)
-	};
-}
-var PacerEventClient = class extends EventClient {
-	constructor(props) {
-		super({
-			pluginId: "pacer",
-			debug: props?.debug,
-			reconnectEveryMs: 1e3
-		});
-	}
-};
-var emitChange = (event, instance) => {
-	const key = instance.key;
-	if (!key) return;
-	registerPacerDevtoolsInstance(key, instance);
-	pacerEventClient.emit(event, toPacerDevtoolsWirePayload({
-		...instance,
-		key
-	}));
-};
-var pacerEventClient = new PacerEventClient();
-//#endregion
-//#region node_modules/.pnpm/@tanstack+pacer@0.21.0/node_modules/@tanstack/pacer/dist/async-retryer.js
-/**
-* Creates the default initial state for an AsyncRetryer instance
-* @returns The default state with all values reset to initial values
-*/
-function getDefaultAsyncRetryerState() {
-	return {
-		currentAttempt: 0,
-		executionCount: 0,
-		isExecuting: false,
-		lastError: void 0,
-		lastExecutionTime: 0,
-		lastResult: void 0,
-		status: "idle",
-		totalExecutionTime: 0
-	};
-}
-var defaultOptions$4 = {
-	backoff: "exponential",
-	baseWait: 1e3,
-	maxWait: Infinity,
-	enabled: true,
-	jitter: 0,
-	maxAttempts: 3,
-	maxExecutionTime: Infinity,
-	maxTotalExecutionTime: Infinity,
-	throwOnError: "last"
-};
-/**
-* Provides robust retry functionality for asynchronous functions, supporting configurable backoff strategies,
-* attempt limits, timeout controls, and detailed state management. The AsyncRetryer class is designed to help you reliably
-* execute async operations that may fail intermittently, such as network requests or database operations,
-* by automatically retrying them according to your chosen policy.
-*
-* ## Retrying Concepts
-*
-* - **Retrying**: Automatically re-executes a failed async function up to a specified number of attempts.
-*   Useful for handling transient errors (e.g., network flakiness, rate limits, temporary server issues).
-* - **Backoff Strategies**: Controls the delay between retry attempts (default: `'exponential'`):
-*   - `'exponential'`: Wait time doubles with each attempt (1s, 2s, 4s, ...) - **DEFAULT**
-*   - `'linear'`: Wait time increases linearly (1s, 2s, 3s, ...)
-*   - `'fixed'`: Waits a constant amount of time (`baseWait`) between each attempt
-* - **Jitter**: Adds randomness to retry delays to prevent thundering herd problems (default: `0`).
-*   Set to a value between 0-1 to apply that percentage of random variation to each delay.
-* - **Max Wait**: Caps the maximum wait time between retries (default: `Infinity`).
-*   Useful for preventing exponential backoff from growing too large (e.g., cap at 30s even if exponential would be 64s).
-* - **Timeout Controls**: Set limits on execution time to prevent hanging operations:
-*   - `maxExecutionTime`: Maximum time for a single function call (default: `Infinity`)
-*   - `maxTotalExecutionTime`: Maximum time for the entire retry operation (default: `Infinity`)
-* - **Abort & Cancellation**: Supports cancellation via an internal `AbortController`. Call `abort()` to stop retries.
-*   Use `getAbortSignal()` to make your async function actually cancellable (e.g., with fetch requests).
-*
-* ## State Management
-*
-* Uses TanStack Store for fine-grained reactivity. State can be accessed via the `store.state` property.
-*
-* Available state properties:
-* - `currentAttempt`: The current retry attempt number (0 when not executing)
-* - `executionCount`: Total number of completed executions (successful or failed)
-* - `isExecuting`: Whether the retryer is currently executing the function
-* - `lastError`: The most recent error encountered during execution
-* - `lastExecutionTime`: Timestamp of the last execution completion in milliseconds
-* - `lastResult`: The result from the most recent successful execution
-* - `status`: Current execution status ('disabled' | 'idle' | 'executing' | 'retrying')
-* - `totalExecutionTime`: Total time spent executing (including retries) in milliseconds
-*
-* ## Error Handling
-*
-* The `throwOnError` option controls when errors are thrown (default: `'last'`):
-* - `'last'`: Only throws the final error after all retries are exhausted - **DEFAULT**
-* - `true`: Throws every error immediately (disables retrying)
-* - `false`: Never throws errors, returns `undefined` instead
-*
-* Callbacks for lifecycle management:
-* - `onAbort`: Called when execution is aborted (manually or due to timeouts)
-* - `onError`: Called for every error (including during retries)
-* - `onLastError`: Called only for the final error after all retries fail
-* - `onRetry`: Called before each retry attempt
-* - `onSettled`: Called after execution completes (success or failure) of each attempt
-* - `onSuccess`: Called when execution succeeds
-* - `onExecutionTimeout`: Called when a single execution attempt times out
-* - `onTotalExecutionTimeout`: Called when the total execution time times out
-*
-* ## Usage
-*
-* - Use for async operations that may fail transiently and benefit from retrying.
-* - Configure `maxAttempts`, `backoff`, `baseWait`, `maxWait`, and `jitter` to control retry behavior.
-* - Set `maxExecutionTime` and `maxTotalExecutionTime` to prevent hanging operations.
-* - Use `onAbort`, `onError`, `onLastError`, `onRetry`, `onSettled`, `onSuccess`, `onExecutionTimeout`, and `onTotalExecutionTimeout` for custom side effects.
-* - Call `abort()` to cancel ongoing execution and pending retries.
-* - Call `reset()` to reset state and cancel execution.
-* - Use `getAbortSignal()` to make your async function cancellable.
-* - Use dynamic options (functions) for `maxAttempts`, `baseWait`, and `enabled` based on retryer state.
-*
-* **Important:** This class is designed for single-use execution. Calling `execute()` multiple times
-* on the same instance will abort previous executions. For multiple calls, create a new instance
-* each time.
-*
-* @example
-* ```typescript
-* // Retry a fetch operation up to 5 times with exponential backoff, jitter, and timeouts
-* const retryer = new AsyncRetryer(async (url: string) => {
-*   const signal = retryer.getAbortSignal()
-*   return await fetch(url, { signal })
-* }, {
-*   maxAttempts: 5,
-*   backoff: 'exponential',
-*   baseWait: 1000,
-*   jitter: 0.1, // Add 10% random variation to prevent thundering herd
-*   maxExecutionTime: 5000, // Abort individual calls after 5 seconds
-*   maxTotalExecutionTime: 30000, // Abort entire operation after 30 seconds
-*   onRetry: (attempt, error) => console.log(`Retry attempt ${attempt} after error:`, error),
-*   onSuccess: (result) => console.log('Success:', result),
-*   onError: (error) => console.error('Error:', error),
-*   onLastError: (error) => console.error('All retries failed:', error),
-* })
-*
-* const result = await retryer.execute('/api/data')
-* ```
-*
-* @template TFn The async function type to be retried.
-*/
-var AsyncRetryer = class {
-	#abortController;
-	/**
-	* Creates a new AsyncRetryer instance
-	* @param fn The async function to retry
-	* @param initialOptions Configuration options for the retryer
-	*/
-	constructor(fn, initialOptions = {}) {
-		this.fn = fn;
-		this.store = new Store(getDefaultAsyncRetryerState());
-		this.#abortController = null;
-		this.setOptions = (newOptions) => {
-			this.options = {
-				...this.options,
-				...newOptions
-			};
-		};
-		this.#setState = (newState) => {
-			this.store.setState((state) => {
-				const combinedState = {
-					...state,
-					...newState
-				};
-				const { isExecuting, currentAttempt } = combinedState;
-				return {
-					...combinedState,
-					status: !this.#getEnabled() ? "disabled" : isExecuting && currentAttempt === 1 ? "executing" : isExecuting && currentAttempt > 1 ? "retrying" : "idle"
-				};
-			});
-			emitChange("AsyncRetryer", this);
-		};
-		this.#getEnabled = () => {
-			return !!parseFunctionOrValue(this.options.enabled, this);
-		};
-		this.#getMaxAttempts = () => {
-			return parseFunctionOrValue(this.options.maxAttempts, this);
-		};
-		this.#getBaseWait = () => {
-			return parseFunctionOrValue(this.options.baseWait, this);
-		};
-		this.#getMaxWait = () => {
-			return parseFunctionOrValue(this.options.maxWait, this);
-		};
-		this.#calculateJitter = (waitTime) => {
-			const jitterAmount = this.options.jitter;
-			if (jitterAmount <= 0) return 0;
-			try {
-				const crypto = typeof globalThis !== "undefined" ? globalThis.crypto : void 0;
-				if (crypto?.getRandomValues) {
-					const array = new Uint32Array(1);
-					crypto.getRandomValues(array);
-					const randomFactor = array[0] / 4294967295 * 2 - 1;
-					return Math.floor(waitTime * jitterAmount * randomFactor);
-				}
-			} catch {}
-			return 0;
-		};
-		this.#calculateWait = (attempt) => {
-			const baseWait = this.#getBaseWait();
-			let waitTime;
-			switch (this.options.backoff) {
-				case "linear":
-					waitTime = baseWait * attempt;
-					break;
-				case "exponential":
-					waitTime = baseWait * Math.pow(2, attempt - 1);
-					break;
-				default:
-					waitTime = baseWait;
-					break;
-			}
-			waitTime = Math.min(waitTime, this.#getMaxWait());
-			const jitter = this.#calculateJitter(waitTime);
-			return Math.max(0, waitTime + jitter);
-		};
-		this.execute = async (...args) => {
-			if (!this.#getEnabled()) return;
-			this.abort("new-execution");
-			const startTime = Date.now();
-			let lastError;
-			let result;
-			this.#abortController = new AbortController();
-			const signal = this.#abortController.signal;
-			this.#setState({
-				isExecuting: true,
-				currentAttempt: 0,
-				lastError: void 0
-			});
-			let totalTimeoutId;
-			if (this.options.maxTotalExecutionTime !== Infinity) totalTimeoutId = setTimeout(() => {
-				this.options.onTotalExecutionTimeout?.(this);
-				this.abort("total-timeout");
-			}, this.options.maxTotalExecutionTime);
-			let isLastAttempt = false;
-			for (let attempt = 1; attempt <= this.#getMaxAttempts(); attempt++) {
-				isLastAttempt = attempt === this.#getMaxAttempts();
-				this.#setState({ currentAttempt: attempt });
-				try {
-					if (signal.aborted) return;
-					const currentTotalTime = Date.now() - startTime;
-					if (this.options.maxTotalExecutionTime !== Infinity && currentTotalTime >= this.options.maxTotalExecutionTime) {
-						this.options.onTotalExecutionTimeout?.(this);
-						this.abort("total-timeout");
-						return;
-					}
-					if (this.options.maxExecutionTime === Infinity) result = await this.fn(...args);
-					else result = await Promise.race([this.fn(...args), new Promise((_, reject) => {
-						const timeout = setTimeout(() => {
-							this.options.onExecutionTimeout?.(this);
-							this.abort("execution-timeout");
-							reject(/* @__PURE__ */ new Error(`Execution timeout: ${this.options.maxExecutionTime}ms exceeded`));
-						}, this.options.maxExecutionTime);
-						signal.addEventListener("abort", () => {
-							clearTimeout(timeout);
-							reject(/* @__PURE__ */ new Error("Aborted"));
-						}, { once: true });
-					})]);
-					if (signal.aborted) return;
-					const totalTime = Date.now() - startTime;
-					this.#setState({
-						executionCount: this.store.state.executionCount + 1,
-						isExecuting: false,
-						lastExecutionTime: Date.now(),
-						totalExecutionTime: totalTime,
-						currentAttempt: 0,
-						lastResult: result
-					});
-					this.options.onSuccess?.(result, args, this);
-					return result;
-				} catch (error) {
-					if (error && typeof error === "object" && "name" in error && error.name === "AbortError") return;
-					lastError = error instanceof Error ? error : new Error(String(error));
-					this.#setState({ lastError });
-					this.options.onError?.(lastError, args, this);
-					if (attempt < this.#getMaxAttempts()) {
-						this.options.onRetry?.(attempt, lastError, this);
-						const wait = this.#calculateWait(attempt);
-						if (wait > 0) {
-							this.#setState({
-								isExecuting: true,
-								currentAttempt: attempt + 1
-							});
-							await new Promise((resolve) => {
-								const timeout = setTimeout(() => {
-									signal.removeEventListener("abort", onAbort);
-									resolve();
-								}, wait);
-								const onAbort = () => {
-									clearTimeout(timeout);
-									signal.removeEventListener("abort", onAbort);
-									resolve();
-								};
-								signal.addEventListener("abort", onAbort);
-							});
-							if (signal.aborted) return;
-						}
-					}
-				} finally {
-					this.options.onSettled?.(args, this);
-				}
-			}
-			if (totalTimeoutId) clearTimeout(totalTimeoutId);
-			this.#setState({ isExecuting: false });
-			this.options.onLastError?.(lastError, this);
-			this.options.onSettled?.(args, this);
-			if (this.options.throwOnError === "last" && isLastAttempt || this.options.throwOnError === true) throw lastError;
-		};
-		this.getAbortSignal = () => {
-			return this.#abortController?.signal ?? null;
-		};
-		this.abort = (reason = "manual") => {
-			if (this.#abortController) {
-				this.#abortController.abort();
-				this.#abortController = null;
-				this.#setState({ isExecuting: false });
-				this.options.onAbort?.(reason, this);
-			}
-		};
-		this.reset = () => {
-			this.#setState(getDefaultAsyncRetryerState());
-		};
-		this.key = initialOptions.key;
-		this.options = {
-			...defaultOptions$4,
-			...initialOptions,
-			throwOnError: initialOptions.throwOnError ?? (initialOptions.onError ? false : defaultOptions$4.throwOnError)
-		};
-		this.#setState(this.options.initialState ?? {});
-		if (this.key) pacerEventClient.on("d-AsyncRetryer", (event) => {
-			if (event.payload.key !== this.key) return;
-			this.#setState(event.payload.store.state);
-			this.setOptions(event.payload.options);
-		});
-	}
-	#setState;
-	#getEnabled;
-	#getMaxAttempts;
-	#getBaseWait;
-	#getMaxWait;
-	#calculateJitter;
-	#calculateWait;
-};
-//#endregion
-//#region node_modules/.pnpm/@tanstack+pacer@0.21.0/node_modules/@tanstack/pacer/dist/async-debouncer.js
-function getDefaultAsyncDebouncerState() {
-	return {
-		canLeadingExecute: true,
-		errorCount: 0,
-		isExecuting: false,
-		isPending: false,
-		lastArgs: void 0,
-		lastResult: void 0,
-		maybeExecuteCount: 0,
-		settleCount: 0,
-		status: "idle",
-		successCount: 0
-	};
-}
-var defaultOptions$3 = {
-	asyncRetryerOptions: { maxAttempts: 1 },
-	enabled: true,
-	leading: false,
-	trailing: true,
-	wait: 0
-};
-/**
-* A class that creates an async debounced function.
-*
-* Async vs Sync Versions:
-* The async version provides advanced features over the sync Debouncer:
-* - Returns promises that can be awaited for debounced function results
-* - Built-in retry support via AsyncRetryer integration
-* - Abort support to cancel in-flight executions
-* - Cancel support to prevent pending executions from starting
-* - Comprehensive error handling with onError callbacks and throwOnError control
-* - Detailed execution tracking (success/error/settle counts)
-*
-* The sync Debouncer is lighter weight and simpler when you don't need async features,
-* return values, or execution control.
-*
-* What is Debouncing?
-* Debouncing ensures that a function is only executed after a specified delay has passed since its last invocation.
-* Each new invocation resets the delay timer. This is useful for handling frequent events like window resizing
-* or input changes where you only want to execute the handler after the events have stopped occurring.
-*
-* Unlike throttling which allows execution at regular intervals, debouncing prevents any execution until
-* the function stops being called for the specified delay period.
-*
-* Error Handling:
-* - If an `onError` handler is provided, it will be called with the error and debouncer instance
-* - If `throwOnError` is true (default when no onError handler is provided), the error will be thrown
-* - If `throwOnError` is false (default when onError handler is provided), the error will be swallowed
-* - Both onError and throwOnError can be used together - the handler will be called before any error is thrown
-* - The error state can be checked using the underlying store
-*
-* State Management:
-* - The debouncer uses a reactive store for state management
-* - Use `initialState` to provide initial state values when creating the async debouncer
-* - The state includes canLeadingExecute, error count, execution status, and success/settle counts
-* - State can be accessed via the `store` property and its `state` getter
-* - The store is reactive and will notify subscribers of state changes
-*
-* @example
-* ```ts
-* const asyncDebouncer = new AsyncDebouncer(async (value: string) => {
-*   const results = await searchAPI(value);
-*   return results; // Return value is preserved
-* }, {
-*   wait: 500,
-*   onError: (error) => {
-*     console.error('Search failed:', error);
-*   }
-* });
-*
-* // Called on each keystroke but only executes after 500ms of no typing
-* // Returns the API response directly
-* const results = await asyncDebouncer.maybeExecute(inputElement.value);
-* ```
-*/
-var AsyncDebouncer = class {
-	#timeoutId;
-	#resolvePreviousPromise;
-	constructor(fn, initialOptions) {
-		this.fn = fn;
-		this.store = new Store(getDefaultAsyncDebouncerState());
-		this.asyncRetryers = /* @__PURE__ */ new Map();
-		this.#timeoutId = null;
-		this.#resolvePreviousPromise = null;
-		this.setOptions = (newOptions) => {
-			this.options = {
-				...this.options,
-				...newOptions
-			};
-			if (!this.#getEnabled()) this.cancel();
-		};
-		this.#setState = (newState) => {
-			this.store.setState((state) => {
-				const combinedState = {
-					...state,
-					...newState
-				};
-				const { isPending, isExecuting, settleCount } = combinedState;
-				return {
-					...combinedState,
-					status: !this.#getEnabled() ? "disabled" : isPending ? "pending" : isExecuting ? "executing" : settleCount > 0 ? "settled" : "idle"
-				};
-			});
-			emitChange("AsyncDebouncer", this);
-		};
-		this.#getEnabled = () => {
-			return !!parseFunctionOrValue(this.options.enabled, this);
-		};
-		this.#getWait = () => {
-			return parseFunctionOrValue(this.options.wait, this);
-		};
-		this.maybeExecute = async (...args) => {
-			if (!this.#getEnabled()) return void 0;
-			this.#cancelPendingExecution();
-			this.#setState({
-				lastArgs: args,
-				maybeExecuteCount: this.store.state.maybeExecuteCount + 1
-			});
-			if (this.options.leading && this.store.state.canLeadingExecute) {
-				this.#setState({ canLeadingExecute: false });
-				await this.#execute(...args);
-				return this.store.state.lastResult;
-			}
-			if (this.options.trailing && this.#getEnabled()) this.#setState({ isPending: true });
-			return new Promise((resolve, reject) => {
-				this.#resolvePreviousPromise = resolve;
-				this.#timeoutId = setTimeout(async () => {
-					if (this.options.trailing && this.store.state.lastArgs) try {
-						await this.#execute(...this.store.state.lastArgs);
-					} catch (error) {
-						reject(error);
-					}
-					this.#setState({ canLeadingExecute: true });
-					this.#resolvePreviousPromise = null;
-					resolve(this.store.state.lastResult);
-				}, this.#getWait());
-			});
-		};
-		this.#execute = async (...args) => {
-			if (!this.#getEnabled()) return void 0;
-			const currentMaybeExecuteCount = this.store.state.maybeExecuteCount + 1;
-			try {
-				this.#setState({ isExecuting: true });
-				const currentAsyncRetryer = new AsyncRetryer(this.fn, {
-					...this.options.asyncRetryerOptions,
-					key: `${this.key}-retryer-${currentMaybeExecuteCount}`
-				});
-				this.asyncRetryers.set(currentMaybeExecuteCount, currentAsyncRetryer);
-				const result = await currentAsyncRetryer.execute(...args);
-				this.#setState({
-					lastResult: result,
-					successCount: this.store.state.successCount + 1
-				});
-				this.options.onSuccess?.(result, args, this);
-			} catch (error) {
-				this.#setState({ errorCount: this.store.state.errorCount + 1 });
-				this.options.onError?.(error, args, this);
-				if (this.options.throwOnError) throw error;
-			} finally {
-				this.asyncRetryers.delete(currentMaybeExecuteCount);
-				this.#setState({
-					isExecuting: false,
-					isPending: false,
-					lastArgs: void 0,
-					settleCount: this.store.state.settleCount + 1
-				});
-				this.options.onSettled?.(args, this);
-			}
-			return this.store.state.lastResult;
-		};
-		this.flush = async () => {
-			if (this.store.state.isPending && this.store.state.lastArgs) {
-				const { lastArgs } = this.store.state;
-				this.#cancelPendingExecution();
-				return await this.#execute(...lastArgs);
-			}
-		};
-		this.#resolvePreviousPromiseInternal = () => {
-			if (this.#resolvePreviousPromise) {
-				this.#resolvePreviousPromise(this.store.state.lastResult);
-				this.#resolvePreviousPromise = null;
-			}
-		};
-		this.#clearTimeout = () => {
-			if (this.#timeoutId) {
-				clearTimeout(this.#timeoutId);
-				this.#timeoutId = null;
-			}
-		};
-		this.#cancelPendingExecution = () => {
-			this.#clearTimeout();
-			this.#resolvePreviousPromiseInternal();
-			this.#setState({
-				isPending: false,
-				lastArgs: void 0
-			});
-		};
-		this.getAbortSignal = (maybeExecuteCount) => {
-			const count = maybeExecuteCount ?? this.store.state.maybeExecuteCount;
-			return this.asyncRetryers.get(count)?.getAbortSignal() ?? null;
-		};
-		this.abort = () => {
-			this.asyncRetryers.forEach((retryer) => retryer.abort());
-			this.asyncRetryers.clear();
-			this.#setState({ isExecuting: false });
-		};
-		this.cancel = () => {
-			this.#cancelPendingExecution();
-			this.#setState({ canLeadingExecute: true });
-		};
-		this.reset = () => {
-			this.#setState(getDefaultAsyncDebouncerState());
-			this.asyncRetryers.forEach((retryer) => retryer.reset());
-		};
-		this.key = initialOptions.key;
-		this.options = {
-			...defaultOptions$3,
-			...initialOptions,
-			throwOnError: initialOptions.throwOnError ?? !initialOptions.onError
-		};
-		this.#setState(this.options.initialState ?? {});
-		if (this.key) pacerEventClient.on("d-AsyncDebouncer", (event) => {
-			if (event.payload.key !== this.key) return;
-			this.#setState(event.payload.store.state);
-			this.setOptions(event.payload.options);
-		});
-	}
-	#setState;
-	/**
-	* Returns the current debouncer enabled state
-	*/
-	#getEnabled;
-	/**
-	* Returns the current debouncer wait state
-	*/
-	#getWait;
-	#execute;
-	#resolvePreviousPromiseInternal;
-	#clearTimeout;
-	/**
-	* Internal cancel without resetting the leading execute state
-	*/
-	#cancelPendingExecution;
-};
-//#endregion
-//#region node_modules/.pnpm/@tanstack+pacer@0.21.0/node_modules/@tanstack/pacer/dist/batcher.js
-function getDefaultBatcherState() {
-	return {
-		executionCount: 0,
-		isEmpty: true,
-		isPending: false,
-		totalItemsProcessed: 0,
-		items: [],
-		size: 0,
-		status: "idle"
-	};
-}
-var defaultOptions$2 = {
-	getShouldExecute: () => false,
-	maxSize: Infinity,
-	started: true,
-	wait: Infinity
-};
-/**
-* A class that collects items and processes them in batches.
-*
-* Batching is a technique for grouping multiple operations together to be processed as a single unit.
-* This synchronous version is lighter weight and often all you need - upgrade to AsyncBatcher when you need promises, retry support, abort/cancel capabilities, or advanced error handling.
-*
-* The Batcher provides a flexible way to implement batching with configurable:
-* - Maximum batch size (number of items per batch)
-* - Time-based batching (process after X milliseconds)
-* - Custom batch processing logic via getShouldExecute
-* - Event callbacks for monitoring batch operations
-*
-* State Management:
-* - Uses TanStack Store for reactive state management
-* - Use `initialState` to provide initial state values when creating the batcher
-* - Use `onExecute` callback to react to batch execution and implement custom logic
-* - Use `onItemsChange` callback to react to items being added or removed from the batcher
-* - The state includes batch execution count, total items processed, items, and running status
-* - State can be accessed via `batcher.store.state` when using the class directly
-* - When using framework adapters (React/Solid), state is accessed from `batcher.state`
-*
-* @example
-* ```ts
-* const batcher = new Batcher<number>(
-*   (items) => console.log('Processing batch:', items),
-*   {
-*     maxSize: 5,
-*     wait: 2000,
-*     onExecute: (batch, batcher) => console.log('Batch executed:', batch)
-*   }
-* );
-*
-* batcher.addItem(1);
-* batcher.addItem(2);
-* // After 2 seconds or when 5 items are added, whichever comes first,
-* // the batch will be processed
-* // batcher.flush() // manually trigger a batch
-* ```
-*/
-var Batcher = class {
-	#timeoutId;
-	constructor(fn, initialOptions) {
-		this.fn = fn;
-		this.store = new Store(getDefaultBatcherState());
-		this.#timeoutId = null;
-		this.setOptions = (newOptions) => {
-			this.options = {
-				...this.options,
-				...newOptions
-			};
-		};
-		this.#setState = (newState) => {
-			this.store.setState((state) => {
-				const combinedState = {
-					...state,
-					...newState
-				};
-				const { isPending, items } = combinedState;
-				const size = items.length;
-				const isEmpty = size === 0;
-				return {
-					...combinedState,
-					isEmpty,
-					size,
-					status: isPending ? "pending" : "idle"
-				};
-			});
-			emitChange("Batcher", this);
-		};
-		this.#getWait = () => {
-			return parseFunctionOrValue(this.options.wait, this);
-		};
-		this.addItem = (item) => {
-			this.#setState({
-				items: [...this.store.state.items, item],
-				isPending: this.options.wait !== Infinity
-			});
-			this.options.onItemsChange?.(this);
-			if (this.store.state.items.length >= this.options.maxSize || this.options.getShouldExecute(this.store.state.items, this)) this.#execute();
-			else if (this.options.wait !== Infinity) {
-				this.#clearTimeout();
-				this.#timeoutId = setTimeout(() => this.#execute(), this.#getWait());
-			}
-		};
-		this.#execute = () => {
-			if (this.store.state.items.length === 0) return;
-			const batch = this.peekAllItems();
-			this.clear();
-			this.options.onItemsChange?.(this);
-			this.fn(batch);
-			this.#setState({
-				executionCount: this.store.state.executionCount + 1,
-				totalItemsProcessed: this.store.state.totalItemsProcessed + batch.length
-			});
-			this.options.onExecute?.(batch, this);
-		};
-		this.flush = () => {
-			this.#clearTimeout();
-			this.#execute();
-		};
-		this.peekAllItems = () => {
-			return [...this.store.state.items];
-		};
-		this.#clearTimeout = () => {
-			if (this.#timeoutId) {
-				clearTimeout(this.#timeoutId);
-				this.#timeoutId = null;
-			}
-		};
-		this.clear = () => {
-			this.#setState({
-				items: [],
-				isPending: false
-			});
-		};
-		this.cancel = () => {
-			this.#clearTimeout();
-			this.#setState({ isPending: false });
-		};
-		this.reset = () => {
-			this.#setState(getDefaultBatcherState());
-			this.options.onItemsChange?.(this);
-		};
-		this.key = initialOptions.key;
-		this.options = {
-			...defaultOptions$2,
-			...initialOptions
-		};
-		this.#setState(this.options.initialState ?? {});
-		if (this.key) pacerEventClient.on("d-Batcher", (event) => {
-			if (event.payload.key !== this.key) return;
-			this.#setState(event.payload.store.state);
-			this.setOptions(event.payload.options);
-		});
-	}
-	#setState;
-	#getWait;
-	/**
-	* Processes the current batch of items.
-	* This method will automatically be triggered if the batcher is running and any of these conditions are met:
-	* - The number of items reaches batchSize
-	* - The wait duration has elapsed
-	* - The getShouldExecute function returns true upon adding an item
-	*
-	* You can also call this method manually to process the current batch at any time.
-	*/
-	#execute;
-	#clearTimeout;
-};
-//#endregion
-//#region node_modules/.pnpm/@tanstack+pacer@0.21.0/node_modules/@tanstack/pacer/dist/debouncer.js
-function getDefaultDebouncerState() {
-	return {
-		canLeadingExecute: true,
-		executionCount: 0,
-		isPending: false,
-		lastArgs: void 0,
-		status: "idle",
-		maybeExecuteCount: 0
-	};
-}
-var defaultOptions$1 = {
-	enabled: true,
-	leading: false,
-	trailing: true,
-	wait: 0
-};
-/**
-* A class that creates a debounced function.
-*
-* Debouncing ensures that a function is only executed after a certain amount of time has passed
-* since its last invocation. This is useful for handling frequent events like window resizing,
-* scroll events, or input changes where you want to limit the rate of execution.
-* This synchronous version is lighter weight and often all you need - upgrade to AsyncDebouncer when you need promises, retry support, abort/cancel capabilities, or advanced error handling.
-*
-* The debounced function can be configured to execute either at the start of the delay period
-* (leading edge) or at the end (trailing edge, default). Each new call during the wait period
-* will reset the timer.
-*
-* State Management:
-* - Uses TanStack Store for reactive state management
-* - Use `initialState` to provide initial state values when creating the debouncer
-* - Use `onExecute` callback to react to function execution and implement custom logic
-* - The state includes canLeadingExecute, execution count, and isPending status
-* - State can be accessed via `debouncer.store.state` when using the class directly
-* - When using framework adapters (React/Solid), state is accessed from `debouncer.state`
-*
-* @example
-* ```ts
-* const debouncer = new Debouncer((value: string) => {
-*   saveToDatabase(value);
-* }, { wait: 500 });
-*
-* // Will only save after 500ms of no new input
-* inputElement.addEventListener('input', () => {
-*   debouncer.maybeExecute(inputElement.value);
-* });
-* ```
-*/
-var Debouncer = class {
-	#timeoutId;
-	constructor(fn, initialOptions) {
-		this.fn = fn;
-		this.store = new Store(getDefaultDebouncerState());
-		this.setOptions = (newOptions) => {
-			this.options = {
-				...this.options,
-				...newOptions
-			};
-			if (!this.#getEnabled()) this.cancel();
-		};
-		this.#setState = (newState) => {
-			this.store.setState((state) => {
-				const combinedState = {
-					...state,
-					...newState
-				};
-				const { isPending } = combinedState;
-				return {
-					...combinedState,
-					status: !this.#getEnabled() ? "disabled" : isPending ? "pending" : "idle"
-				};
-			});
-			emitChange("Debouncer", this);
-		};
-		this.#getEnabled = () => {
-			return !!parseFunctionOrValue(this.options.enabled, this);
-		};
-		this.#getWait = () => {
-			return parseFunctionOrValue(this.options.wait, this);
-		};
-		this.maybeExecute = (...args) => {
-			if (!this.#getEnabled()) return void 0;
-			this.#setState({ maybeExecuteCount: this.store.state.maybeExecuteCount + 1 });
-			let _didLeadingExecute = false;
-			if (this.options.leading && this.store.state.canLeadingExecute) {
-				this.#setState({ canLeadingExecute: false });
-				_didLeadingExecute = true;
-				this.#execute(...args);
-			}
-			if (this.options.trailing) this.#setState({
-				isPending: true,
-				lastArgs: args
-			});
-			if (this.#timeoutId) clearTimeout(this.#timeoutId);
-			this.#timeoutId = setTimeout(() => {
-				this.#setState({ canLeadingExecute: true });
-				if (this.options.trailing && !_didLeadingExecute) this.#execute(...args);
-			}, this.#getWait());
-		};
-		this.#execute = (...args) => {
-			if (!this.#getEnabled()) return void 0;
-			this.fn(...args);
-			this.#setState({
-				executionCount: this.store.state.executionCount + 1,
-				isPending: false,
-				lastArgs: void 0
-			});
-			this.options.onExecute?.(args, this);
-		};
-		this.flush = () => {
-			if (this.store.state.isPending && this.store.state.lastArgs) {
-				this.#clearTimeout();
-				this.#execute(...this.store.state.lastArgs);
-			}
-		};
-		this.#clearTimeout = () => {
-			if (this.#timeoutId) {
-				clearTimeout(this.#timeoutId);
-				this.#timeoutId = void 0;
-			}
-		};
-		this.cancel = () => {
-			this.#clearTimeout();
-			this.#setState({
-				canLeadingExecute: true,
-				isPending: false
-			});
-		};
-		this.reset = () => {
-			this.#setState(getDefaultDebouncerState());
-		};
-		this.key = initialOptions.key;
-		this.options = {
-			...defaultOptions$1,
-			...initialOptions
-		};
-		this.#setState(this.options.initialState ?? {});
-		if (this.key) pacerEventClient.on("d-Debouncer", (event) => {
-			if (event.payload.key !== this.key) return;
-			this.#setState(event.payload.store.state);
-			this.setOptions(event.payload.options);
-		});
-	}
-	#setState;
-	/**
-	* Returns the current enabled state of the debouncer
-	*/
-	#getEnabled;
-	/**
-	* Returns the current wait time in milliseconds
-	*/
-	#getWait;
-	#execute;
-	#clearTimeout;
-};
-//#endregion
-//#region node_modules/.pnpm/@tanstack+pacer@0.21.0/node_modules/@tanstack/pacer/dist/throttler.js
-function getDefaultThrottlerState() {
-	return {
-		executionCount: 0,
-		isPending: false,
-		lastArgs: void 0,
-		lastExecutionTime: 0,
-		nextExecutionTime: 0,
-		status: "idle",
-		maybeExecuteCount: 0
-	};
-}
-var defaultOptions = {
-	enabled: true,
-	leading: true,
-	trailing: true,
-	wait: 0
-};
-/**
-* A class that creates a throttled function.
-*
-* Throttling ensures a function is called at most once within a specified time window.
-* Unlike debouncing which waits for a pause in calls, throttling guarantees consistent
-* execution timing regardless of call frequency.
-* This synchronous version is lighter weight and often all you need - upgrade to AsyncThrottler when you need promises, retry support, abort/cancel capabilities, or advanced error handling.
-*
-* Supports both leading and trailing edge execution:
-* - Leading: Execute immediately on first call (default: true)
-* - Trailing: Execute after wait period if called during throttle (default: true)
-*
-* For collapsing rapid-fire events where you only care about the last call, consider using Debouncer.
-*
-* State Management:
-* - Uses TanStack Store for reactive state management
-* - Use `initialState` to provide initial state values when creating the throttler
-* - Use `onExecute` callback to react to function execution and implement custom logic
-* - The state includes execution count, last execution time, pending status, and more
-* - State can be accessed via `throttler.store.state` when using the class directly
-* - When using framework adapters (React/Solid), state is accessed from `throttler.state`
-*
-* @example
-* ```ts
-* const throttler = new Throttler(
-*   (id: string) => api.getData(id),
-*   { wait: 1000 } // Execute at most once per second
-* );
-*
-* // First call executes immediately
-* throttler.maybeExecute('123');
-*
-* // Subsequent calls within 1000ms are throttled
-* throttler.maybeExecute('123'); // Throttled
-* ```
-*/
-var Throttler = class {
-	#timeoutId;
-	constructor(fn, initialOptions) {
-		this.fn = fn;
-		this.store = new Store(getDefaultThrottlerState());
-		this.setOptions = (newOptions) => {
-			this.options = {
-				...this.options,
-				...newOptions
-			};
-			if (!this.#getEnabled()) this.cancel();
-		};
-		this.#setState = (newState) => {
-			this.store.setState((state) => {
-				const combinedState = {
-					...state,
-					...newState
-				};
-				const { isPending } = combinedState;
-				return {
-					...combinedState,
-					status: !this.#getEnabled() ? "disabled" : isPending ? "pending" : "idle"
-				};
-			});
-			emitChange("Throttler", this);
-		};
-		this.#getEnabled = () => {
-			return !!parseFunctionOrValue(this.options.enabled, this);
-		};
-		this.#getWait = () => {
-			return parseFunctionOrValue(this.options.wait, this);
-		};
-		this.maybeExecute = (...args) => {
-			this.#setState({ maybeExecuteCount: this.store.state.maybeExecuteCount + 1 });
-			const now = Date.now();
-			const timeSinceLastExecution = now - this.store.state.lastExecutionTime;
-			const wait = this.#getWait();
-			if (this.options.leading && timeSinceLastExecution >= wait) this.#execute(...args);
-			else {
-				this.#setState({ lastArgs: args });
-				if (!this.#timeoutId && this.options.trailing) {
-					const timeoutDuration = wait - (this.store.state.lastExecutionTime ? now - this.store.state.lastExecutionTime : 0);
-					this.#setState({ isPending: true });
-					this.#timeoutId = setTimeout(() => {
-						const { lastArgs } = this.store.state;
-						if (lastArgs !== void 0) this.#execute(...lastArgs);
-					}, timeoutDuration);
-				}
-			}
-		};
-		this.#execute = (...args) => {
-			if (!this.#getEnabled()) return;
-			this.fn(...args);
-			const lastExecutionTime = Date.now();
-			const nextExecutionTime = lastExecutionTime + this.#getWait();
-			this.#clearTimeout();
-			this.#setState({
-				executionCount: this.store.state.executionCount + 1,
-				lastExecutionTime,
-				nextExecutionTime,
-				isPending: false,
-				lastArgs: void 0
-			});
-			this.options.onExecute?.(args, this);
-			setTimeout(() => {
-				if (!this.store.state.isPending) this.#setState({ nextExecutionTime: void 0 });
-			}, this.#getWait());
-		};
-		this.flush = () => {
-			if (this.store.state.isPending && this.store.state.lastArgs) this.#execute(...this.store.state.lastArgs);
-		};
-		this.#clearTimeout = () => {
-			if (this.#timeoutId) {
-				clearTimeout(this.#timeoutId);
-				this.#timeoutId = void 0;
-			}
-		};
-		this.cancel = () => {
-			this.#clearTimeout();
-			this.#setState({
-				lastArgs: void 0,
-				isPending: false
-			});
-		};
-		this.reset = () => {
-			this.#setState(getDefaultThrottlerState());
-		};
-		this.key = initialOptions.key;
-		this.options = {
-			...defaultOptions,
-			...initialOptions
-		};
-		this.#setState(this.options.initialState ?? {});
-		if (this.key) pacerEventClient.on("d-Throttler", (event) => {
-			if (event.payload.key !== this.key) return;
-			this.#setState(event.payload.store.state);
-			this.setOptions(event.payload.options);
-		});
-	}
-	#setState;
-	#getEnabled;
-	#getWait;
-	#execute;
-	#clearTimeout;
-};
-//#endregion
-export { AsyncDebouncer as i, Debouncer as n, Batcher as r, Throttler as t };