@ls-stack/utils 3.40.0 → 3.42.0

package/dist/testUtils.d.cts

@@ -42,26 +42,32 @@ declare function waitController(): {
     stopWaitingAfter: (ms: number) => void;
 };
 /**
- * Produces a more compact and readable snapshot of a value using yaml.
- * By default booleans are shown as `✅` and `❌`, use `showBooleansAs` to disable/configure this.
+ * Produces a more compact and readable snapshot of a value using yaml. By
+ * default booleans are shown as `✅` and `❌`, use `showBooleansAs` to
+ * disable/configure this.
  *
  * Filtering patterns in `rejectKeys` and `filterKeys`:
+ *
  * - `'prop'` - Only root-level properties named 'prop'
  * - `'**prop'` - Any property named exactly 'prop' at any level (root or nested)
- * - `'*.prop'` - Any nested property named 'prop' at second level (excludes root-level matches)
+ * - `'*.prop'` - Any nested property named 'prop' at second level (excludes
+ *   root-level matches)
  * - `'test.*.prop'` - Any property named 'prop' at second level of 'test'
  * - `'test.*.test.**prop'` - Any property named 'prop' inside of 'test.*.test'
  * - `'prop.nested'` - Exact nested property paths like `obj.prop.nested`
- * - `'prop.**nested'` - All nested properties inside root `prop` with name `nested`
+ * - `'prop.**nested'` - All nested properties inside root `prop` with name
+ *   `nested`
  * - `'prop[0]'` - The first item of the `prop` array
  * - `'prop[*]'` - All items of the `prop` array
  * - `'prop[0].nested'` - `nested` prop of the first item of the `prop` array
  * - `'prop[*].nested'` - `nested` prop of all items of the `prop` array
  * - `'prop[*]**nested'` - all `nested` props of all items of the `prop` array
  * - `'prop[0-2]'` - The first three items of the `prop` array
- * - `'prop[4-*]'` - All items of the `prop` array from the fourth index to the end
+ * - `'prop[4-*]'` - All items of the `prop` array from the fourth index to the
+ *   end
  * - `'prop[0-2].nested.**prop'` - Combining multiple nested patterns is supported
  * - Root array:
+ *
  *   - `'[0]'` - The first item of the root array
  *   - `'[*]'` - All items of the array
  *   - `'[0].nested'` - `nested` prop of the first item of the array
@@ -70,27 +76,39 @@ declare function waitController(): {
  *   - `'[0-2]'` - The first three items of the array
  *   - `'[4-*]'` - All items of the array from the fourth index to the end
  * - Expanding the patterns with parentheses:
- *   - `'prop.test.(prop1|prop2|prop3.prop4)'` - Will produce `prop.test.prop1`, `prop.test.prop2`, and `prop.test.prop3.prop4`
+ *
+ *   - `'prop.test.(prop1|prop2|prop3.prop4)'` - Will produce `prop.test.prop1`,
+ *       `prop.test.prop2`, and `prop.test.prop3.prop4`
  * - Array filtering by value:
- *   - `'users[%name="John"]'` - Filters the `users` with the `name` property equal to `John`
- *   - `'users[%name="John" | "Jane"]'` - Filters the `users` with the `name` property equal to `John` or `Jane`
- *   - `'users[%name="John" | "Jane" && %age=20]'` - AND and OR are supported by using `&&` and `||`, nesting logical operators is not supported yet
+ *
+ *   - `'users[%name="John"]'` - Filters the `users` with the `name` property equal
+ *       to `John`
+ *   - `'users[%name="John" | "Jane"]'` - Filters the `users` with the `name`
+ *       property equal to `John` or `Jane`
+ *   - `'users[%name="John" | "Jane" && %age=20]'` - AND and OR are supported by
+ *       using `&&` and `||`, nesting logical operators is not supported yet
  *   - `'users[%config.name="John" | "Jane"]'` - Dot notation is supported
  *
  * Check more supported patterns in {@link filterObjectOrArrayKeys} docs.
  *
  * @param value - The value to snapshot.
  * @param options - The options for the snapshot.
- * @param options.collapseObjects - Whether to collapse objects into a single line.
+ * @param options.collapseObjects - Whether to collapse objects into a single
+ *   line.
  * @param options.maxLineLength - The maximum length of a line.
  * @param options.showUndefined - Whether to show undefined values.
- * @param options.showBooleansAs - Whether to show booleans as text, by default true is `✅` and false is `❌`
+ * @param options.showBooleansAs - Whether to show booleans as text, by default
+ *   true is `✅` and false is `❌`
  * @param options.rejectKeys - The keys to reject.
  * @param options.filterKeys - The keys to filter.
  * @param options.ignoreProps - The props to ignore.
- * @param options.replaceValues - Function to replace values at specific paths. Returns `false` to keep original value or `{newValue}` to replace.
- * @param options.sortKeys - Sort all keys by a specific order (default: `simpleValuesFirst`).
- * @param options.sortPatterns - Sort specific keys by pattern. Use to control the order of specific properties. The same patterns as `filterKeys` are supported.
+ * @param options.replaceValues - Function to replace values at specific paths.
+ *   Returns `false` to keep original value or `{newValue}` to replace.
+ * @param options.sortKeys - Sort all keys by a specific order (default:
+ *   `simpleValuesFirst`).
+ * @param options.sortPatterns - Sort specific keys by pattern. Use to control
+ *   the order of specific properties. The same patterns as `filterKeys` are
+ *   supported.
  * @returns The compact snapshot of the value.
  */
 declare function compactSnapshot(value: unknown, { collapseObjects, maxLineLength, showUndefined, showBooleansAs, replaceValues, rejectKeys, filterKeys, sortKeys, sortPatterns, ...options }?: YamlStringifyOptions & {

package/dist/testUtils.d.ts

@@ -42,26 +42,32 @@ declare function waitController(): {
     stopWaitingAfter: (ms: number) => void;
 };
 /**
- * Produces a more compact and readable snapshot of a value using yaml.
- * By default booleans are shown as `✅` and `❌`, use `showBooleansAs` to disable/configure this.
+ * Produces a more compact and readable snapshot of a value using yaml. By
+ * default booleans are shown as `✅` and `❌`, use `showBooleansAs` to
+ * disable/configure this.
  *
  * Filtering patterns in `rejectKeys` and `filterKeys`:
+ *
  * - `'prop'` - Only root-level properties named 'prop'
  * - `'**prop'` - Any property named exactly 'prop' at any level (root or nested)
- * - `'*.prop'` - Any nested property named 'prop' at second level (excludes root-level matches)
+ * - `'*.prop'` - Any nested property named 'prop' at second level (excludes
+ *   root-level matches)
  * - `'test.*.prop'` - Any property named 'prop' at second level of 'test'
  * - `'test.*.test.**prop'` - Any property named 'prop' inside of 'test.*.test'
  * - `'prop.nested'` - Exact nested property paths like `obj.prop.nested`
- * - `'prop.**nested'` - All nested properties inside root `prop` with name `nested`
+ * - `'prop.**nested'` - All nested properties inside root `prop` with name
+ *   `nested`
  * - `'prop[0]'` - The first item of the `prop` array
  * - `'prop[*]'` - All items of the `prop` array
  * - `'prop[0].nested'` - `nested` prop of the first item of the `prop` array
  * - `'prop[*].nested'` - `nested` prop of all items of the `prop` array
  * - `'prop[*]**nested'` - all `nested` props of all items of the `prop` array
  * - `'prop[0-2]'` - The first three items of the `prop` array
- * - `'prop[4-*]'` - All items of the `prop` array from the fourth index to the end
+ * - `'prop[4-*]'` - All items of the `prop` array from the fourth index to the
+ *   end
  * - `'prop[0-2].nested.**prop'` - Combining multiple nested patterns is supported
  * - Root array:
+ *
  *   - `'[0]'` - The first item of the root array
  *   - `'[*]'` - All items of the array
  *   - `'[0].nested'` - `nested` prop of the first item of the array
@@ -70,27 +76,39 @@ declare function waitController(): {
  *   - `'[0-2]'` - The first three items of the array
  *   - `'[4-*]'` - All items of the array from the fourth index to the end
  * - Expanding the patterns with parentheses:
- *   - `'prop.test.(prop1|prop2|prop3.prop4)'` - Will produce `prop.test.prop1`, `prop.test.prop2`, and `prop.test.prop3.prop4`
+ *
+ *   - `'prop.test.(prop1|prop2|prop3.prop4)'` - Will produce `prop.test.prop1`,
+ *       `prop.test.prop2`, and `prop.test.prop3.prop4`
  * - Array filtering by value:
- *   - `'users[%name="John"]'` - Filters the `users` with the `name` property equal to `John`
- *   - `'users[%name="John" | "Jane"]'` - Filters the `users` with the `name` property equal to `John` or `Jane`
- *   - `'users[%name="John" | "Jane" && %age=20]'` - AND and OR are supported by using `&&` and `||`, nesting logical operators is not supported yet
+ *
+ *   - `'users[%name="John"]'` - Filters the `users` with the `name` property equal
+ *       to `John`
+ *   - `'users[%name="John" | "Jane"]'` - Filters the `users` with the `name`
+ *       property equal to `John` or `Jane`
+ *   - `'users[%name="John" | "Jane" && %age=20]'` - AND and OR are supported by
+ *       using `&&` and `||`, nesting logical operators is not supported yet
  *   - `'users[%config.name="John" | "Jane"]'` - Dot notation is supported
  *
  * Check more supported patterns in {@link filterObjectOrArrayKeys} docs.
  *
  * @param value - The value to snapshot.
  * @param options - The options for the snapshot.
- * @param options.collapseObjects - Whether to collapse objects into a single line.
+ * @param options.collapseObjects - Whether to collapse objects into a single
+ *   line.
  * @param options.maxLineLength - The maximum length of a line.
  * @param options.showUndefined - Whether to show undefined values.
- * @param options.showBooleansAs - Whether to show booleans as text, by default true is `✅` and false is `❌`
+ * @param options.showBooleansAs - Whether to show booleans as text, by default
+ *   true is `✅` and false is `❌`
  * @param options.rejectKeys - The keys to reject.
  * @param options.filterKeys - The keys to filter.
  * @param options.ignoreProps - The props to ignore.
- * @param options.replaceValues - Function to replace values at specific paths. Returns `false` to keep original value or `{newValue}` to replace.
- * @param options.sortKeys - Sort all keys by a specific order (default: `simpleValuesFirst`).
- * @param options.sortPatterns - Sort specific keys by pattern. Use to control the order of specific properties. The same patterns as `filterKeys` are supported.
+ * @param options.replaceValues - Function to replace values at specific paths.
+ *   Returns `false` to keep original value or `{newValue}` to replace.
+ * @param options.sortKeys - Sort all keys by a specific order (default:
+ *   `simpleValuesFirst`).
+ * @param options.sortPatterns - Sort specific keys by pattern. Use to control
+ *   the order of specific properties. The same patterns as `filterKeys` are
+ *   supported.
  * @returns The compact snapshot of the value.
  */
 declare function compactSnapshot(value: unknown, { collapseObjects, maxLineLength, showUndefined, showBooleansAs, replaceValues, rejectKeys, filterKeys, sortKeys, sortPatterns, ...options }?: YamlStringifyOptions & {

package/dist/testUtils.js

@@ -1,10 +1,11 @@
 import {
   yamlStringify
-} from "./chunk-ADM37GSC.js";
+} from "./chunk-7L4KCZJJ.js";
 import {
   omit,
   pick
-} from "./chunk-GHAQOUA6.js";
+} from "./chunk-Y45CE75W.js";
+import "./chunk-GMJTLFM6.js";
 import "./chunk-IATIXMCE.js";
 import {
   deepEqual
@@ -18,7 +19,7 @@ import {
 import {
   clampMin
 } from "./chunk-HTCYUMDR.js";
-import "./chunk-KW55OTUG.js";
+import "./chunk-B3KFV2MH.js";
 import {
   arrayWithPrevAndIndex,
   filterAndMap

package/dist/throttle.d.cts

@@ -4,54 +4,85 @@ import { __LEGIT_ANY_FUNCTION__ } from './saferTyping.cjs';
 interface ThrottleSettings {
     /**
      * Specify invoking on the leading edge of the timeout.
+     *
      * @default true
      */
     leading?: boolean;
     /**
      * Specify invoking on the trailing edge of the timeout.
+     *
      * @default true
      */
     trailing?: boolean;
 }
 /**
- * Creates a throttled function that only invokes the provided function at most once per every `wait` milliseconds.
- * The throttled function comes with a `cancel` method to cancel delayed invocations and a `flush` method to immediately invoke them.
+ * Creates a throttled function that only invokes the provided function at most
+ * once per every `wait` milliseconds. The throttled function comes with a
+ * `cancel` method to cancel delayed invocations and a `flush` method to
+ * immediately invoke them.
  *
- * Throttling is useful for rate-limiting events that fire frequently, like scroll or resize handlers.
- * Unlike debouncing, throttling guarantees the function is called at regular intervals.
+ * Throttling is useful for rate-limiting events that fire frequently, like
+ * scroll or resize handlers. Unlike debouncing, throttling guarantees the
+ * function is called at regular intervals.
+ *
+ * @example
+ *   ```ts
+ *   const throttledSave = throttle(saveData, 1000);
+ *
+ *   // Will only call saveData at most once per second
+ *   throttledSave();
+ *   throttledSave();
+ *   throttledSave();
+ *   ```;
+ *
+ * @example
+ *   ```ts
+ *   // Only invoke on trailing edge
+ *   const throttledHandler = throttle(handleScroll, 100, { leading: false });
+ *   ```;
  *
  * @template T - The type of the function to throttle
  * @param func - The function to throttle
  * @param wait - The number of milliseconds to throttle invocations to
  * @param options - The options object
- * @param options.leading - Specify invoking on the leading edge of the timeout (default: true)
- * @param options.trailing - Specify invoking on the trailing edge of the timeout (default: true)
+ * @param options.leading - Specify invoking on the leading edge of the timeout
+ *   (default: true)
+ * @param options.trailing - Specify invoking on the trailing edge of the
+ *   timeout (default: true)
  * @returns Returns the new throttled function
+ */
+declare function throttle<T extends __LEGIT_ANY_FUNCTION__>(func: T, wait: number, options?: ThrottleSettings): DebouncedFunc<T>;
+/**
+ * Creates a factory for throttled functions that caches throttled instances
+ * based on function arguments. Each unique set of arguments gets its own
+ * throttled function instance, allowing for fine-grained throttling control per
+ * argument combination.
+ *
+ * This is useful when you want to throttle calls to the same function but with
+ * different parameters independently. For example, throttling API calls per
+ * user ID or throttling UI updates per component.
  *
  * @example
- * ```ts
- * const throttledSave = throttle(saveData, 1000);
+ *   ```ts
+ *   const apiThrottle = createThrottledFunctionFactory(
+ *     1000,
+ *     (userId: string, action: string) => callAPI(userId, action)
+ *   );
  *
- * // Will only call saveData at most once per second
- * throttledSave();
- * throttledSave();
- * throttledSave();
- * ```
+ *   // Each user gets their own throttled instance
+ *   apiThrottle.call('user1', 'update'); // Executes immediately
+ *   apiThrottle.call('user2', 'update'); // Executes immediately (different user)
+ *   apiThrottle.call('user1', 'update'); // Throttled (same user)
+ *   ```;
  *
  * @example
- * ```ts
- * // Only invoke on trailing edge
- * const throttledHandler = throttle(handleScroll, 100, { leading: false });
- * ```
- */
-declare function throttle<T extends __LEGIT_ANY_FUNCTION__>(func: T, wait: number, options?: ThrottleSettings): DebouncedFunc<T>;
-/**
- * Creates a factory for throttled functions that caches throttled instances based on function arguments.
- * Each unique set of arguments gets its own throttled function instance, allowing for fine-grained
- * throttling control per argument combination.
- *
- * This is useful when you want to throttle calls to the same function but with different parameters
- * independently. For example, throttling API calls per user ID or throttling UI updates per component.
+ *   ```ts
+ *   // Throttle UI updates per component
+ *   const updateThrottle = createThrottledFunctionFactory(
+ *     100,
+ *     (componentId: string, data: any) => updateComponent(componentId, data)
+ *   );
+ *   ```;
  *
  * @template T - The type of arguments the callback function accepts
  * @template R - The return type of the callback function
@@ -59,28 +90,6 @@ declare function throttle<T extends __LEGIT_ANY_FUNCTION__>(func: T, wait: numbe
  * @param callback - The function to throttle
  * @param options - The throttle options (leading/trailing behavior)
  * @returns An object with a `call` method that accepts the callback arguments
- *
- * @example
- * ```ts
- * const apiThrottle = createThrottledFunctionFactory(
- *   1000,
- *   (userId: string, action: string) => callAPI(userId, action)
- * );
- *
- * // Each user gets their own throttled instance
- * apiThrottle.call('user1', 'update'); // Executes immediately
- * apiThrottle.call('user2', 'update'); // Executes immediately (different user)
- * apiThrottle.call('user1', 'update'); // Throttled (same user)
- * ```
- *
- * @example
- * ```ts
- * // Throttle UI updates per component
- * const updateThrottle = createThrottledFunctionFactory(
- *   100,
- *   (componentId: string, data: any) => updateComponent(componentId, data)
- * );
- * ```
  */
 declare function createThrottledFunctionFactory<T extends string | number | null | undefined | boolean, R>(wait: number, callback: (...args: T[]) => R, options?: ThrottleSettings): {
     call: (...args: T[]) => R | undefined;

package/dist/throttle.d.ts

@@ -4,54 +4,85 @@ import { __LEGIT_ANY_FUNCTION__ } from './saferTyping.js';
 interface ThrottleSettings {
     /**
      * Specify invoking on the leading edge of the timeout.
+     *
      * @default true
      */
     leading?: boolean;
     /**
      * Specify invoking on the trailing edge of the timeout.
+     *
      * @default true
      */
     trailing?: boolean;
 }
 /**
- * Creates a throttled function that only invokes the provided function at most once per every `wait` milliseconds.
- * The throttled function comes with a `cancel` method to cancel delayed invocations and a `flush` method to immediately invoke them.
+ * Creates a throttled function that only invokes the provided function at most
+ * once per every `wait` milliseconds. The throttled function comes with a
+ * `cancel` method to cancel delayed invocations and a `flush` method to
+ * immediately invoke them.
  *
- * Throttling is useful for rate-limiting events that fire frequently, like scroll or resize handlers.
- * Unlike debouncing, throttling guarantees the function is called at regular intervals.
+ * Throttling is useful for rate-limiting events that fire frequently, like
+ * scroll or resize handlers. Unlike debouncing, throttling guarantees the
+ * function is called at regular intervals.
+ *
+ * @example
+ *   ```ts
+ *   const throttledSave = throttle(saveData, 1000);
+ *
+ *   // Will only call saveData at most once per second
+ *   throttledSave();
+ *   throttledSave();
+ *   throttledSave();
+ *   ```;
+ *
+ * @example
+ *   ```ts
+ *   // Only invoke on trailing edge
+ *   const throttledHandler = throttle(handleScroll, 100, { leading: false });
+ *   ```;
  *
  * @template T - The type of the function to throttle
  * @param func - The function to throttle
  * @param wait - The number of milliseconds to throttle invocations to
  * @param options - The options object
- * @param options.leading - Specify invoking on the leading edge of the timeout (default: true)
- * @param options.trailing - Specify invoking on the trailing edge of the timeout (default: true)
+ * @param options.leading - Specify invoking on the leading edge of the timeout
+ *   (default: true)
+ * @param options.trailing - Specify invoking on the trailing edge of the
+ *   timeout (default: true)
  * @returns Returns the new throttled function
+ */
+declare function throttle<T extends __LEGIT_ANY_FUNCTION__>(func: T, wait: number, options?: ThrottleSettings): DebouncedFunc<T>;
+/**
+ * Creates a factory for throttled functions that caches throttled instances
+ * based on function arguments. Each unique set of arguments gets its own
+ * throttled function instance, allowing for fine-grained throttling control per
+ * argument combination.
+ *
+ * This is useful when you want to throttle calls to the same function but with
+ * different parameters independently. For example, throttling API calls per
+ * user ID or throttling UI updates per component.
  *
  * @example
- * ```ts
- * const throttledSave = throttle(saveData, 1000);
+ *   ```ts
+ *   const apiThrottle = createThrottledFunctionFactory(
+ *     1000,
+ *     (userId: string, action: string) => callAPI(userId, action)
+ *   );
  *
- * // Will only call saveData at most once per second
- * throttledSave();
- * throttledSave();
- * throttledSave();
- * ```
+ *   // Each user gets their own throttled instance
+ *   apiThrottle.call('user1', 'update'); // Executes immediately
+ *   apiThrottle.call('user2', 'update'); // Executes immediately (different user)
+ *   apiThrottle.call('user1', 'update'); // Throttled (same user)
+ *   ```;
  *
  * @example
- * ```ts
- * // Only invoke on trailing edge
- * const throttledHandler = throttle(handleScroll, 100, { leading: false });
- * ```
- */
-declare function throttle<T extends __LEGIT_ANY_FUNCTION__>(func: T, wait: number, options?: ThrottleSettings): DebouncedFunc<T>;
-/**
- * Creates a factory for throttled functions that caches throttled instances based on function arguments.
- * Each unique set of arguments gets its own throttled function instance, allowing for fine-grained
- * throttling control per argument combination.
- *
- * This is useful when you want to throttle calls to the same function but with different parameters
- * independently. For example, throttling API calls per user ID or throttling UI updates per component.
+ *   ```ts
+ *   // Throttle UI updates per component
+ *   const updateThrottle = createThrottledFunctionFactory(
+ *     100,
+ *     (componentId: string, data: any) => updateComponent(componentId, data)
+ *   );
+ *   ```;
  *
  * @template T - The type of arguments the callback function accepts
  * @template R - The return type of the callback function
@@ -59,28 +90,6 @@ declare function throttle<T extends __LEGIT_ANY_FUNCTION__>(func: T, wait: numbe
  * @param callback - The function to throttle
  * @param options - The throttle options (leading/trailing behavior)
  * @returns An object with a `call` method that accepts the callback arguments
- *
- * @example
- * ```ts
- * const apiThrottle = createThrottledFunctionFactory(
- *   1000,
- *   (userId: string, action: string) => callAPI(userId, action)
- * );
- *
- * // Each user gets their own throttled instance
- * apiThrottle.call('user1', 'update'); // Executes immediately
- * apiThrottle.call('user2', 'update'); // Executes immediately (different user)
- * apiThrottle.call('user1', 'update'); // Throttled (same user)
- * ```
- *
- * @example
- * ```ts
- * // Throttle UI updates per component
- * const updateThrottle = createThrottledFunctionFactory(
- *   100,
- *   (componentId: string, data: any) => updateComponent(componentId, data)
- * );
- * ```
  */
 declare function createThrottledFunctionFactory<T extends string | number | null | undefined | boolean, R>(wait: number, callback: (...args: T[]) => R, options?: ThrottleSettings): {
     call: (...args: T[]) => R | undefined;

package/dist/timers.d.cts

@@ -2,69 +2,70 @@ type CleanupTimer = () => void;
 /**
  * Creates a timeout with automatic cleanup capability.
  *
- * Returns a cleanup function that can be called to cancel the timeout.
- * The cleanup function is idempotent - calling it multiple times is safe.
+ * Returns a cleanup function that can be called to cancel the timeout. The
+ * cleanup function is idempotent - calling it multiple times is safe.
+ *
+ * @example
+ *   ```typescript
+ *   const cleanup = createTimeout(1000, () => {
+ *     console.log('Timeout completed');
+ *   });
+ *
+ *   // Cancel the timeout before it completes
+ *   cleanup();
+ *   ```;
  *
  * @param ms - The timeout duration in milliseconds
  * @param callback - The function to execute when the timeout completes
  * @returns A cleanup function that cancels the timeout when called
- *
- * @example
- * ```typescript
- * const cleanup = createTimeout(1000, () => {
- *   console.log('Timeout completed');
- * });
- *
- * // Cancel the timeout before it completes
- * cleanup();
- * ```
  */
 declare function createTimeout(ms: number, callback: () => void): CleanupTimer;
 /**
  * Creates an interval with automatic cleanup capability.
  *
- * Returns a cleanup function that can be called to cancel the interval.
- * The cleanup function is idempotent - calling it multiple times is safe.
+ * Returns a cleanup function that can be called to cancel the interval. The
+ * cleanup function is idempotent - calling it multiple times is safe.
+ *
+ * @example
+ *   ```typescript
+ *   const cleanup = createInterval(1000, () => {
+ *     console.log('Interval tick');
+ *   });
+ *
+ *   // Stop the interval
+ *   cleanup();
+ *   ```;
  *
  * @param ms - The interval duration in milliseconds
  * @param callback - The function to execute on each interval tick
  * @returns A cleanup function that cancels the interval when called
- *
- * @example
- * ```typescript
- * const cleanup = createInterval(1000, () => {
- *   console.log('Interval tick');
- * });
- *
- * // Stop the interval
- * cleanup();
- * ```
  */
 declare function createInterval(ms: number, callback: () => void): CleanupTimer;
 /**
  * Creates a timeout that prevents concurrent executions.
  *
- * Each call to the `call` function will cancel any previous pending timeout
- * and start a new one. This is useful for debouncing or ensuring only the
- * last call executes after a delay.
+ * Each call to the `call` function will cancel any previous pending timeout and
+ * start a new one. This is useful for debouncing or ensuring only the last call
+ * executes after a delay.
+ *
+ * @example
+ *   ```typescript
+ *   const { call, clean } = createDebouncedTimeout(1000, () => {
+ *     console.log('Only the last call executes');
+ *   });
+ *
+ *   call(); // This will be cancelled
+ *   call(); // This will be cancelled
+ *   call(); // Only this one will execute after 1000ms
+ *
+ *   // Or cancel all pending timeouts
+ *   clean();
+ *   ```;
  *
  * @param ms - The timeout duration in milliseconds
  * @param callback - The function to execute when the timeout completes
- * @returns An object with `call` to trigger the timeout and `clean` to cancel it
- *
- * @example
- * ```typescript
- * const { call, clean } = createDebouncedTimeout(1000, () => {
- *   console.log('Only the last call executes');
- * });
- *
- * call(); // This will be cancelled
- * call(); // This will be cancelled
- * call(); // Only this one will execute after 1000ms
- *
- * // Or cancel all pending timeouts
- * clean();
- * ```
+ * @returns An object with `call` to trigger the timeout and `clean` to cancel
+ *   it
  */
 declare function createDebouncedTimeout(ms: number, callback: () => void): {
     call: () => void;
@@ -73,32 +74,36 @@ declare function createDebouncedTimeout(ms: number, callback: () => void): {
 /**
  * Creates a timeout that waits for a condition to become true.
  *
- * Polls the condition function at regular intervals until it returns a truthy value,
- * then calls the callback with that value. If the condition doesn't become true
- * within the maximum wait time, the timeout expires without calling the callback.
+ * Polls the condition function at regular intervals until it returns a truthy
+ * value, then calls the callback with that value. If the condition doesn't
+ * become true within the maximum wait time, the timeout expires without calling
+ * the callback.
+ *
+ * @example
+ *   ```typescript
+ *   const cleanup = createWaitUntil({
+ *     condition: () => document.getElementById('myElement'),
+ *     maxWaitMs: 5000,
+ *     callback: (element) => {
+ *       console.log('Element found:', element);
+ *     },
+ *     checkIntervalMs: 50
+ *   });
+ *
+ *   // Cancel the condition check
+ *   cleanup();
+ *   ```;
  *
  * @template T - The type of value returned by the condition function when true
  * @param options - Configuration options
- * @param options.condition - Function that returns false or a truthy value when the condition is met
- * @param options.maxWaitMs - Maximum time to wait for the condition in milliseconds
+ * @param options.condition - Function that returns false or a truthy value when
+ *   the condition is met
+ * @param options.maxWaitMs - Maximum time to wait for the condition in
+ *   milliseconds
  * @param options.callback - Function to call when the condition becomes true
- * @param options.checkIntervalMs - How often to check the condition in milliseconds (default: 20)
+ * @param options.checkIntervalMs - How often to check the condition in
+ *   milliseconds (default: 20)
  * @returns A cleanup function that cancels the condition timeout
- *
- * @example
- * ```typescript
- * const cleanup = createWaitUntil({
- *   condition: () => document.getElementById('myElement'),
- *   maxWaitMs: 5000,
- *   callback: (element) => {
- *     console.log('Element found:', element);
- *   },
- *   checkIntervalMs: 50
- * });
- *
- * // Cancel the condition check
- * cleanup();
- * ```
  */
 declare function createWaitUntil<T extends NonNullable<unknown>>({ condition, maxWaitMs, callback, checkIntervalMs, }: {
     condition: () => false | T;