@tanstack/pacer 0.22.0 → 0.23.0

package/dist/async-throttler.js

@@ -91,157 +91,15 @@ const defaultOptions = {
 * ```
 */
 var AsyncThrottler = class {
-	#timeoutId;
-	#resolvePreviousPromise;
+	fn;
+	store = new Store(getDefaultAsyncThrottlerState());
+	key;
+	options;
+	asyncRetryers = /* @__PURE__ */ new Map();
+	#timeoutId = null;
+	#resolvePreviousPromise = null;
 	constructor(fn, initialOptions) {
 		this.fn = fn;
-		this.store = new Store(getDefaultAsyncThrottlerState());
-		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("AsyncThrottler", 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.#resolvePreviousPromiseInternal();
-			this.#setState({
-				maybeExecuteCount: this.store.state.maybeExecuteCount + 1,
-				lastArgs: args
-			});
-			const wait = this.#getWait();
-			const thisMaybeExecuteNumber = this.store.state.maybeExecuteCount;
-			for (let maxNumIterations = wait / 10; this.store.state.isExecuting && maxNumIterations > 0; maxNumIterations--) {
-				await new Promise((resolve) => setTimeout(resolve, 10));
-				if (this.store.state.maybeExecuteCount !== thisMaybeExecuteNumber) return this.store.state.lastResult;
-			}
-			const now = Date.now();
-			const timeSinceLastExecution = now - this.store.state.lastExecutionTime;
-			if (this.options.leading && !this.store.state.isPending && timeSinceLastExecution >= wait) await this.#execute(...args);
-			else if (this.options.trailing) {
-				this.cancel();
-				this.#setState({ isPending: true });
-				return new Promise((resolve, reject) => {
-					this.#resolvePreviousPromise = resolve;
-					const newTimeSinceLastExecution = this.store.state.lastExecutionTime ? now - this.store.state.lastExecutionTime : 0;
-					const timeoutDuration = Math.max(0, wait - newTimeSinceLastExecution);
-					this.#timeoutId = setTimeout(async () => {
-						this.#clearTimeout();
-						if (this.store.state.lastArgs !== void 0) try {
-							await this.#execute(...this.store.state.lastArgs);
-						} catch (error) {
-							reject(error);
-						}
-						this.#resolvePreviousPromise = null;
-						resolve(this.store.state.lastResult);
-					}, timeoutDuration);
-				});
-			}
-			return this.store.state.lastResult;
-		};
-		this.#execute = async (...args) => {
-			if (!this.#getEnabled()) return void 0;
-			const currentMaybeExecute = this.store.state.maybeExecuteCount;
-			try {
-				this.#setState({ isExecuting: true });
-				const currentAsyncRetryer = new AsyncRetryer(this.fn, this.options.asyncRetryerOptions);
-				this.asyncRetryers.set(currentMaybeExecute, 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(currentMaybeExecute);
-				const lastExecutionTime = Date.now();
-				const wait = this.#getWait();
-				const nextExecutionTime = lastExecutionTime + wait;
-				this.#setState({
-					isExecuting: false,
-					isPending: !!this.#timeoutId,
-					settleCount: this.store.state.settleCount + 1,
-					lastExecutionTime,
-					nextExecutionTime
-				});
-				this.options.onSettled?.(args, this);
-				setTimeout(() => {
-					if (!this.store.state.isPending) this.#setState({ nextExecutionTime: void 0 });
-				}, wait);
-			}
-			return this.store.state.lastResult;
-		};
-		this.flush = async () => {
-			if (this.store.state.isPending && this.store.state.lastArgs) {
-				const resolvePromise = this.#resolvePreviousPromise;
-				this.#clearTimeout();
-				this.#setState({ isPending: false });
-				const result = await this.#execute(...this.store.state.lastArgs);
-				if (resolvePromise) resolvePromise(result);
-				return result;
-			}
-		};
-		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.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.#clearTimeout();
-			if (this.#resolvePreviousPromise) {
-				this.#resolvePreviousPromiseInternal();
-				this.#resolvePreviousPromise = null;
-			}
-			this.#setState({ isPending: false });
-		};
-		this.reset = () => {
-			this.#setState(getDefaultAsyncThrottlerState());
-			this.asyncRetryers.forEach((retryer) => retryer.reset());
-		};
 		this.key = initialOptions.key;
 		this.options = {
 			...defaultOptions,
@@ -255,18 +113,218 @@ var AsyncThrottler = class {
 			this.setOptions(event.payload.options);
 		});
 	}
-	#setState;
+	/**
+	* Updates the async throttler options
+	*/
+	setOptions = (newOptions) => {
+		this.options = {
+			...this.options,
+			...newOptions
+		};
+		if (!this.#getEnabled()) this.cancel();
+	};
+	#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("AsyncThrottler", this);
+	};
 	/**
 	* Returns the current enabled state of the async throttler
 	*/
-	#getEnabled;
+	#getEnabled = () => {
+		return !!parseFunctionOrValue(this.options.enabled, this);
+	};
 	/**
 	* Returns the current wait time in milliseconds
 	*/
-	#getWait;
-	#execute;
-	#resolvePreviousPromiseInternal;
-	#clearTimeout;
+	#getWait = () => {
+		return parseFunctionOrValue(this.options.wait, this);
+	};
+	/**
+	* Attempts to execute the throttled function. The execution behavior depends on the throttler options:
+	*
+	* - If enough time has passed since the last execution (>= wait period):
+	*   - With leading=true: Executes immediately
+	*   - With leading=false: Waits for the next trailing execution
+	*
+	* - If within the wait period:
+	*   - With trailing=true: Schedules execution for end of wait period
+	*   - With trailing=false: Drops the execution
+	*
+	* @example
+	* ```ts
+	* const throttled = new AsyncThrottler(fn, { wait: 1000 });
+	*
+	* // First call executes immediately
+	* await throttled.maybeExecute('a', 'b');
+	*
+	* // Call during wait period - gets throttled
+	* await throttled.maybeExecute('c', 'd');
+	* ```
+	*/
+	maybeExecute = async (...args) => {
+		if (!this.#getEnabled()) return void 0;
+		this.#resolvePreviousPromiseInternal();
+		this.#setState({
+			maybeExecuteCount: this.store.state.maybeExecuteCount + 1,
+			lastArgs: args
+		});
+		const wait = this.#getWait();
+		const thisMaybeExecuteNumber = this.store.state.maybeExecuteCount;
+		for (let maxNumIterations = wait / 10; this.store.state.isExecuting && maxNumIterations > 0; maxNumIterations--) {
+			await new Promise((resolve) => setTimeout(resolve, 10));
+			if (this.store.state.maybeExecuteCount !== thisMaybeExecuteNumber) return this.store.state.lastResult;
+		}
+		const now = Date.now();
+		const timeSinceLastExecution = now - this.store.state.lastExecutionTime;
+		if (this.options.leading && !this.store.state.isPending && timeSinceLastExecution >= wait) await this.#execute(...args);
+		else if (this.options.trailing) {
+			this.cancel();
+			this.#setState({ isPending: true });
+			return new Promise((resolve, reject) => {
+				this.#resolvePreviousPromise = resolve;
+				const newTimeSinceLastExecution = this.store.state.lastExecutionTime ? now - this.store.state.lastExecutionTime : 0;
+				const timeoutDuration = Math.max(0, wait - newTimeSinceLastExecution);
+				this.#timeoutId = setTimeout(async () => {
+					this.#clearTimeout();
+					if (this.store.state.lastArgs !== void 0) try {
+						await this.#execute(...this.store.state.lastArgs);
+					} catch (error) {
+						reject(error);
+					}
+					this.#resolvePreviousPromise = null;
+					resolve(this.store.state.lastResult);
+				}, timeoutDuration);
+			});
+		}
+		return this.store.state.lastResult;
+	};
+	#execute = async (...args) => {
+		if (!this.#getEnabled()) return void 0;
+		const currentMaybeExecute = this.store.state.maybeExecuteCount;
+		try {
+			this.#setState({ isExecuting: true });
+			const currentAsyncRetryer = new AsyncRetryer(this.fn, this.options.asyncRetryerOptions);
+			this.asyncRetryers.set(currentMaybeExecute, 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(currentMaybeExecute);
+			const lastExecutionTime = Date.now();
+			const wait = this.#getWait();
+			const nextExecutionTime = lastExecutionTime + wait;
+			this.#setState({
+				isExecuting: false,
+				isPending: !!this.#timeoutId,
+				settleCount: this.store.state.settleCount + 1,
+				lastExecutionTime,
+				nextExecutionTime
+			});
+			this.options.onSettled?.(args, this);
+			setTimeout(() => {
+				if (!this.store.state.isPending) this.#setState({ nextExecutionTime: void 0 });
+			}, wait);
+		}
+		return this.store.state.lastResult;
+	};
+	/**
+	* Processes the current pending execution immediately
+	*/
+	flush = async () => {
+		if (this.store.state.isPending && this.store.state.lastArgs) {
+			const resolvePromise = this.#resolvePreviousPromise;
+			this.#clearTimeout();
+			this.#setState({ isPending: false });
+			const result = await this.#execute(...this.store.state.lastArgs);
+			if (resolvePromise) resolvePromise(result);
+			return result;
+		}
+	};
+	#resolvePreviousPromiseInternal = () => {
+		if (this.#resolvePreviousPromise) {
+			this.#resolvePreviousPromise(this.store.state.lastResult);
+			this.#resolvePreviousPromise = null;
+		}
+	};
+	#clearTimeout = () => {
+		if (this.#timeoutId) {
+			clearTimeout(this.#timeoutId);
+			this.#timeoutId = null;
+		}
+	};
+	/**
+	* Returns the AbortSignal for a specific execution.
+	* If no maybeExecuteCount is provided, returns the signal for the most recent execution.
+	* Returns null if no execution is found or not currently executing.
+	*
+	* @param maybeExecuteCount - Optional specific execution to get signal for
+	* @example
+	* ```typescript
+	* const throttler = new AsyncThrottler(
+	*   async (data: string) => {
+	*     const signal = throttler.getAbortSignal()
+	*     if (signal) {
+	*       const response = await fetch('/api/save', {
+	*         method: 'POST',
+	*         body: data,
+	*         signal
+	*       })
+	*       return response.json()
+	*     }
+	*   },
+	*   { wait: 1000 }
+	* )
+	* ```
+	*/
+	getAbortSignal = (maybeExecuteCount) => {
+		const count = maybeExecuteCount ?? this.store.state.maybeExecuteCount;
+		return this.asyncRetryers.get(count)?.getAbortSignal() ?? null;
+	};
+	/**
+	* Aborts all ongoing executions with the internal abort controllers.
+	* Does NOT cancel any pending execution that have not started yet.
+	*/
+	abort = () => {
+		this.asyncRetryers.forEach((retryer) => retryer.abort());
+		this.asyncRetryers.clear();
+		this.#setState({ isExecuting: false });
+	};
+	/**
+	* Cancels any pending execution that have not started yet.
+	* Does NOT abort any execution already in progress.
+	*/
+	cancel = () => {
+		this.#clearTimeout();
+		if (this.#resolvePreviousPromise) {
+			this.#resolvePreviousPromiseInternal();
+			this.#resolvePreviousPromise = null;
+		}
+		this.#setState({ isPending: false });
+	};
+	/**
+	* Resets the debouncer state to its default values
+	*/
+	reset = () => {
+		this.#setState(getDefaultAsyncThrottlerState());
+		this.asyncRetryers.forEach((retryer) => retryer.reset());
+	};
 };
 /**
 * Creates an async throttled function that limits how often the function can execute.
@@ -337,5 +395,4 @@ function asyncThrottle(fn, initialOptions) {
 }
 
 //#endregion
-export { AsyncThrottler, asyncThrottle, asyncThrottlerOptions };
-//# sourceMappingURL=async-throttler.js.map
+export { AsyncThrottler, asyncThrottle, asyncThrottlerOptions };

package/dist/batcher.d.ts

@@ -1,7 +1,7 @@
 import { OptionalKeys } from "./types.js";
 import { Store } from "@tanstack/store";
 //#region src/batcher.d.ts
-interface BatcherState<TValue> {
+export interface BatcherState<TValue> {
   /**
    * Number of batch executions that have been completed
    */
@@ -34,7 +34,7 @@ interface BatcherState<TValue> {
 /**
  * Options for configuring a Batcher instance
  */
-interface BatcherOptions<TValue> {
+export interface BatcherOptions<TValue> {
   /**
    * Custom function to determine if a batch should be processed
    * Return true to process the batch immediately
@@ -115,7 +115,7 @@ type BatcherOptionsWithOptionalCallbacks<TValue> = OptionalKeys<Required<Batcher
  * // batcher.flush() // manually trigger a batch
  * ```
  */
-declare class Batcher<TValue> {
+export declare class Batcher<TValue> {
   #private;
   fn: (items: Array<TValue>) => void;
   readonly store: Store<Readonly<BatcherState<TValue>>>;
@@ -173,7 +173,5 @@ declare class Batcher<TValue> {
  * batchItems(3); // Triggers batch processing
  * ```
  */
-declare function batch<TValue>(fn: (items: Array<TValue>) => void, options: BatcherOptions<TValue>): (item: TValue) => void;
-//#endregion
-export { Batcher, BatcherOptions, BatcherState, batch };
-//# sourceMappingURL=batcher.d.ts.map
+export declare function batch<TValue>(fn: (items: Array<TValue>) => void, options: BatcherOptions<TValue>): (item: TValue) => void;
+//#endregion

package/dist/batcher.js

@@ -60,89 +60,13 @@ const defaultOptions = {
 * ```
 */
 var Batcher = class {
-	#timeoutId;
+	fn;
+	store = new Store(getDefaultBatcherState());
+	key;
+	options;
+	#timeoutId = null;
 	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,
@@ -155,8 +79,52 @@ var Batcher = class {
 			this.setOptions(event.payload.options);
 		});
 	}
-	#setState;
-	#getWait;
+	/**
+	* Updates the batcher options
+	*/
+	setOptions = (newOptions) => {
+		this.options = {
+			...this.options,
+			...newOptions
+		};
+	};
+	#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);
+	};
+	#getWait = () => {
+		return parseFunctionOrValue(this.options.wait, this);
+	};
+	/**
+	* Adds an item to the batcher
+	* If the batch size is reached, timeout occurs, or shouldProcess returns true, the batch will be processed
+	*/
+	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());
+		}
+	};
 	/**
 	* Processes the current batch of items.
 	* This method will automatically be triggered if the batcher is running and any of these conditions are met:
@@ -166,8 +134,61 @@ var Batcher = class {
 	*
 	* You can also call this method manually to process the current batch at any time.
 	*/
