@ls-stack/utils 3.56.0 → 3.58.0

package/dist/arrayUtils.cjs

@@ -29,9 +29,11 @@ __export(arrayUtils_exports, {
   findBeforeIndex: () => findBeforeIndex,
   getAscIndexOrder: () => getAscIndexOrder,
   hasDuplicates: () => hasDuplicates,
+  intersperse: () => intersperse,
   isInArray: () => isInArray,
   rejectArrayUndefinedValues: () => rejectArrayUndefinedValues,
   rejectDuplicates: () => rejectDuplicates,
+  repeat: () => repeat,
   sortBy: () => sortBy,
   truncateArray: () => truncateArray
 });
@@ -176,6 +178,26 @@ function arrayOps(array) {
     findAndMap: (predicate) => findAndMap(array, predicate)
   };
 }
+function intersperse(array, separator) {
+  const result = [];
+  for (let i = 0; i < array.length; i++) {
+    result.push(array[i]);
+    if (i < array.length - 1) {
+      result.push(separator);
+    }
+  }
+  return result;
+}
+function repeat(value, count, separator) {
+  const result = [];
+  for (let i = 0; i < count; i++) {
+    result.push(value);
+    if (separator !== void 0 && i < count - 1) {
+      result.push(separator);
+    }
+  }
+  return result;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   arrayOps,
@@ -187,9 +209,11 @@ function arrayOps(array) {
   findBeforeIndex,
   getAscIndexOrder,
   hasDuplicates,
+  intersperse,
   isInArray,
   rejectArrayUndefinedValues,
   rejectDuplicates,
+  repeat,
   sortBy,
   truncateArray
 });

package/dist/arrayUtils.d.cts

@@ -82,25 +82,6 @@ declare function rejectArrayUndefinedValues<T extends unknown[]>(array: T): T;
 declare function hasDuplicates<T>(array: T[], getKey?: (item: T) => unknown): boolean;
 declare function rejectDuplicates<T>(array: T[], getKey?: (item: T) => unknown): T[];
 declare function truncateArray<T>(array: T[], maxLength: number, appendIfTruncated?: T | ((truncatedCount: number) => T)): T[];
-type ArrayOps<T> = {
-    /**
-     * Filter and map an array
-     *
-     * @example
-     *   const items = [1, 2, 3];
-     *
-     *   const enhancedItems = arrayOps(items);
-     *
-     *   enhancedItems.filterAndMap((item) => (item === 2 ? false : item));
-     *
-     * @param mapFilter - A function that takes an item and returns a value or
-     *   `false` to reject the item.
-     */
-    filterAndMap: <R>(mapFilter: (item: T, index: number) => false | R) => R[];
-    sortBy: (sortByValue: SortByValueFn<T>, props: SortByProps) => T[];
-    rejectDuplicates: (getKey: (item: T) => unknown) => T[];
-    findAndMap: <R>(predicate: (value: T) => R | false) => R | undefined;
-};
 /**
  * Finds the first item in an array where the predicate returns a non-false
  * value and returns that mapped value.
@@ -127,6 +108,25 @@ type ArrayOps<T> = {
  *   item matches
  */
 declare function findAndMap<T, R>(array: T[], predicate: (value: T) => R | false): R | undefined;
+type ArrayOps<T> = {
+    /**
+     * Filter and map an array
+     *
+     * @example
+     *   const items = [1, 2, 3];
+     *
+     *   const enhancedItems = arrayOps(items);
+     *
+     *   enhancedItems.filterAndMap((item) => (item === 2 ? false : item));
+     *
+     * @param mapFilter - A function that takes an item and returns a value or
+     *   `false` to reject the item.
+     */
+    filterAndMap: <R>(mapFilter: (item: T, index: number) => false | R) => R[];
+    sortBy: (sortByValue: SortByValueFn<T>, props: SortByProps) => T[];
+    rejectDuplicates: (getKey: (item: T) => unknown) => T[];
+    findAndMap: <R>(predicate: (value: T) => R | false) => R | undefined;
+};
 /**
  * Enhance an array with extra methods
  *
@@ -140,5 +140,30 @@ declare function findAndMap<T, R>(array: T[], predicate: (value: T) => R | false
  * @param array
  */
 declare function arrayOps<T>(array: T[]): ArrayOps<T>;
