es-toolkit 1.19.0 → 1.20.0-dev.625

package/dist/compat/array/drop.d.mts

@@ -0,0 +1,19 @@
+/**
+ * Removes a specified number of elements from the beginning of an array and returns the rest.
+ *
+ * This function takes an array and a number, and returns a new array with the specified number
+ * of elements removed from the start.
+ *
+ * @template T - The type of elements in the array.
+ * @param { T[] |  null | undefined} collection - - The array from which to drop elements.
+ * @param {number} itemsCount - The number of elements to drop from the beginning of the array.
+ * @returns {T[]} A new array with the specified number of elements removed from the start.
+ *
+ * @example
+ * const array = [1, 2, 3, 4, 5];
+ * const result = drop(array, 2);
+ * result will be [3, 4, 5] since the first two elements are dropped.
+ */
+declare function drop<T>(collection: readonly T[] | null | undefined, itemsCount: number): T[];
+
+export { drop };

package/dist/compat/array/drop.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Removes a specified number of elements from the beginning of an array and returns the rest.
+ *
+ * This function takes an array and a number, and returns a new array with the specified number
+ * of elements removed from the start.
+ *
+ * @template T - The type of elements in the array.
+ * @param { T[] |  null | undefined} collection - - The array from which to drop elements.
+ * @param {number} itemsCount - The number of elements to drop from the beginning of the array.
+ * @returns {T[]} A new array with the specified number of elements removed from the start.
+ *
+ * @example
+ * const array = [1, 2, 3, 4, 5];
+ * const result = drop(array, 2);
+ * result will be [3, 4, 5] since the first two elements are dropped.
+ */
+declare function drop<T>(collection: readonly T[] | null | undefined, itemsCount: number): T[];
+
+export { drop };

package/dist/compat/array/drop.mjs

@@ -0,0 +1,9 @@
+function drop(collection, itemsCount) {
+    if (collection === null || collection === undefined) {
+        return [];
+    }
+    itemsCount = Math.max(itemsCount, 0);
+    return collection.slice(itemsCount);
+}
+
+export { drop };

package/dist/compat/array/findLastIndex.mjs

@@ -2,30 +2,30 @@ import { property } from '../object/property.mjs';
 import { matches } from '../predicate/matches.mjs';
 import { matchesProperty } from '../predicate/matchesProperty.mjs';
 