-	#execute;
-	#clearTimeout;
+	#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);
+	};
+	/**
+	* Processes the current batch of items immediately
+	*/
+	flush = () => {
+		this.#clearTimeout();
+		this.#execute();
+	};
+	/**
+	* Returns a copy of all items in the batcher
+	*/
+	peekAllItems = () => {
+		return [...this.store.state.items];
+	};
+	#clearTimeout = () => {
+		if (this.#timeoutId) {
+			clearTimeout(this.#timeoutId);
+			this.#timeoutId = null;
+		}
+	};
+	/**
+	* Removes all items from the batcher
+	*/
+	clear = () => {
+		this.#setState({
+			items: [],
+			isPending: false
+		});
+	};
+	/**
+	* Cancels any pending execution that was scheduled.
+	* Does NOT clear out the items.
+	*/
+	cancel = () => {
+		this.#clearTimeout();
+		this.#setState({ isPending: false });
+	};
+	/**
+	* Resets the batcher state to its default values
+	*/
+	reset = () => {
+		this.#setState(getDefaultBatcherState());
+		this.options.onItemsChange?.(this);
+	};
 };
 /**
 * Creates a batcher that processes items in batches.
@@ -194,5 +215,4 @@ function batch(fn, options) {
 }
 
 //#endregion
-export { Batcher, batch };
-//# sourceMappingURL=batcher.js.map
+export { Batcher, batch };

package/dist/debouncer.d.ts

@@ -1,7 +1,7 @@
 import { AnyFunction } from "./types.js";
 import { Store } from "@tanstack/store";
 //#region src/debouncer.d.ts
-interface DebouncerState<TFn extends AnyFunction> {
+export interface DebouncerState<TFn extends AnyFunction> {
   /**
    * Whether the debouncer can execute on the leading edge of the timeout
    */