+/**
+ * Inserts a separator value between each element in an array.
+ *
+ * @example
+ *   intersperse([1, 2, 3], 0); // [1, 0, 2, 0, 3]
+ *
+ * @param array - The array to intersperse
+ * @param separator - The value to insert between elements
+ * @returns A new array with separator values inserted between elements
+ */
+declare function intersperse<T, I>(array: T[], separator: I): (T | I)[];
+/**
+ * Creates an array by repeating a value a specified number of times,
+ * optionally with a separator between each repetition.
+ *
+ * @example
+ *   repeat('x', 3); // ['x', 'x', 'x']
+ *   repeat('x', 3, '-'); // ['x', '-', 'x', '-', 'x']
+ *
+ * @param value - The value to repeat
+ * @param count - Number of times to repeat the value
+ * @param separator - Optional separator to insert between repetitions
+ * @returns A new array with the repeated values
+ */
+declare function repeat<T>(value: T, count: number, separator?: T): T[];
 
-export { type FilterAndMapReturn, type SortByProps, type SortByValueFn, arrayOps, arrayWithPrev, arrayWithPrevAndIndex, filterAndMap, findAfterIndex, findAndMap, findBeforeIndex, getAscIndexOrder, hasDuplicates, isInArray, rejectArrayUndefinedValues, rejectDuplicates, sortBy, truncateArray };
+export { type FilterAndMapReturn, type SortByProps, type SortByValueFn, arrayOps, arrayWithPrev, arrayWithPrevAndIndex, filterAndMap, findAfterIndex, findAndMap, findBeforeIndex, getAscIndexOrder, hasDuplicates, intersperse, isInArray, rejectArrayUndefinedValues, rejectDuplicates, repeat, sortBy, truncateArray };

package/dist/arrayUtils.d.ts

@@ -82,25 +82,6 @@ declare function rejectArrayUndefinedValues<T extends unknown[]>(array: T): T;
 declare function hasDuplicates<T>(array: T[], getKey?: (item: T) => unknown): boolean;
 declare function rejectDuplicates<T>(array: T[], getKey?: (item: T) => unknown): T[];
 declare function truncateArray<T>(array: T[], maxLength: number, appendIfTruncated?: T | ((truncatedCount: number) => T)): T[];
-type ArrayOps<T> = {
-    /**
-     * Filter and map an array
-     *
-     * @example
-     *   const items = [1, 2, 3];
-     *
-     *   const enhancedItems = arrayOps(items);
-     *
-     *   enhancedItems.filterAndMap((item) => (item === 2 ? false : item));
-     *
-     * @param mapFilter - A function that takes an item and returns a value or
-     *   `false` to reject the item.
-     */
-    filterAndMap: <R>(mapFilter: (item: T, index: number) => false | R) => R[];
-    sortBy: (sortByValue: SortByValueFn<T>, props: SortByProps) => T[];
-    rejectDuplicates: (getKey: (item: T) => unknown) => T[];
-    findAndMap: <R>(predicate: (value: T) => R | false) => R | undefined;
-};
 /**
  * Finds the first item in an array where the predicate returns a non-false
  * value and returns that mapped value.
@@ -127,6 +108,25 @@ type ArrayOps<T> = {
  *   item matches
  */
 declare function findAndMap<T, R>(array: T[], predicate: (value: T) => R | false): R | undefined;
