@ls-stack/utils 3.57.0 → 3.59.0

package/dist/arrayUtils.cjs

@@ -31,6 +31,7 @@ __export(arrayUtils_exports, {
   hasDuplicates: () => hasDuplicates,
   intersperse: () => intersperse,
   isInArray: () => isInArray,
+  looseIsInArray: () => looseIsInArray,
   rejectArrayUndefinedValues: () => rejectArrayUndefinedValues,
   rejectDuplicates: () => rejectDuplicates,
   repeat: () => repeat,
@@ -105,6 +106,9 @@ function isInArray(value, oneOf) {
   }
   return false;
 }
+function looseIsInArray(value, array) {
+  return array.includes(value);
+}
 function findAfterIndex(array, index, predicate) {
   for (let i = index + 1; i < array.length; i++) {
     if (predicate(array[i])) {
@@ -211,6 +215,7 @@ function repeat(value, count, separator) {
   hasDuplicates,
   intersperse,
   isInArray,
+  looseIsInArray,
   rejectArrayUndefinedValues,
   rejectDuplicates,
   repeat,

package/dist/arrayUtils.d.cts

@@ -76,6 +76,7 @@ declare function arrayWithPrevAndIndex<T>(array: T[]): {
     index: number;
 }[];
 declare function isInArray<T, const U extends T>(value: T, oneOf: readonly U[]): value is U;
+declare function looseIsInArray(value: unknown, array: readonly unknown[]): boolean;
 declare function findAfterIndex<T>(array: T[], index: number, predicate: (item: T) => boolean): T | undefined;
 declare function findBeforeIndex<T>(array: T[], index: number, predicate: (item: T) => boolean): T | undefined;
 declare function rejectArrayUndefinedValues<T extends unknown[]>(array: T): T;
@@ -152,8 +153,8 @@ declare function arrayOps<T>(array: T[]): ArrayOps<T>;
  */
 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.
+ * 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']
@@ -166,4 +167,4 @@ declare function intersperse<T, I>(array: T[], separator: I): (T | I)[];
  */
 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, intersperse, isInArray, rejectArrayUndefinedValues, rejectDuplicates, repeat, sortBy, truncateArray };
+export { type FilterAndMapReturn, type SortByProps, type SortByValueFn, arrayOps, arrayWithPrev, arrayWithPrevAndIndex, filterAndMap, findAfterIndex, findAndMap, findBeforeIndex, getAscIndexOrder, hasDuplicates, intersperse, isInArray, looseIsInArray, rejectArrayUndefinedValues, rejectDuplicates, repeat, sortBy, truncateArray };

package/dist/arrayUtils.d.ts

@@ -76,6 +76,7 @@ declare function arrayWithPrevAndIndex<T>(array: T[]): {
     index: number;
 }[];
 declare function isInArray<T, const U extends T>(value: T, oneOf: readonly U[]): value is U;
+declare function looseIsInArray(value: unknown, array: readonly unknown[]): boolean;
 declare function findAfterIndex<T>(array: T[], index: number, predicate: (item: T) => boolean): T | undefined;
 declare function findBeforeIndex<T>(array: T[], index: number, predicate: (item: T) => boolean): T | undefined;
 declare function rejectArrayUndefinedValues<T extends unknown[]>(array: T): T;
@@ -152,8 +153,8 @@ declare function arrayOps<T>(array: T[]): ArrayOps<T>;
  */
 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.
+ * 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']
@@ -166,4 +167,4 @@ declare function intersperse<T, I>(array: T[], separator: I): (T | I)[];
  */
 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, intersperse, isInArray, rejectArrayUndefinedValues, rejectDuplicates, repeat, sortBy, truncateArray };
+export { type FilterAndMapReturn, type SortByProps, type SortByValueFn, arrayOps, arrayWithPrev, arrayWithPrevAndIndex, filterAndMap, findAfterIndex, findAndMap, findBeforeIndex, getAscIndexOrder, hasDuplicates, intersperse, isInArray, looseIsInArray, rejectArrayUndefinedValues, rejectDuplicates, repeat, sortBy, truncateArray };

package/dist/arrayUtils.js

@@ -10,12 +10,13 @@ import {
   hasDuplicates,
   intersperse,
   isInArray,
+  looseIsInArray,
   rejectArrayUndefinedValues,
   rejectDuplicates,
   repeat,
   sortBy,
   truncateArray
-} from "./chunk-BT3UMATU.js";
+} from "./chunk-GVIDV772.js";
 import "./chunk-C2SVCIWE.js";
 import "./chunk-JF2MDHOJ.js";
 export {
@@ -30,6 +31,7 @@ export {
   hasDuplicates,
   intersperse,
   isInArray,
+  looseIsInArray,
   rejectArrayUndefinedValues,
   rejectDuplicates,
   repeat,

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-LBBC55GE.js → chunk-2LO5FYP5.js}

@@ -1,6 +1,6 @@
 import {
   sortBy
-} from "./chunk-BT3UMATU.js";
+} from "./chunk-GVIDV772.js";
 import {
   isPlainObject
 } from "./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-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-BT3UMATU.js → chunk-GVIDV772.js}

@@ -60,6 +60,9 @@ function isInArray(value, oneOf) {
   }
   return false;
 }
+function looseIsInArray(value, array) {
+  return array.includes(value);
+}
 function findAfterIndex(array, index, predicate) {
   for (let i = index + 1; i < array.length; i++) {
     if (predicate(array[i])) {
@@ -161,6 +164,7 @@ export {
   arrayWithPrev,
   arrayWithPrevAndIndex,
   isInArray,
+  looseIsInArray,
   findAfterIndex,
   findBeforeIndex,
   rejectArrayUndefinedValues,

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

@@ -3,7 +3,7 @@ import {
 } from "./chunk-GMJTLFM6.js";
 import {
   sortBy
-} from "./chunk-BT3UMATU.js";
+} from "./chunk-GVIDV772.js";
 
 // src/objUtils.ts
 import { Result } from "t-result";
@@ -17,14 +17,16 @@ function pick(obj, keys) {
   }
   return result;
 }
-function mapArrayToObject(array, mapper) {
+function mapArrToObj(array, mapper) {
   return Object.fromEntries(array.map(mapper));
 }
-function mapObjectToObject(obj, mapper) {
+var mapArrayToObject = mapArrToObj;
+function mapObjToObj(obj, mapper) {
   return Object.fromEntries(
     objectTypedEntries(obj).map(([key, value]) => mapper(key, value))
   );
 }
+var mapObjectToObject = mapObjToObj;
 function omit(obj, keys) {
   const result = {};
   for (const key of Object.keys(obj)) {
@@ -136,16 +138,41 @@ function parsePath(path) {
 function isNumericString(str) {
   return /^\d+$/.test(str);
 }
+function getObjPropertyOrInsert(obj, prop, insertValue) {
+  if (obj[prop] === void 0) {
+    obj[prop] = insertValue();
+  }
+  return obj[prop];
+}
+function addPrefixToObjKeys(obj, prefix) {
+  const newObj = {};
+  for (const [key, value] of Object.entries(obj)) {
+    newObj[`${prefix}${key}`] = value;
+  }
+  return newObj;
+}
+function addSuffixToObjKeys(obj, suffix) {
+  const newObj = {};
+  for (const [key, value] of Object.entries(obj)) {
+    newObj[`${key}${suffix}`] = value;
+  }
+  return newObj;
+}
 
 export {
   objectTypedEntries,
   pick,
+  mapArrToObj,
   mapArrayToObject,
+  mapObjToObj,
   mapObjectToObject,
   omit,
   looseGetObjectProperty,
   rejectObjUndefinedValues,
   filterObjectKeys,
   sortObjectKeys,
-  getValueFromPath
+  getValueFromPath,
+  getObjPropertyOrInsert,
+  addPrefixToObjKeys,
+  addSuffixToObjKeys
 };

package/dist/concurrentCalls.js

@@ -9,7 +9,7 @@ import {
 } from "./chunk-5DZT3Z5Z.js";
 import {
   truncateArray
-} from "./chunk-BT3UMATU.js";
+} from "./chunk-GVIDV772.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 };

package/dist/debounce.d.ts

@@ -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 };

package/dist/debounce.js

@@ -1,7 +1,7 @@
 import {
   debounce,
   isDebouncedFn
-} from "./chunk-NW5H5EW7.js";
+} from "./chunk-CCUPDGSZ.js";
 export {
   debounce,
   isDebouncedFn

package/dist/filterObjectOrArrayKeys.js

@@ -1,7 +1,7 @@
 import {
   filterObjectOrArrayKeys
-} from "./chunk-LBBC55GE.js";
-import "./chunk-BT3UMATU.js";
+} from "./chunk-2LO5FYP5.js";
+import "./chunk-GVIDV772.js";
 import "./chunk-C2SVCIWE.js";
 import "./chunk-JF2MDHOJ.js";
 export {

package/dist/interpolate.js

@@ -2,7 +2,7 @@ import {
   clampMax,
   clampMin,
   clampRange
-} from "./chunk-HTCYUMDR.js";
+} from "./chunk-DBOWTYR4.js";
 import {
   invariant
 } from "./chunk-C2SVCIWE.js";

package/dist/matchPath.js

@@ -1,8 +1,8 @@
 import {
   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/mathUtils.cjs

@@ -20,11 +20,15 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/mathUtils.ts
 var mathUtils_exports = {};
 __export(mathUtils_exports, {
+  ceilToStep: () => ceilToStep,
   clamp: () => clamp,
   clampMax: () => clampMax,
   clampMin: () => clampMin,
   clampRange: () => clampRange,
-  fixFloatingPointNumber: () => fixFloatingPointNumber
+  fixFloatingPointNumber: () => fixFloatingPointNumber,
+  floorToStep: () => floorToStep,
+  round: () => round,
+  roundToStep: () => roundToStep
 });
 module.exports = __toCommonJS(mathUtils_exports);
 function clampMax(value, max) {
@@ -45,11 +49,33 @@ function clamp(num, min, max) {
 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;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  ceilToStep,
   clamp,
   clampMax,
   clampMin,
   clampRange,
-  fixFloatingPointNumber
+  fixFloatingPointNumber,
+  floorToStep,
+  round,
+  roundToStep
 });

package/dist/mathUtils.d.cts

@@ -3,5 +3,52 @@ declare function clampMin(value: number, min: number): number;
 declare function clampRange(num: number, v1: number, v2: number): number;
 declare function clamp(num: number, min: number, max: number): number;
 declare function fixFloatingPointNumber(value: number): number;
+/**
+ * Rounds a number to the nearest multiple of the specified step value.
+ *
+ * @param value - The number to round
+ * @param step - The step size to round to
+ * @param offset - Optional offset to shift the rounding grid
+ * @returns The rounded value
+ *
+ * @example
+ * roundToStep(23, 5) // 25 (nearest multiple of 5)
+ */
+declare function roundToStep(value: number, step: number, offset?: number): number;
+/**
+ * Floors a number down to the nearest multiple of the specified step value.
+ *
+ * @param value - The number to floor
+ * @param step - The step size to floor to
+ * @param offset - Optional offset to shift the flooring grid
+ * @returns The floored value
+ *
+ * @example
+ * floorToStep(23, 5) // 20 (largest multiple of 5 ≤ 23)
+ */
+declare function floorToStep(value: number, step: number, offset?: number): number;
+/**
+ * Ceils a number up to the nearest multiple of the specified step value.
+ *
+ * @param value - The number to ceil
+ * @param step - The step size to ceil to
+ * @param offset - Optional offset to shift the ceiling grid
+ * @returns The ceiled value
+ *
+ * @example
+ * ceilToStep(23, 5) // 25 (smallest multiple of 5 ≥ 23)
+ */
+declare function ceilToStep(value: number, step: number, offset?: number): number;
+/**
+ * Rounds a number to the specified number of decimal places.
+ *
+ * @param num - The number to round
+ * @param precision - Number of decimal places
+ * @returns The rounded number
+ *
+ * @example
+ * round(3.14159, 2) // 3.14
+ */
+declare function round(num: number, precision: number): number;
 
-export { clamp, clampMax, clampMin, clampRange, fixFloatingPointNumber };
+export { ceilToStep, clamp, clampMax, clampMin, clampRange, fixFloatingPointNumber, floorToStep, round, roundToStep };

package/dist/mathUtils.d.ts

@@ -3,5 +3,52 @@ declare function clampMin(value: number, min: number): number;
 declare function clampRange(num: number, v1: number, v2: number): number;
 declare function clamp(num: number, min: number, max: number): number;
 declare function fixFloatingPointNumber(value: number): number;
+/**
+ * Rounds a number to the nearest multiple of the specified step value.
+ *
+ * @param value - The number to round
+ * @param step - The step size to round to
+ * @param offset - Optional offset to shift the rounding grid
+ * @returns The rounded value
+ *
+ * @example
+ * roundToStep(23, 5) // 25 (nearest multiple of 5)
+ */
+declare function roundToStep(value: number, step: number, offset?: number): number;
+/**
+ * Floors a number down to the nearest multiple of the specified step value.
+ *
+ * @param value - The number to floor
+ * @param step - The step size to floor to
+ * @param offset - Optional offset to shift the flooring grid
+ * @returns The floored value
+ *
+ * @example
+ * floorToStep(23, 5) // 20 (largest multiple of 5 ≤ 23)
+ */
+declare function floorToStep(value: number, step: number, offset?: number): number;
+/**
+ * Ceils a number up to the nearest multiple of the specified step value.
+ *
+ * @param value - The number to ceil
+ * @param step - The step size to ceil to
+ * @param offset - Optional offset to shift the ceiling grid
+ * @returns The ceiled value
+ *
+ * @example
+ * ceilToStep(23, 5) // 25 (smallest multiple of 5 ≥ 23)
+ */
+declare function ceilToStep(value: number, step: number, offset?: number): number;
+/**
+ * Rounds a number to the specified number of decimal places.
+ *
+ * @param num - The number to round
+ * @param precision - Number of decimal places
+ * @returns The rounded number
+ *
+ * @example
+ * round(3.14159, 2) // 3.14
+ */
+declare function round(num: number, precision: number): number;
 
-export { clamp, clampMax, clampMin, clampRange, fixFloatingPointNumber };
+export { ceilToStep, clamp, clampMax, clampMin, clampRange, fixFloatingPointNumber, floorToStep, round, roundToStep };

package/dist/mathUtils.js

@@ -1,14 +1,22 @@
 import {
+  ceilToStep,
   clamp,
   clampMax,
   clampMin,
   clampRange,
-  fixFloatingPointNumber
-} from "./chunk-HTCYUMDR.js";
+  fixFloatingPointNumber,
+  floorToStep,
+  round,
+  roundToStep
+} from "./chunk-DBOWTYR4.js";
 export {
+  ceilToStep,
   clamp,
   clampMax,
   clampMin,
   clampRange,
-  fixFloatingPointNumber
+  fixFloatingPointNumber,
+  floorToStep,
+  round,
+  roundToStep
 };

package/dist/objUtils.cjs

@@ -20,10 +20,15 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/objUtils.ts
 var objUtils_exports = {};
 __export(objUtils_exports, {
+  addPrefixToObjKeys: () => addPrefixToObjKeys,
+  addSuffixToObjKeys: () => addSuffixToObjKeys,
   filterObjectKeys: () => filterObjectKeys,
+  getObjPropertyOrInsert: () => getObjPropertyOrInsert,
   getValueFromPath: () => getValueFromPath,
   looseGetObjectProperty: () => looseGetObjectProperty,
+  mapArrToObj: () => mapArrToObj,
   mapArrayToObject: () => mapArrayToObject,
+  mapObjToObj: () => mapObjToObj,
   mapObjectToObject: () => mapObjectToObject,
   objectTypedEntries: () => objectTypedEntries,
   omit: () => omit,
@@ -76,14 +81,16 @@ function pick(obj, keys) {
   }
   return result;
 }
-function mapArrayToObject(array, mapper) {
+function mapArrToObj(array, mapper) {
   return Object.fromEntries(array.map(mapper));
 }
-function mapObjectToObject(obj, mapper) {
+var mapArrayToObject = mapArrToObj;
+function mapObjToObj(obj, mapper) {
   return Object.fromEntries(
     objectTypedEntries(obj).map(([key, value]) => mapper(key, value))
   );
 }
+var mapObjectToObject = mapObjToObj;
 function omit(obj, keys) {
   const result = {};
   for (const key of Object.keys(obj)) {
@@ -195,12 +202,37 @@ function parsePath(path) {
 function isNumericString(str) {
   return /^\d+$/.test(str);
 }
+function getObjPropertyOrInsert(obj, prop, insertValue) {
+  if (obj[prop] === void 0) {
+    obj[prop] = insertValue();
+  }
+  return obj[prop];
+}
+function addPrefixToObjKeys(obj, prefix) {
+  const newObj = {};
+  for (const [key, value] of Object.entries(obj)) {
+    newObj[`${prefix}${key}`] = value;
+  }
+  return newObj;
+}
+function addSuffixToObjKeys(obj, suffix) {
+  const newObj = {};
+  for (const [key, value] of Object.entries(obj)) {
+    newObj[`${key}${suffix}`] = value;
+  }
+  return newObj;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  addPrefixToObjKeys,
+  addSuffixToObjKeys,
   filterObjectKeys,
+  getObjPropertyOrInsert,
   getValueFromPath,
   looseGetObjectProperty,
+  mapArrToObj,
   mapArrayToObject,
+  mapObjToObj,
   mapObjectToObject,
   objectTypedEntries,
   omit,

package/dist/objUtils.d.cts

@@ -8,13 +8,24 @@ import { MakeUndefinedKeysOptional } from './typeUtils.cjs';
  */
 declare function objectTypedEntries<T extends Record<string, unknown>>(obj: T): [Extract<keyof T, string>, T[keyof T]][];
 declare function pick<T extends Record<string, unknown>, K extends keyof T>(obj: T, keys: K[]): Pick<T, K>;
-declare function mapArrayToObject<T, K extends string, O>(array: T[], mapper: (item: T, index: number) => [K, O]): Record<K, O>;
-declare function mapObjectToObject<I extends Record<string | number | symbol, unknown>, K extends string | number | symbol, O>(obj: I, mapper: (key: keyof I, value: I[keyof I]) => [K, O]): Record<K, O>;
+declare function mapArrToObj<T, K extends string, O>(array: T[], mapper: (item: T, index: number) => [K, O]): Record<K, O>;
+/** @deprecated Use mapArrToObj instead */
+declare const mapArrayToObject: typeof mapArrToObj;
+declare function mapObjToObj<I extends Record<string | number | symbol, unknown>, K extends string | number | symbol, O>(obj: I, mapper: (key: keyof I, value: I[keyof I]) => [K, O]): Record<K, O>;
+/** @deprecated Use mapObjToObj instead */
+declare const mapObjectToObject: typeof mapObjToObj;
 declare function omit<T extends Record<string, unknown>, K extends keyof T>(obj: T, keys: K[]): Omit<T, K>;
 declare function looseGetObjectProperty<T extends Record<string, unknown>>(obj: T, key: string): T[keyof T] | undefined;
 declare function rejectObjUndefinedValues<T extends Record<string, unknown>>(obj: T): MakeUndefinedKeysOptional<T>;
 declare function filterObjectKeys<T extends Record<string, unknown>>(obj: T, predicate: (key: keyof T, value: T[keyof T]) => boolean): Partial<T>;
 declare function sortObjectKeys<T extends Record<string, unknown>>(obj: T, sortByFn: SortByValueFn<[key: keyof T, value: T[keyof T]]>, options?: SortByProps): T;
 declare function getValueFromPath(obj: Record<string, unknown>, path: string): Result<unknown, Error>;
+declare function getObjPropertyOrInsert<T extends Record<string, any>, K extends keyof T>(obj: T, prop: K, insertValue: () => Exclude<T[K], undefined>): Exclude<T[K], undefined>;
+declare function addPrefixToObjKeys<T extends Record<string, unknown>, P extends string>(obj: T, prefix: P): {
+    [K in keyof T & string as `${P}${K}`]: T[K];
+};
+declare function addSuffixToObjKeys<T extends Record<string, unknown>, S extends string>(obj: T, suffix: S): {
+    [K in keyof T & string as `${K}${S}`]: T[K];
+};
 
-export { filterObjectKeys, getValueFromPath, looseGetObjectProperty, mapArrayToObject, mapObjectToObject, objectTypedEntries, omit, pick, rejectObjUndefinedValues, sortObjectKeys };
+export { addPrefixToObjKeys, addSuffixToObjKeys, filterObjectKeys, getObjPropertyOrInsert, getValueFromPath, looseGetObjectProperty, mapArrToObj, mapArrayToObject, mapObjToObj, mapObjectToObject, objectTypedEntries, omit, pick, rejectObjUndefinedValues, sortObjectKeys };

package/dist/objUtils.d.ts

@@ -8,13 +8,24 @@ import { MakeUndefinedKeysOptional } from './typeUtils.js';
  */
 declare function objectTypedEntries<T extends Record<string, unknown>>(obj: T): [Extract<keyof T, string>, T[keyof T]][];
 declare function pick<T extends Record<string, unknown>, K extends keyof T>(obj: T, keys: K[]): Pick<T, K>;
-declare function mapArrayToObject<T, K extends string, O>(array: T[], mapper: (item: T, index: number) => [K, O]): Record<K, O>;
-declare function mapObjectToObject<I extends Record<string | number | symbol, unknown>, K extends string | number | symbol, O>(obj: I, mapper: (key: keyof I, value: I[keyof I]) => [K, O]): Record<K, O>;
+declare function mapArrToObj<T, K extends string, O>(array: T[], mapper: (item: T, index: number) => [K, O]): Record<K, O>;
+/** @deprecated Use mapArrToObj instead */
+declare const mapArrayToObject: typeof mapArrToObj;
+declare function mapObjToObj<I extends Record<string | number | symbol, unknown>, K extends string | number | symbol, O>(obj: I, mapper: (key: keyof I, value: I[keyof I]) => [K, O]): Record<K, O>;
+/** @deprecated Use mapObjToObj instead */
+declare const mapObjectToObject: typeof mapObjToObj;
 declare function omit<T extends Record<string, unknown>, K extends keyof T>(obj: T, keys: K[]): Omit<T, K>;
 declare function looseGetObjectProperty<T extends Record<string, unknown>>(obj: T, key: string): T[keyof T] | undefined;
 declare function rejectObjUndefinedValues<T extends Record<string, unknown>>(obj: T): MakeUndefinedKeysOptional<T>;
 declare function filterObjectKeys<T extends Record<string, unknown>>(obj: T, predicate: (key: keyof T, value: T[keyof T]) => boolean): Partial<T>;
 declare function sortObjectKeys<T extends Record<string, unknown>>(obj: T, sortByFn: SortByValueFn<[key: keyof T, value: T[keyof T]]>, options?: SortByProps): T;
 declare function getValueFromPath(obj: Record<string, unknown>, path: string): Result<unknown, Error>;
+declare function getObjPropertyOrInsert<T extends Record<string, any>, K extends keyof T>(obj: T, prop: K, insertValue: () => Exclude<T[K], undefined>): Exclude<T[K], undefined>;
+declare function addPrefixToObjKeys<T extends Record<string, unknown>, P extends string>(obj: T, prefix: P): {
+    [K in keyof T & string as `${P}${K}`]: T[K];
+};
+declare function addSuffixToObjKeys<T extends Record<string, unknown>, S extends string>(obj: T, suffix: S): {
+    [K in keyof T & string as `${K}${S}`]: T[K];
+};
 
-export { filterObjectKeys, getValueFromPath, looseGetObjectProperty, mapArrayToObject, mapObjectToObject, objectTypedEntries, omit, pick, rejectObjUndefinedValues, sortObjectKeys };
+export { addPrefixToObjKeys, addSuffixToObjKeys, filterObjectKeys, getObjPropertyOrInsert, getValueFromPath, looseGetObjectProperty, mapArrToObj, mapArrayToObject, mapObjToObj, mapObjectToObject, objectTypedEntries, omit, pick, rejectObjUndefinedValues, sortObjectKeys };

package/dist/objUtils.js

@@ -1,24 +1,34 @@
 import {
+  addPrefixToObjKeys,
+  addSuffixToObjKeys,
   filterObjectKeys,
+  getObjPropertyOrInsert,
   getValueFromPath,
   looseGetObjectProperty,
+  mapArrToObj,
   mapArrayToObject,
+  mapObjToObj,
   mapObjectToObject,
   objectTypedEntries,
   omit,
   pick,
   rejectObjUndefinedValues,
   sortObjectKeys
-} from "./chunk-WNFRB7P6.js";
+} from "./chunk-SGRS4OEE.js";
 import "./chunk-GMJTLFM6.js";
-import "./chunk-BT3UMATU.js";
+import "./chunk-GVIDV772.js";
 import "./chunk-C2SVCIWE.js";
 import "./chunk-JF2MDHOJ.js";
 export {
+  addPrefixToObjKeys,
+  addSuffixToObjKeys,
   filterObjectKeys,
+  getObjPropertyOrInsert,
   getValueFromPath,
   looseGetObjectProperty,
+  mapArrToObj,
   mapArrayToObject,
+  mapObjToObj,
   mapObjectToObject,
   objectTypedEntries,
   omit,

package/dist/serializeXML.js

@@ -1,6 +1,6 @@
 import {
   filterAndMap
-} from "./chunk-BT3UMATU.js";
+} from "./chunk-GVIDV772.js";
 import "./chunk-C2SVCIWE.js";
 import {
   isTruthy

package/dist/testUtils.js

@@ -4,11 +4,11 @@ import {
 import {
   omit,
   pick
-} from "./chunk-WNFRB7P6.js";
+} from "./chunk-SGRS4OEE.js";
 import "./chunk-GMJTLFM6.js";
 import {
   filterObjectOrArrayKeys
-} from "./chunk-LBBC55GE.js";
+} from "./chunk-2LO5FYP5.js";
 import "./chunk-IATIXMCE.js";
 import {
   deepEqual
@@ -21,12 +21,12 @@ import {
 } from "./chunk-DFXNVEH6.js";
 import {
   clampMin
-} from "./chunk-HTCYUMDR.js";
+} from "./chunk-DBOWTYR4.js";
 import "./chunk-BM4PYVOX.js";
 import {
   arrayWithPrevAndIndex,
   filterAndMap
-} from "./chunk-BT3UMATU.js";
+} from "./chunk-GVIDV772.js";
 import {
   isObject
 } from "./chunk-C2SVCIWE.js";

package/dist/throttle.cjs

@@ -27,6 +27,9 @@ module.exports = __toCommonJS(throttle_exports);
 
 // src/debounce.ts
 function debounce(func, wait, options) {
+  let currentCallback = func;
+  let waitMs = wait;
+  let currentOptions = options;
   let lastArgs;
   let lastThis;
   let maxWait;
@@ -37,35 +40,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();
@@ -92,6 +97,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);
@@ -104,17 +133,20 @@ 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;
 }
 

package/dist/throttle.js

@@ -1,6 +1,6 @@
 import {
   debounce
-} from "./chunk-NW5H5EW7.js";
+} from "./chunk-CCUPDGSZ.js";
 import {
   EnhancedMap
 } from "./chunk-7CQPOM5I.js";

package/dist/time.js

@@ -15,8 +15,8 @@ import {
   getUnixSeconds,
   msToTimeString,
   parseTimeStringToMs
-} from "./chunk-5MNYPLZI.js";
-import "./chunk-HTCYUMDR.js";
+} from "./chunk-6FBIEPWU.js";
+import "./chunk-DBOWTYR4.js";
 import "./chunk-II4R3VVX.js";
 export {
   DAY_AS_MS,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@ls-stack/utils",
   "description": "Universal TypeScript utilities for browser and Node.js",
-  "version": "3.57.0",
+  "version": "3.59.0",
   "license": "MIT",
   "files": [
     "dist",

package/dist/chunk-HTCYUMDR.js

@@ -1,27 +0,0 @@
-// 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));
-}
-
-export {
-  clampMax,
-  clampMin,
-  clampRange,
-  clamp,
-  fixFloatingPointNumber
-};