-function findLastIndex(source, doesMatch, fromIndex = source.length - 1) {
+function findLastIndex(arr, doesMatch, fromIndex = arr.length - 1) {
     if (fromIndex < 0) {
-        fromIndex = Math.max(source.length + fromIndex, 0);
+        fromIndex = Math.max(arr.length + fromIndex, 0);
     }
     else {
-        fromIndex = Math.min(fromIndex, source.length - 1);
+        fromIndex = Math.min(fromIndex, arr.length - 1);
     }
-    source = source.slice(0, fromIndex + 1);
+    arr = arr.slice(0, fromIndex + 1);
     switch (typeof doesMatch) {
         case 'function': {
-            return source.findLastIndex(doesMatch);
+            return arr.findLastIndex(doesMatch);
         }
         case 'object': {
             if (Array.isArray(doesMatch) && doesMatch.length === 2) {
                 const key = doesMatch[0];
                 const value = doesMatch[1];
-                return source.findLastIndex(matchesProperty(key, value));
+                return arr.findLastIndex(matchesProperty(key, value));
             }
             else {
-                return source.findLastIndex(matches(doesMatch));
+                return arr.findLastIndex(matches(doesMatch));
             }
         }
         case 'string': {
-            return source.findLastIndex(property(doesMatch));
+            return arr.findLastIndex(property(doesMatch));
         }
     }
 }

package/dist/compat/array/some.d.mts

@@ -65,7 +65,6 @@ declare function some<T>(arr: readonly T[], doesMatch: Partial<T>): boolean;
  * @param {T[]} arr The array to iterate over.
  * @param {((item: T, index: number, arr: any) => unknown) | Partial<T> | [keyof T, unknown] | string} [predicate=identity] The function invoked per iteration.
  * If a property name or an object is provided it will be used to create a predicate function.
- * @param guard
  * @returns {boolean} Returns `true` if any element passes the predicate check, else `false`.
  *
  * @example

package/dist/compat/array/some.d.ts

@@ -65,7 +65,6 @@ declare function some<T>(arr: readonly T[], doesMatch: Partial<T>): boolean;
  * @param {T[]} arr The array to iterate over.
  * @param {((item: T, index: number, arr: any) => unknown) | Partial<T> | [keyof T, unknown] | string} [predicate=identity] The function invoked per iteration.
  * If a property name or an object is provided it will be used to create a predicate function.
- * @param guard
  * @returns {boolean} Returns `true` if any element passes the predicate check, else `false`.
  *
  * @example

package/dist/compat/function/curry.d.mts

@@ -0,0 +1,48 @@
+/**
+ * Creates a function that accepts arguments of `func` and either invokes `func` returning its result, if at least `arity` number of arguments have been provided, or returns a function that accepts the remaining `func` arguments, and so on.
+ * The arity of `func` may be specified if `func.length` is not sufficient.
+ *
+ * The `curry.placeholder` value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments.
+ *
+ * Note: This method doesn't set the `length` property of curried functions.
+ *
+ * @param {(...args: any[]) => any} func - The function to curry.
+ * @param {number=func.length} arity - The arity of func.
+ * @param {unknown} guard - Enables use as an iteratee for methods like `Array#map`.
+ * @returns {((...args: any[]) => any) & { placeholder: typeof curry.placeholder }} - Returns the new curried function.
+ *
+ * @example
+ * const abc = function(a, b, c) {
+ *   return Array.from(arguments);
+ * };
+ *
+ * let curried = curry(abc);
+ *
+ * curried(1)(2)(3);
+ * // => [1, 2, 3]
+ *
+ * curried(1, 2)(3);
+ * // => [1, 2, 3]
+ *
+ * curried(1, 2, 3);
+ * // => [1, 2, 3]
+ *
+ * // Curried with placeholders.
+ * curried(1)(curry.placeholder, 3)(2);
+ * // => [1, 2, 3]
+ *
+ * // Curried with arity.
+ * curried = curry(abc, 2);
+ *
+ * curried(1)(2);
+ * // => [1, 2]
+ */
+declare function curry(func: (...args: any[]) => any, arity?: number, guard?: unknown): ((...args: any[]) => any) & {
+    placeholder: typeof curry.placeholder;
+};
+declare namespace curry {
+    var placeholder: typeof curryPlaceholder;
+}
+declare const curryPlaceholder: unique symbol;
+
+export { curry };

package/dist/compat/function/curry.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Creates a function that accepts arguments of `func` and either invokes `func` returning its result, if at least `arity` number of arguments have been provided, or returns a function that accepts the remaining `func` arguments, and so on.
+ * The arity of `func` may be specified if `func.length` is not sufficient.
+ *
+ * The `curry.placeholder` value, which defaults to a `symbol`, may be used as a placeholder for partially applied arguments.
+ *
+ * Note: This method doesn't set the `length` property of curried functions.
+ *
+ * @param {(...args: any[]) => any} func - The function to curry.
+ * @param {number=func.length} arity - The arity of func.
+ * @param {unknown} guard - Enables use as an iteratee for methods like `Array#map`.
+ * @returns {((...args: any[]) => any) & { placeholder: typeof curry.placeholder }} - Returns the new curried function.
+ *
+ * @example
+ * const abc = function(a, b, c) {
+ *   return Array.from(arguments);
+ * };
+ *
+ * let curried = curry(abc);
+ *
+ * curried(1)(2)(3);
+ * // => [1, 2, 3]
+ *
+ * curried(1, 2)(3);
+ * // => [1, 2, 3]
+ *
+ * curried(1, 2, 3);
+ * // => [1, 2, 3]
+ *
+ * // Curried with placeholders.
+ * curried(1)(curry.placeholder, 3)(2);
+ * // => [1, 2, 3]
+ *
+ * // Curried with arity.
+ * curried = curry(abc, 2);
+ *
+ * curried(1)(2);
+ * // => [1, 2]
+ */
+declare function curry(func: (...args: any[]) => any, arity?: number, guard?: unknown): ((...args: any[]) => any) & {
+    placeholder: typeof curry.placeholder;
+};
+declare namespace curry {
+    var placeholder: typeof curryPlaceholder;
+}
+declare const curryPlaceholder: unique symbol;
+
+export { curry };

package/dist/compat/function/curry.mjs

@@ -0,0 +1,65 @@
+function curry(func, arity = func.length, guard) {
+    arity = guard ? func.length : arity;
+    arity = Number.parseInt(arity, 10);
+    if (Number.isNaN(arity) || arity < 1) {
+        arity = 0;
+    }
+    const wrapper = function (...partials) {
+        const holders = replaceHolders(partials);
+        const length = partials.length - holders.length;
+        if (length < arity) {
+            return makeCurry(func, holders, arity - length, partials);
+        }
+        if (this instanceof wrapper) {
+            return new func(...partials);
+        }
+        return func.apply(this, partials);
+    };
+    wrapper.placeholder = curryPlaceholder;
+    return wrapper;
+}
+function makeCurry(func, holders, arity, partials) {
+    function wrapper(...args) {
+        const holdersCount = args.filter(item => item === curry.placeholder).length;
+        const length = args.length - holdersCount;
+        args = composeArgs(args, partials, holders);
+        if (length < arity) {
+            const newHolders = replaceHolders(args);
+            return makeCurry(func, newHolders, arity - length, args);
+        }
+        if (this instanceof wrapper) {
+            return new func(...args);
+        }
+        return func.apply(this, args);
+    }
+    wrapper.placeholder = curryPlaceholder;
+    return wrapper;
+}
+function replaceHolders(args) {
+    const result = [];
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === curry.placeholder) {
+            result.push(i);
+        }
+    }
+    return result;
+}
+function composeArgs(args, partials, holders) {
+    const result = [...partials];
+    const argsLength = args.length;
+    const holdersLength = holders.length;
+    let argsIndex = -1, leftIndex = partials.length, rangeLength = Math.max(argsLength - holdersLength, 0);
+    while (++argsIndex < holdersLength) {
+        if (argsIndex < argsLength) {
+            result[holders[argsIndex]] = args[argsIndex];
+        }
+    }
+    while (rangeLength--) {
+        result[leftIndex++] = args[argsIndex++];
+    }
+    return result;
+}
+const curryPlaceholder = Symbol('curry.placeholder');
+curry.placeholder = curryPlaceholder;
+
+export { curry };