+type ArrayOps<T> = {
+    /**
+     * Filter and map an array
+     *
+     * @example
+     *   const items = [1, 2, 3];
+     *
+     *   const enhancedItems = arrayOps(items);
+     *
+     *   enhancedItems.filterAndMap((item) => (item === 2 ? false : item));
+     *
+     * @param mapFilter - A function that takes an item and returns a value or
+     *   `false` to reject the item.
+     */
+    filterAndMap: <R>(mapFilter: (item: T, index: number) => false | R) => R[];
+    sortBy: (sortByValue: SortByValueFn<T>, props: SortByProps) => T[];
+    rejectDuplicates: (getKey: (item: T) => unknown) => T[];
+    findAndMap: <R>(predicate: (value: T) => R | false) => R | undefined;
+};
 /**
  * Enhance an array with extra methods
  *
@@ -140,5 +140,30 @@ declare function findAndMap<T, R>(array: T[], predicate: (value: T) => R | false
  * @param array
  */
 declare function arrayOps<T>(array: T[]): ArrayOps<T>;
+/**
+ * Inserts a separator value between each element in an array.
+ *
+ * @example
+ *   intersperse([1, 2, 3], 0); // [1, 0, 2, 0, 3]
+ *
+ * @param array - The array to intersperse
+ * @param separator - The value to insert between elements
+ * @returns A new array with separator values inserted between elements
+ */
+declare function intersperse<T, I>(array: T[], separator: I): (T | I)[];
+/**
+ * Creates an array by repeating a value a specified number of times,
+ * optionally with a separator between each repetition.
+ *
+ * @example
+ *   repeat('x', 3); // ['x', 'x', 'x']
+ *   repeat('x', 3, '-'); // ['x', '-', 'x', '-', 'x']
+ *
+ * @param value - The value to repeat
+ * @param count - Number of times to repeat the value
+ * @param separator - Optional separator to insert between repetitions
+ * @returns A new array with the repeated values
+ */
+declare function repeat<T>(value: T, count: number, separator?: T): T[];
 
-export { type FilterAndMapReturn, type SortByProps, type SortByValueFn, arrayOps, arrayWithPrev, arrayWithPrevAndIndex, filterAndMap, findAfterIndex, findAndMap, findBeforeIndex, getAscIndexOrder, hasDuplicates, isInArray, rejectArrayUndefinedValues, rejectDuplicates, sortBy, truncateArray };
+export { type FilterAndMapReturn, type SortByProps, type SortByValueFn, arrayOps, arrayWithPrev, arrayWithPrevAndIndex, filterAndMap, findAfterIndex, findAndMap, findBeforeIndex, getAscIndexOrder, hasDuplicates, intersperse, isInArray, rejectArrayUndefinedValues, rejectDuplicates, repeat, sortBy, truncateArray };

package/dist/arrayUtils.js

@@ -8,12 +8,14 @@ import {
   findBeforeIndex,
   getAscIndexOrder,
   hasDuplicates,
+  intersperse,
   isInArray,
   rejectArrayUndefinedValues,
   rejectDuplicates,
+  repeat,
   sortBy,
   truncateArray
-} from "./chunk-27AL66CH.js";
+} from "./chunk-BT3UMATU.js";
 import "./chunk-C2SVCIWE.js";
 import "./chunk-JF2MDHOJ.js";
 export {
@@ -26,9 +28,11 @@ export {
   findBeforeIndex,
   getAscIndexOrder,
   hasDuplicates,
+  intersperse,
   isInArray,
   rejectArrayUndefinedValues,
   rejectDuplicates,
+  repeat,
   sortBy,
   truncateArray
 };

package/dist/asyncQueue.js

@@ -3,8 +3,8 @@ import {
 } from "./chunk-DFXNVEH6.js";
 import {
   durationObjToMs
-} from "./chunk-5MNYPLZI.js";
-import "./chunk-HTCYUMDR.js";
+} from "./chunk-6FBIEPWU.js";
+import "./chunk-DBOWTYR4.js";
 import "./chunk-II4R3VVX.js";
 
 // src/asyncQueue.ts

package/dist/cache.js

@@ -4,9 +4,9 @@ import {
   cachedGetter,
   createCache,
   fastCache
-} from "./chunk-AULH7VMS.js";
-import "./chunk-5MNYPLZI.js";
-import "./chunk-HTCYUMDR.js";
+} from "./chunk-DX2524CZ.js";
+import "./chunk-6FBIEPWU.js";
+import "./chunk-DBOWTYR4.js";
 import "./chunk-II4R3VVX.js";
 import "./chunk-C2SVCIWE.js";
 import "./chunk-JF2MDHOJ.js";