@@ -30,7 +30,7 @@ interface DebouncerState<TFn extends AnyFunction> {
 /**
  * Options for configuring a debounced function
  */
-interface DebouncerOptions<TFn extends AnyFunction> {
+export interface DebouncerOptions<TFn extends AnyFunction> {
   /**
    * Whether the debouncer is enabled. When disabled, maybeExecute will not trigger any executions.
    * Can be a boolean or a function that returns a boolean.
@@ -71,7 +71,7 @@ interface DebouncerOptions<TFn extends AnyFunction> {
 /**
  * Utility function for sharing common `DebouncerOptions` options between different `Debouncer` instances.
  */
-declare function debouncerOptions<TFn extends AnyFunction = AnyFunction, TOptions extends Partial<DebouncerOptions<TFn>> = Partial<DebouncerOptions<TFn>>>(options: TOptions): TOptions;
+export declare function debouncerOptions<TFn extends AnyFunction = AnyFunction, TOptions extends Partial<DebouncerOptions<TFn>> = Partial<DebouncerOptions<TFn>>>(options: TOptions): TOptions;
 /**
  * A class that creates a debounced function.
  *
@@ -104,7 +104,7 @@ declare function debouncerOptions<TFn extends AnyFunction = AnyFunction, TOption
  * });
  * ```
  */
-declare class Debouncer<TFn extends AnyFunction> {
+export declare class Debouncer<TFn extends AnyFunction> {
   #private;
   fn: TFn;
   readonly store: Store<Readonly<DebouncerState<TFn>>>;
@@ -160,7 +160,5 @@ declare class Debouncer<TFn extends AnyFunction> {
  * inputElement.addEventListener('input', debounced);
  * ```
  */
-declare function debounce<TFn extends AnyFunction>(fn: TFn, initialOptions: DebouncerOptions<TFn>): (...args: Parameters<TFn>) => void;
-//#endregion
-export { Debouncer, DebouncerOptions, DebouncerState, debounce, debouncerOptions };
-//# sourceMappingURL=debouncer.d.ts.map
+export declare function debounce<TFn extends AnyFunction>(fn: TFn, initialOptions: DebouncerOptions<TFn>): (...args: Parameters<TFn>) => void;
+//#endregion