package/dist/compat/function/debounce.d.mts

@@ -0,0 +1,73 @@
+interface DebounceOptions {
+    /**
+     * An optional AbortSignal to cancel the debounced function.
+     */
+    signal?: AbortSignal;
+    /**
+     * If `true`, the function will be invoked on the leading edge of the timeout.
+     * @default false
+     */
+    leading?: boolean;
+    /**
+     * If `true`, the function will be invoked on the trailing edge of the timeout.
+     * @default true
+     */
+    trailing?: boolean;
+    /**
+     * The maximum time `func` is allowed to be delayed before it's invoked.
+     * @default Infinity
+     */
+    maxWait?: number;
+}
+/**
+ * Creates a debounced function that delays invoking the provided function until after `debounceMs` milliseconds
+ * have elapsed since the last time the debounced function was invoked. The debounced function also has a `cancel`
+ * method to cancel any pending execution.
+ *
+ * You can set the debounced function to run at the start (`leading`) or end (`trailing`) of the delay period.
+ * If `leading` is true, the function runs immediately on the first call.
+ * If `trailing` is true, the function runs after `debounceMs` milliseconds have passed since the last call.
+ * If both `leading` and `trailing` are true, the function runs at both the start and end, but it must be called at least twice within `debounceMs` milliseconds for this to happen
+ * (since one debounced function call cannot trigger the function twice).
+ *
+ * You can also set a `maxWait` time, which is the maximum time the function is allowed to be delayed before it is called.
+ *
+ * @template F - The type of function.
+ * @param {F} func - The function to debounce.
+ * @param {number} debounceMs - The number of milliseconds to delay.
+ * @param {DebounceOptions} options - The options object
+ * @param {AbortSignal} options.signal - An optional AbortSignal to cancel the debounced function.
+ * @param {boolean} options.leading - If `true`, the function will be invoked on the leading edge of the timeout.
+ * @param {boolean} options.trailing - If `true`, the function will be invoked on the trailing edge of the timeout.
+ * @param {number} options.maxWait - The maximum time `func` is allowed to be delayed before it's invoked.
+ * @returns A new debounced function with a `cancel` method.
+ *
+ * @example
+ * const debouncedFunction = debounce(() => {
+ *   console.log('Function executed');
+ * }, 1000);
+ *
+ * // Will log 'Function executed' after 1 second if not called again in that time
+ * debouncedFunction();
+ *
+ * // Will not log anything as the previous call is canceled
+ * debouncedFunction.cancel();
+ *
+ * // With AbortSignal
+ * const controller = new AbortController();
+ * const signal = controller.signal;
+ * const debouncedWithSignal = debounce(() => {
+ *  console.log('Function executed');
+ * }, 1000, { signal });
+ *
+ * debouncedWithSignal();
+ *
+ * // Will cancel the debounced function call
+ * controller.abort();
+ */
+declare function debounce<F extends (...args: any[]) => any>(func: F, debounceMs?: number, options?: DebounceOptions): ((...args: Parameters<F>) => ReturnType<F> | undefined) & {
+    cancel: () => void;
+    flush: () => void;
+};
+
+export { debounce };