package/dist/{chunk-5MNYPLZI.js → chunk-6FBIEPWU.js}

@@ -1,6 +1,6 @@
 import {
   clampMax
-} from "./chunk-HTCYUMDR.js";
+} from "./chunk-DBOWTYR4.js";
 import {
   castToNumber
 } from "./chunk-II4R3VVX.js";

package/dist/{chunk-27AL66CH.js → chunk-BT3UMATU.js}

@@ -133,6 +133,26 @@ function arrayOps(array) {
     findAndMap: (predicate) => findAndMap(array, predicate)
   };
 }
+function intersperse(array, separator) {
+  const result = [];
+  for (let i = 0; i < array.length; i++) {
+    result.push(array[i]);
+    if (i < array.length - 1) {
+      result.push(separator);
+    }
+  }
+  return result;
+}
+function repeat(value, count, separator) {
+  const result = [];
+  for (let i = 0; i < count; i++) {
+    result.push(value);
+    if (separator !== void 0 && i < count - 1) {
+      result.push(separator);
+    }
+  }
+  return result;
+}
 
 export {
   filterAndMap,
@@ -148,5 +168,7 @@ export {
   rejectDuplicates,
   truncateArray,
   findAndMap,
-  arrayOps
+  arrayOps,
+  intersperse,
+  repeat
 };

package/dist/{chunk-NW5H5EW7.js → chunk-CCUPDGSZ.js}

@@ -1,5 +1,8 @@
 // src/debounce.ts
 function debounce(func, wait, options) {
+  let currentCallback = func;
+  let waitMs = wait;
+  let currentOptions = options;
   let lastArgs;
   let lastThis;
   let maxWait;
@@ -10,35 +13,37 @@ function debounce(func, wait, options) {
   let leading = false;
   let maxing = false;
   let trailing = true;
-  if (options) {
-    leading = !!options.leading;
-    maxing = "maxWait" in options;
-    maxWait = maxing ? Math.max(options.maxWait || 0, wait) : maxWait;
-    trailing = "trailing" in options ? !!options.trailing : trailing;
+  function applyOptions() {
+    const opts = currentOptions;
+    leading = !!opts?.leading;
+    trailing = opts && "trailing" in opts ? !!opts.trailing : true;
+    maxing = !!(opts && "maxWait" in opts);
+    maxWait = maxing ? Math.max(opts?.maxWait ?? 0, waitMs) : void 0;
   }
+  applyOptions();
   function invokeFunc(time) {
     const args = lastArgs;
     const thisArg = lastThis;
     lastArgs = lastThis = void 0;
     lastInvokeTime = time;
-    result = func.apply(thisArg, args);
+    result = currentCallback.apply(thisArg, args);
     return result;
   }
   function leadingEdge(time) {
     lastInvokeTime = time;
-    timerId = setTimeout(timerExpired, wait);
+    timerId = setTimeout(timerExpired, waitMs);
     return leading ? invokeFunc(time) : result;
   }
   function remainingWait(time) {
     const timeSinceLastCall = time - (lastCallTime ?? 0);
     const timeSinceLastInvoke = time - lastInvokeTime;
-    const timeWaiting = wait - timeSinceLastCall;
+    const timeWaiting = waitMs - timeSinceLastCall;
     return maxing ? Math.min(timeWaiting, (maxWait ?? 0) - timeSinceLastInvoke) : timeWaiting;
   }
   function shouldInvoke(time) {
     const timeSinceLastCall = time - (lastCallTime ?? 0);
     const timeSinceLastInvoke = time - lastInvokeTime;
-    return lastCallTime === void 0 || timeSinceLastCall >= wait || timeSinceLastCall < 0 || maxing && timeSinceLastInvoke >= (maxWait ?? 0);
+    return lastCallTime === void 0 || timeSinceLastCall >= waitMs || timeSinceLastCall < 0 || maxing && timeSinceLastInvoke >= (maxWait ?? 0);
   }
   function timerExpired() {
     const time = Date.now();
@@ -65,6 +70,30 @@ function debounce(func, wait, options) {
   function flush() {
     return timerId === void 0 ? result : trailingEdge(Date.now());
   }
+  function pending() {
+    return timerId !== void 0;
+  }
+  function updateCb(callback) {
+    currentCallback = callback;
+  }
+  function updateParams(newWait, newOptions) {
+    waitMs = newWait;
+    if (newOptions !== void 0) {
+      currentOptions = newOptions;
+    }
+    applyOptions();
+    if (timerId !== void 0) {
+      const time = Date.now();
+      const shouldRun = shouldInvoke(time);
+      clearTimeout(timerId);
+      if (shouldRun) {
+        timerId = setTimeout(timerExpired, 0);
+      } else {
+        const delay = remainingWait(time);
+        timerId = setTimeout(timerExpired, delay > 0 ? delay : 0);
+      }
+    }
+  }
   function debounced() {
     const time = Date.now();
     const isInvoking = shouldInvoke(time);
@@ -77,21 +106,24 @@ function debounce(func, wait, options) {
       }
       if (maxing) {
         clearTimeout(timerId);
-        timerId = setTimeout(timerExpired, wait);
+        timerId = setTimeout(timerExpired, waitMs);
         return invokeFunc(lastCallTime);
       }
     }
     if (timerId === void 0) {
-      timerId = setTimeout(timerExpired, wait);
+      timerId = setTimeout(timerExpired, waitMs);
     }
     return result;
   }
   debounced.cancel = cancel;
   debounced.flush = flush;
+  debounced.pending = pending;
+  debounced.updateCb = updateCb;
+  debounced.updateParams = updateParams;
   return debounced;
 }
 function isDebouncedFn(fn) {
-  return typeof fn === "function" && "cancel" in fn && "flush" in fn;
+  return typeof fn === "function" && "cancel" in fn && typeof fn.cancel === "function" && "flush" in fn && typeof fn.flush === "function" && "pending" in fn && typeof fn.pending === "function" && "updateCb" in fn && typeof fn.updateCb === "function" && "updateParams" in fn && typeof fn.updateParams === "function";
 }
 
 export {

package/dist/chunk-DBOWTYR4.js

@@ -0,0 +1,49 @@
+// src/mathUtils.ts
+function clampMax(value, max) {
+  return value > max ? max : value;
+}
+function clampMin(value, min) {
+  return value < min ? min : value;
+}
+function clampRange(num, v1, v2) {
+  if (v2 > v1) {
+    return clamp(num, v1, v2);
+  }
+  return clamp(num, v2, v1);
+}
+function clamp(num, min, max) {
+  return num > max ? max : num < min ? min : num;
+}
+function fixFloatingPointNumber(value) {
+  return Number(value.toPrecision(15));
+}
+function roundToStep(value, step, offset = 0) {
+  const inv = 1 / step;
+  const snapped = Math.round((value - offset) * inv) / inv + offset;
+  return Number(snapped.toFixed(12));
+}
+function floorToStep(value, step, offset = 0) {
+  const inv = 1 / step;
+  const snapped = Math.floor((value - offset) * inv) / inv + offset;
+  return Number(snapped.toFixed(12));
+}
+function ceilToStep(value, step, offset = 0) {
+  const inv = 1 / step;
+  const snapped = Math.ceil((value - offset) * inv) / inv + offset;
+  return Number(snapped.toFixed(12));
+}
+function round(num, precision) {
+  return Math.round(num * 10 ** precision) / 10 ** precision;
+}
+
+export {
+  clampMax,
+  clampMin,
+  clampRange,
+  clamp,
+  fixFloatingPointNumber,
+  roundToStep,
+  floorToStep,
+  ceilToStep,
+  round
+};

package/dist/{chunk-AULH7VMS.js → chunk-DX2524CZ.js}

@@ -1,6 +1,6 @@
 import {
   durationObjToMs
-} from "./chunk-5MNYPLZI.js";
+} from "./chunk-6FBIEPWU.js";
 import {
   isPromise
 } from "./chunk-C2SVCIWE.js";

package/dist/{chunk-6CG6JZKB.js → chunk-LBBC55GE.js}

@@ -1,6 +1,6 @@
 import {
   sortBy
-} from "./chunk-27AL66CH.js";
+} from "./chunk-BT3UMATU.js";
 import {
   isPlainObject
 } from "./chunk-JF2MDHOJ.js";

package/dist/{chunk-Y76LZUOB.js → chunk-WNFRB7P6.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-GMJTLFM6.js";
 import {
   sortBy
-} from "./chunk-27AL66CH.js";
+} from "./chunk-BT3UMATU.js";
 
 // src/objUtils.ts
 import { Result } from "t-result";

package/dist/concurrentCalls.js

@@ -1,15 +1,15 @@
-import {
-  safeJsonStringify
-} from "./chunk-VAAMRG4K.js";
 import {
   truncateString
 } from "./chunk-BM4PYVOX.js";
+import {
+  safeJsonStringify
+} from "./chunk-VAAMRG4K.js";
 import {
   sleep
 } from "./chunk-5DZT3Z5Z.js";
 import {
   truncateArray
-} from "./chunk-27AL66CH.js";
+} from "./chunk-BT3UMATU.js";
 import {
   invariant
 } from "./chunk-C2SVCIWE.js";

package/dist/createThrottleController.js

@@ -3,8 +3,8 @@ import {
 } from "./chunk-7CQPOM5I.js";
 import {
   durationObjToMs
-} from "./chunk-5MNYPLZI.js";
-import "./chunk-HTCYUMDR.js";
+} from "./chunk-6FBIEPWU.js";
+import "./chunk-DBOWTYR4.js";
 import "./chunk-II4R3VVX.js";
 import "./chunk-C2SVCIWE.js";
 import "./chunk-JF2MDHOJ.js";

package/dist/debounce.cjs

@@ -25,6 +25,9 @@ __export(debounce_exports, {
 });
 module.exports = __toCommonJS(debounce_exports);
 function debounce(func, wait, options) {
+  let currentCallback = func;
+  let waitMs = wait;
+  let currentOptions = options;
   let lastArgs;
   let lastThis;
   let maxWait;
@@ -35,35 +38,37 @@ function debounce(func, wait, options) {
   let leading = false;
   let maxing = false;
   let trailing = true;
-  if (options) {
-    leading = !!options.leading;
-    maxing = "maxWait" in options;
-    maxWait = maxing ? Math.max(options.maxWait || 0, wait) : maxWait;
-    trailing = "trailing" in options ? !!options.trailing : trailing;
+  function applyOptions() {
+    const opts = currentOptions;
+    leading = !!opts?.leading;
+    trailing = opts && "trailing" in opts ? !!opts.trailing : true;
+    maxing = !!(opts && "maxWait" in opts);
+    maxWait = maxing ? Math.max(opts?.maxWait ?? 0, waitMs) : void 0;
   }
+  applyOptions();
   function invokeFunc(time) {
     const args = lastArgs;
     const thisArg = lastThis;
     lastArgs = lastThis = void 0;
     lastInvokeTime = time;
-    result = func.apply(thisArg, args);
+    result = currentCallback.apply(thisArg, args);
     return result;
   }
   function leadingEdge(time) {
     lastInvokeTime = time;
-    timerId = setTimeout(timerExpired, wait);
+    timerId = setTimeout(timerExpired, waitMs);
     return leading ? invokeFunc(time) : result;
   }
   function remainingWait(time) {
     const timeSinceLastCall = time - (lastCallTime ?? 0);
     const timeSinceLastInvoke = time - lastInvokeTime;
-    const timeWaiting = wait - timeSinceLastCall;
+    const timeWaiting = waitMs - timeSinceLastCall;
     return maxing ? Math.min(timeWaiting, (maxWait ?? 0) - timeSinceLastInvoke) : timeWaiting;
   }
   function shouldInvoke(time) {
     const timeSinceLastCall = time - (lastCallTime ?? 0);
     const timeSinceLastInvoke = time - lastInvokeTime;
-    return lastCallTime === void 0 || timeSinceLastCall >= wait || timeSinceLastCall < 0 || maxing && timeSinceLastInvoke >= (maxWait ?? 0);
+    return lastCallTime === void 0 || timeSinceLastCall >= waitMs || timeSinceLastCall < 0 || maxing && timeSinceLastInvoke >= (maxWait ?? 0);
   }
   function timerExpired() {
     const time = Date.now();
@@ -90,6 +95,30 @@ function debounce(func, wait, options) {
   function flush() {
     return timerId === void 0 ? result : trailingEdge(Date.now());
   }
+  function pending() {
+    return timerId !== void 0;
+  }
+  function updateCb(callback) {
+    currentCallback = callback;
+  }
+  function updateParams(newWait, newOptions) {
+    waitMs = newWait;
+    if (newOptions !== void 0) {
+      currentOptions = newOptions;
+    }
+    applyOptions();
+    if (timerId !== void 0) {
+      const time = Date.now();
+      const shouldRun = shouldInvoke(time);
+      clearTimeout(timerId);
+      if (shouldRun) {
+        timerId = setTimeout(timerExpired, 0);
+      } else {
+        const delay = remainingWait(time);
+        timerId = setTimeout(timerExpired, delay > 0 ? delay : 0);
+      }
+    }
+  }
   function debounced() {
     const time = Date.now();
     const isInvoking = shouldInvoke(time);
@@ -102,21 +131,24 @@ function debounce(func, wait, options) {
       }
       if (maxing) {
         clearTimeout(timerId);
-        timerId = setTimeout(timerExpired, wait);
+        timerId = setTimeout(timerExpired, waitMs);
         return invokeFunc(lastCallTime);
       }
     }
     if (timerId === void 0) {
-      timerId = setTimeout(timerExpired, wait);
+      timerId = setTimeout(timerExpired, waitMs);
     }
     return result;
   }
   debounced.cancel = cancel;
   debounced.flush = flush;
+  debounced.pending = pending;
+  debounced.updateCb = updateCb;
+  debounced.updateParams = updateParams;
   return debounced;
 }
 function isDebouncedFn(fn) {
-  return typeof fn === "function" && "cancel" in fn && "flush" in fn;
+  return typeof fn === "function" && "cancel" in fn && typeof fn.cancel === "function" && "flush" in fn && typeof fn.flush === "function" && "pending" in fn && typeof fn.pending === "function" && "updateCb" in fn && typeof fn.updateCb === "function" && "updateParams" in fn && typeof fn.updateParams === "function";
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/debounce.d.cts

@@ -27,11 +27,20 @@ interface DebouncedFunc<T extends (...args: any[]) => void> {
      * debounced function was never invoked.
      */
     flush: () => ReturnType<T> | undefined;
+    /** Return true if the debounced function still has a scheduled run. */
+    pending: () => boolean;
+    /** Update the debounced function with a new callback. */
+    updateCb: (callback: T) => void;
+    /** Update the debounce wait and options while keeping scheduled runs. */
+    updateParams: (wait: number, options?: DebounceOptions) => void;
 }
 declare function debounce<T extends (...args: any[]) => void>(func: T, wait: number, options?: DebounceOptions): DebouncedFunc<T>;
 declare function isDebouncedFn<T extends (...args: any[]) => void>(fn: T): fn is T & {
     cancel: () => void;
     flush: () => ReturnType<T> | undefined;
+    pending: () => boolean;
+    updateCb: (callback: T) => void;
+    updateParams: (wait: number, options?: DebounceOptions) => void;
 };
 
 export { type DebounceOptions, type DebouncedFunc, debounce, isDebouncedFn };