package/dist/compat/function/debounce.d.ts

@@ -0,0 +1,73 @@
+interface DebounceOptions {
+    /**
+     * An optional AbortSignal to cancel the debounced function.
+     */
+    signal?: AbortSignal;
+    /**
+     * If `true`, the function will be invoked on the leading edge of the timeout.
+     * @default false
+     */
+    leading?: boolean;
+    /**
+     * If `true`, the function will be invoked on the trailing edge of the timeout.
+     * @default true
+     */
+    trailing?: boolean;
+    /**
+     * The maximum time `func` is allowed to be delayed before it's invoked.
+     * @default Infinity
+     */
+    maxWait?: number;
+}
+/**
+ * Creates a debounced function that delays invoking the provided function until after `debounceMs` milliseconds
+ * have elapsed since the last time the debounced function was invoked. The debounced function also has a `cancel`
+ * method to cancel any pending execution.
+ *
+ * You can set the debounced function to run at the start (`leading`) or end (`trailing`) of the delay period.
+ * If `leading` is true, the function runs immediately on the first call.
+ * If `trailing` is true, the function runs after `debounceMs` milliseconds have passed since the last call.
+ * If both `leading` and `trailing` are true, the function runs at both the start and end, but it must be called at least twice within `debounceMs` milliseconds for this to happen
+ * (since one debounced function call cannot trigger the function twice).
+ *
+ * You can also set a `maxWait` time, which is the maximum time the function is allowed to be delayed before it is called.
+ *
+ * @template F - The type of function.
+ * @param {F} func - The function to debounce.
+ * @param {number} debounceMs - The number of milliseconds to delay.
+ * @param {DebounceOptions} options - The options object
+ * @param {AbortSignal} options.signal - An optional AbortSignal to cancel the debounced function.
+ * @param {boolean} options.leading - If `true`, the function will be invoked on the leading edge of the timeout.
+ * @param {boolean} options.trailing - If `true`, the function will be invoked on the trailing edge of the timeout.
+ * @param {number} options.maxWait - The maximum time `func` is allowed to be delayed before it's invoked.
+ * @returns A new debounced function with a `cancel` method.
+ *
+ * @example
+ * const debouncedFunction = debounce(() => {
+ *   console.log('Function executed');
+ * }, 1000);
+ *
+ * // Will log 'Function executed' after 1 second if not called again in that time
+ * debouncedFunction();
+ *
+ * // Will not log anything as the previous call is canceled
+ * debouncedFunction.cancel();
+ *
+ * // With AbortSignal
+ * const controller = new AbortController();
+ * const signal = controller.signal;
+ * const debouncedWithSignal = debounce(() => {
+ *  console.log('Function executed');
+ * }, 1000, { signal });
+ *
+ * debouncedWithSignal();
+ *
+ * // Will cancel the debounced function call
+ * controller.abort();
+ */
+declare function debounce<F extends (...args: any[]) => any>(func: F, debounceMs?: number, options?: DebounceOptions): ((...args: Parameters<F>) => ReturnType<F> | undefined) & {
+    cancel: () => void;
+    flush: () => void;
+};
+
+export { debounce };

package/dist/compat/function/debounce.mjs

@@ -0,0 +1,48 @@
+import { debounce as debounce$1 } from '../../function/debounce.mjs';
+
+function debounce(func, debounceMs = 0, options = {}) {
+    if (typeof options !== 'object') {
+        options = {};
+    }
+    const { signal, leading = false, trailing = true, maxWait } = options;
+    const edges = Array(2);
+    if (leading) {
+        edges[0] = 'leading';
+    }
+    if (trailing) {
+        edges[1] = 'trailing';
+    }
+    let result = undefined;
+    let pendingAt = null;
+    const _debounced = debounce$1(function (...args) {
+        result = func.apply(this, args);
+        pendingAt = null;
+    }, debounceMs, { signal, edges });
+    const debounced = function (...args) {
+        if (maxWait != null) {
+            if (pendingAt === null) {
+                pendingAt = Date.now();
+            }
+            else {
+                if (Date.now() - pendingAt >= maxWait) {
+                    result = func.apply(this, args);
+                    pendingAt = Date.now();
+                    _debounced.cancel();
+                    _debounced.schedule();
+                    return result;
+                }
+            }
+        }
+        _debounced.apply(this, args);
+        return result;
+    };
+    const flush = () => {
+        _debounced.flush();
+        return result;
+    };
+    debounced.cancel = _debounced.cancel;
+    debounced.flush = flush;
+    return debounced;
+}
+
+export { debounce };

package/dist/compat/function/throttle.d.mts

@@ -0,0 +1,52 @@
+interface ThrottleOptions {
+    /**
+     * An optional AbortSignal to cancel the function invocation on the trailing edge.
+     */
+    signal?: AbortSignal;
+    /**
+     * If `true`, the function will be invoked on the leading edge of the timeout.
+     * @default true
+     */
+    leading?: boolean;
+    /**
+     * If `true`, the function will be invoked 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 `throttleMs` milliseconds. Subsequent calls to the throttled function
+ * within the wait time will not trigger the execution of the original function.
+ *
+ * @template F - The type of function.
+ * @param {F} func - The function to throttle.
+ * @param {number} throttleMs - The number of milliseconds to throttle executions to.
+ * @param {ThrottleOptions} options - The options object
+ * @param {AbortSignal} options.signal - An optional AbortSignal to cancel the throttled function.
+ * @param {boolean} options.leading - If `true`, the function will be invoked on the leading edge of the timeout.
+ * @param {boolean} options.trailing - If `true`, the function will be invoked on the trailing edge of the timeout.
+ * @returns {(...args: Parameters<F>) => void} A new throttled function that accepts the same parameters as the original function.
+ *
+ * @example
+ * const throttledFunction = throttle(() => {
+ *   console.log('Function executed');
+ * }, 1000);
+ *
+ * // Will log 'Function executed' immediately
+ * throttledFunction();
+ *
+ * // Will not log anything as it is within the throttle time
+ * throttledFunction();
+ *
+ * // After 1 second
+ * setTimeout(() => {
+ *   throttledFunction(); // Will log 'Function executed'
+ * }, 1000);
+ */
+declare function throttle<F extends (...args: any[]) => any>(func: F, throttleMs?: number, options?: ThrottleOptions): ((...args: Parameters<F>) => ReturnType<F> | undefined) & {
+    cancel: () => void;
+    flush: () => void;
+};
+
+export { throttle };

package/dist/compat/function/throttle.d.ts

@@ -0,0 +1,52 @@
+interface ThrottleOptions {
+    /**
+     * An optional AbortSignal to cancel the function invocation on the trailing edge.
+     */
+    signal?: AbortSignal;
+    /**
+     * If `true`, the function will be invoked on the leading edge of the timeout.
+     * @default true
+     */
+    leading?: boolean;
+    /**
+     * If `true`, the function will be invoked 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 `throttleMs` milliseconds. Subsequent calls to the throttled function
+ * within the wait time will not trigger the execution of the original function.
+ *
+ * @template F - The type of function.
+ * @param {F} func - The function to throttle.
+ * @param {number} throttleMs - The number of milliseconds to throttle executions to.
+ * @param {ThrottleOptions} options - The options object
+ * @param {AbortSignal} options.signal - An optional AbortSignal to cancel the throttled function.
+ * @param {boolean} options.leading - If `true`, the function will be invoked on the leading edge of the timeout.
+ * @param {boolean} options.trailing - If `true`, the function will be invoked on the trailing edge of the timeout.
+ * @returns {(...args: Parameters<F>) => void} A new throttled function that accepts the same parameters as the original function.
+ *
+ * @example
+ * const throttledFunction = throttle(() => {
+ *   console.log('Function executed');
+ * }, 1000);
+ *
+ * // Will log 'Function executed' immediately
+ * throttledFunction();
+ *
+ * // Will not log anything as it is within the throttle time
+ * throttledFunction();
+ *
+ * // After 1 second
+ * setTimeout(() => {
+ *   throttledFunction(); // Will log 'Function executed'
+ * }, 1000);
+ */
+declare function throttle<F extends (...args: any[]) => any>(func: F, throttleMs?: number, options?: ThrottleOptions): ((...args: Parameters<F>) => ReturnType<F> | undefined) & {
+    cancel: () => void;
+    flush: () => void;
+};
+
+export { throttle };

package/dist/compat/function/throttle.mjs

@@ -0,0 +1,11 @@
+import { debounce } from './debounce.mjs';
+
+function throttle(func, throttleMs = 0, options = {}) {
+    if (typeof options !== 'object') {
+        options = {};
+    }
+    const { leading = true, trailing = true, signal } = options;
+    return debounce(func, throttleMs, { leading, trailing, signal, maxWait: throttleMs });
+}
+
+export { throttle };

package/dist/compat/index.d.mts

@@ -3,7 +3,6 @@ export { compact } from '../array/compact.mjs';
 export { countBy } from '../array/countBy.mjs';
 export { differenceBy } from '../array/differenceBy.mjs';
 export { differenceWith } from '../array/differenceWith.mjs';
-export { drop } from '../array/drop.mjs';
 export { dropRight } from '../array/dropRight.mjs';
 export { dropRightWhile } from '../array/dropRightWhile.mjs';
 export { dropWhile } from '../array/dropWhile.mjs';
@@ -51,17 +50,13 @@ export { AbortError } from '../error/AbortError.mjs';
 export { TimeoutError } from '../error/TimeoutError.mjs';
 export { before } from '../function/before.mjs';
 export { after } from '../function/after.mjs';
-export { debounce } from '../function/debounce.mjs';
 export { noop } from '../function/noop.mjs';
 export { once } from '../function/once.mjs';
-export { throttle } from '../function/throttle.mjs';
 export { negate } from '../function/negate.mjs';
 export { MemoizeCache, memoize } from '../function/memoize.mjs';
 export { unary } from '../function/unary.mjs';
 export { partial } from '../function/partial.mjs';
 export { partialRight } from '../function/partialRight.mjs';
-export { curry } from '../function/curry.mjs';
-export { clamp } from '../math/clamp.mjs';
 export { inRange } from '../math/inRange.mjs';
 export { mean } from '../math/mean.mjs';
 export { meanBy } from '../math/meanBy.mjs';
@@ -89,7 +84,6 @@ export { isPrimitive } from '../predicate/isPrimitive.mjs';
 export { delay } from '../promise/delay.mjs';
 export { withTimeout } from '../promise/withTimeout.mjs';
 export { timeout } from '../promise/timeout.mjs';
-export { upperCase } from '../string/upperCase.mjs';
 export { capitalize } from '../string/capitalize.mjs';
 export { pascalCase } from '../string/pascalCase.mjs';
 export { upperFirst } from '../string/upperFirst.mjs';
@@ -103,6 +97,7 @@ export { castArray } from './array/castArray.mjs';
 export { chunk } from './array/chunk.mjs';
 export { concat } from './array/concat.mjs';
 export { difference } from './array/difference.mjs';
+export { drop } from './array/drop.mjs';
 export { fill } from './array/fill.mjs';
 export { find } from './array/find.mjs';
 export { findIndex } from './array/findIndex.mjs';
@@ -124,6 +119,9 @@ export { rest } from './function/rest.mjs';
 export { spread } from './function/spread.mjs';
 export { attempt } from './function/attempt.mjs';
 export { rearg } from './function/rearg.mjs';
+export { curry } from './function/curry.mjs';
+export { debounce } from './function/debounce.mjs';
+export { throttle } from './function/throttle.mjs';
 export { get } from './object/get.mjs';
 export { set } from './object/set.mjs';
 export { pick } from './object/pick.mjs';
@@ -156,11 +154,14 @@ export { conforms } from './predicate/conforms.mjs';
 export { conformsTo } from './predicate/conformsTo.mjs';
 export { isInteger } from './predicate/isInteger.mjs';
 export { isSafeInteger } from './predicate/isSafeInteger.mjs';
+export { isNumber } from './predicate/isNumber.mjs';
+export { isNaN } from './predicate/isNaN.mjs';
 export { camelCase } from './string/camelCase.mjs';
 export { kebabCase } from './string/kebabCase.mjs';
 export { snakeCase } from './string/snakeCase.mjs';
 export { startCase } from './string/startCase.mjs';
 export { lowerCase } from './string/lowerCase.mjs';
+export { upperCase } from './string/upperCase.mjs';
 export { startsWith } from './string/startsWith.mjs';
 export { endsWith } from './string/endsWith.mjs';
 export { padStart } from './string/padStart.mjs';
@@ -169,6 +170,7 @@ export { repeat } from './string/repeat.mjs';
 export { trim } from './string/trim.mjs';
 export { trimStart } from './string/trimStart.mjs';
 export { trimEnd } from './string/trimEnd.mjs';
+export { clamp } from './math/clamp.mjs';
 export { max } from './math/max.mjs';
 export { min } from './math/min.mjs';
 export { ceil } from './math/ceil.mjs';