es-toolkit 1.18.0-dev.587 → 1.18.0-dev.589

package/dist/compat/index.d.mts

@@ -60,6 +60,7 @@ 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';
@@ -151,6 +152,7 @@ export { isWeakMap } from './predicate/isWeakMap.mjs';
 export { isWeakSet } from './predicate/isWeakSet.mjs';
 export { conforms } from './predicate/conforms.mjs';
 export { conformsTo } from './predicate/conformsTo.mjs';
+export { isInteger } from './predicate/isInteger.mjs';
 export { camelCase } from './string/camelCase.mjs';
 export { kebabCase } from './string/kebabCase.mjs';
 export { snakeCase } from './string/snakeCase.mjs';

package/dist/compat/index.d.ts

@@ -60,6 +60,7 @@ export { MemoizeCache, memoize } from '../function/memoize.js';
 export { unary } from '../function/unary.js';
 export { partial } from '../function/partial.js';
 export { partialRight } from '../function/partialRight.js';
+export { curry } from '../function/curry.js';
 export { clamp } from '../math/clamp.js';
 export { inRange } from '../math/inRange.js';
 export { mean } from '../math/mean.js';
@@ -151,6 +152,7 @@ export { isWeakMap } from './predicate/isWeakMap.js';
 export { isWeakSet } from './predicate/isWeakSet.js';
 export { conforms } from './predicate/conforms.js';
 export { conformsTo } from './predicate/conformsTo.js';
+export { isInteger } from './predicate/isInteger.js';
 export { camelCase } from './string/camelCase.js';
 export { kebabCase } from './string/kebabCase.js';
 export { snakeCase } from './string/snakeCase.js';

package/dist/compat/index.js

@@ -4,7 +4,7 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
 const zipWith = require('../_chunk/zipWith-CYaH1Y.js');
 const promise_index = require('../_chunk/index-BGZDR9.js');
-const rest$1 = require('../_chunk/rest-CXt9w3.js');
+const curry = require('../_chunk/curry-BmwJrK.js');
 const range = require('../_chunk/range-BXlMmn.js');
 const randomInt = require('../_chunk/randomInt-CF7bZK.js');
 const toMerged = require('../_chunk/toMerged-LBvzaK.js');
@@ -684,7 +684,7 @@ function ary(func, n = func.length, guard) {
     if (Number.isNaN(n) || n < 0) {
         n = 0;
     }
-    return rest$1.ary(func, n);
+    return curry.ary(func, n);
 }
 
 function bind(func, thisObj, ...partialArgs) {
@@ -744,7 +744,7 @@ function rest(func, start = func.length - 1) {
     if (Number.isNaN(start) || start < 0) {
         start = func.length - 1;
     }
-    return rest$1.rest(func, start);
+    return curry.rest(func, start);
 }
 
 function spread(func, argsIndex = 0) {
@@ -946,7 +946,7 @@ function mergeWithDeep(target, source, merge, stack) {
 }
 
 function merge(object, ...sources) {
-    return mergeWith(object, ...sources, rest$1.noop);
+    return mergeWith(object, ...sources, curry.noop);
 }
 
 function isArrayLike(value) {
@@ -1028,6 +1028,10 @@ function conforms(source) {
     };
 }
 
+function isInteger(value) {
+    return Number.isInteger(value);
+}
+
 function normalizeForCase(str) {
     if (typeof str === 'object') {
         str = str.toString();
@@ -1272,17 +1276,18 @@ exports.TimeoutError = promise_index.TimeoutError;
 exports.delay = promise_index.delay;
 exports.timeout = promise_index.timeout;
 exports.withTimeout = promise_index.withTimeout;
-exports.after = rest$1.after;
-exports.before = rest$1.before;
-exports.debounce = rest$1.debounce;
-exports.memoize = rest$1.memoize;
-exports.negate = rest$1.negate;
-exports.noop = rest$1.noop;
-exports.once = rest$1.once;
-exports.partial = rest$1.partial;
-exports.partialRight = rest$1.partialRight;
-exports.throttle = rest$1.throttle;
-exports.unary = rest$1.unary;
+exports.after = curry.after;
+exports.before = curry.before;
+exports.curry = curry.curry;
+exports.debounce = curry.debounce;
+exports.memoize = curry.memoize;
+exports.negate = curry.negate;
+exports.noop = curry.noop;
+exports.once = curry.once;
+exports.partial = curry.partial;
+exports.partialRight = curry.partialRight;
+exports.throttle = curry.throttle;
+exports.unary = curry.unary;
 exports.clamp = range.clamp;
 exports.inRange = range.inRange;
 exports.mean = range.mean;
@@ -1348,6 +1353,7 @@ exports.isArguments = isArguments;
 exports.isArray = isArray;
 exports.isArrayLike = isArrayLike;
 exports.isBoolean = isBoolean;
+exports.isInteger = isInteger;
 exports.isMatch = isMatch;
 exports.isObject = isObject;
 exports.isPlainObject = isPlainObject;

package/dist/compat/index.mjs

@@ -60,6 +60,7 @@ export { 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';
@@ -151,6 +152,7 @@ export { isWeakMap } from './predicate/isWeakMap.mjs';
 export { isWeakSet } from './predicate/isWeakSet.mjs';
 export { conforms } from './predicate/conforms.mjs';
 export { conformsTo } from './predicate/conformsTo.mjs';
+export { isInteger } from './predicate/isInteger.mjs';
 export { camelCase } from './string/camelCase.mjs';
 export { kebabCase } from './string/kebabCase.mjs';
 export { snakeCase } from './string/snakeCase.mjs';

package/dist/compat/predicate/isInteger.d.mts

@@ -0,0 +1,17 @@
+/**
+ * Checks if `value` is an integer.
+ *
+ * This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to `number`.
+ *
+ * @param {unknown} value - The value to check
+ * @returns {boolean} `true` if `value` is integer, otherwise `false`.
+ *
+ * @example
+ * isInteger(3); // Returns: true
+ * isInteger(Infinity); // Returns: false
+ * isInteger('3'); // Returns: false
+ * isInteger([]); // Returns: false
+ */
+declare function isInteger(value?: unknown): value is number;
+
+export { isInteger };

package/dist/compat/predicate/isInteger.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Checks if `value` is an integer.
+ *
+ * This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to `number`.
+ *
+ * @param {unknown} value - The value to check
+ * @returns {boolean} `true` if `value` is integer, otherwise `false`.
+ *
+ * @example
+ * isInteger(3); // Returns: true
+ * isInteger(Infinity); // Returns: false
+ * isInteger('3'); // Returns: false
+ * isInteger([]); // Returns: false
+ */
+declare function isInteger(value?: unknown): value is number;
+
+export { isInteger };

package/dist/compat/predicate/isInteger.mjs

@@ -0,0 +1,5 @@
+function isInteger(value) {
+    return Number.isInteger(value);
+}
+
+export { isInteger };

package/dist/function/curry.d.mts

@@ -0,0 +1,127 @@
+/**
+ * Curries a function, allowing it to be called with a single argument at a time and returning a new function that takes the next argument.
+ * This process continues until all arguments have been provided, at which point the original function is called with all accumulated arguments.
+ *
+ * @param {() => R} func - The function to curry.
+ * @returns {() => R} A curried function.
+ *
+ * @example
+ * function noArgFunc() {
+ *   return 42;
+ * }
+ * const curriedNoArgFunc = curry(noArgFunc);
+ * console.log(curriedNoArgFunc()); // 42
+ */
+declare function curry<R>(func: () => R): () => R;
+/**
+ * Curries a function, allowing it to be called with a single argument at a time and returning a new function that takes the next argument.
+ * This process continues until all arguments have been provided, at which point the original function is called with all accumulated arguments.
+ *
+ * @param {(p: P) => R} func - The function to curry.
+ * @returns {(p: P) => R} A curried function.
+ *
+ * @example
+ * function oneArgFunc(a: number) {
+ *   return a * 2;
+ * }
+ * const curriedOneArgFunc = curry(oneArgFunc);
+ * console.log(curriedOneArgFunc(5)); // 10
+ */
+declare function curry<P, R>(func: (p: P) => R): (p: P) => R;
+/**
+ * Curries a function, allowing it to be called with a single argument at a time and returning a new function that takes the next argument.
+ * This process continues until all arguments have been provided, at which point the original function is called with all accumulated arguments.
+ *
+ * @param {(p1: P1, p2: P2) => R} func - The function to curry.
+ * @returns {(p1: P1) => (p2: P2) => R} A curried function.
+ *
+ * @example
+ * function twoArgFunc(a: number, b: number) {
+ *   return a + b;
+ * }
+ * const curriedTwoArgFunc = curry(twoArgFunc);
+ * const add5 = curriedTwoArgFunc(5);
+ * console.log(add5(10)); // 15
+ */
+declare function curry<P1, P2, R>(func: (p1: P1, p2: P2) => R): (p1: P1) => (p2: P2) => R;
+/**
+ * Curries a function, allowing it to be called with a single argument at a time and returning a new function that takes the next argument.
+ * This process continues until all arguments have been provided, at which point the original function is called with all accumulated arguments.
+ *
+ * @param {(p1: P1, p2: P2, p3: P3, p4: P4) => R} func - The function to curry.
+ * @returns {(p1: P1) => (p2: P2) => (p3: P3) => (p4: P4) => R} A curried function.
+ *
+ * @example
+ * function fourArgFunc(a: number, b: number, c: number, d: number) {
+ *   return a + b + c + d;
+ * }
+ * const curriedFourArgFunc = curry(fourArgFunc);
+ * const add1 = curriedFourArgFunc(1);
+ * const add2 = add1(2);
+ * const add3 = add2(3);
+ * console.log(add3(4)); // 10
+ */
+declare function curry<P1, P2, P3, R>(func: (p1: P1, p2: P2, p3: P3) => R): (p1: P1) => (p2: P2) => (p3: P3) => R;
+/**
+ * Curries a function, allowing it to be called with a single argument at a time and returning a new function that takes the next argument.
+ * This process continues until all arguments have been provided, at which point the original function is called with all accumulated arguments.
+ *
+ * @param {(p1: P1, p2: P2, p3: P3, p4: P4) => R} func - The function to curry.
+ * @returns {(p1: P1) => (p2: P2) => (p3: P3) => (p4: P4) => R} A curried function.
+ *
+ * @example
+ * function fourArgFunc(a: number, b: number, c: number, d: number) {
+ *   return a + b + c + d;
+ * }
+ * const curriedFourArgFunc = curry(fourArgFunc);
+ * const add1 = curriedFourArgFunc(1);
+ * const add2 = add1(2);
+ * const add3 = add2(3);
+ * console.log(add3(4)); // 10
+ */
+declare function curry<P1, P2, P3, P4, R>(func: (p1: P1, p2: P2, p3: P3, p4: P4) => R): (p1: P1) => (p2: P2) => (p3: P3) => (p4: P4) => R;
+/**
+ * Curries a function, allowing it to be called with a single argument at a time and returning a new function that takes the next argument.
+ * This process continues until all arguments have been provided, at which point the original function is called with all accumulated arguments.
+ *
+ * @param {(p1: P1, p2: P2, p3: P3, p4: P4, p5: P5) => R} func - The function to curry.
+ * @returns {(p1: P1) => (p2: P2) => (p3: P3) => (p4: P4) => (p5: P5) => R} A curried function.
+ *
+ * @example
+ * function fiveArgFunc(a: number, b: number, c: number, d: number, e: number) {
+ *   return a + b + c + d + e;
+ * }
+ * const curriedFiveArgFunc = curry(fiveArgFunc);
+ * const add1 = curriedFiveArgFunc(1);
+ * const add2 = add1(2);
+ * const add3 = add2(3);
+ * const add4 = add3(4);
+ * console.log(add4(5)); // 15
+ */
+declare function curry<P1, P2, P3, P4, P5, R>(func: (p1: P1, p2: P2, p3: P3, p4: P4, p5: P5) => R): (p1: P1) => (p2: P2) => (p3: P3) => (p4: P4) => (p5: P5) => R;
+/**
+ * Curries a function, allowing it to be called with a single argument at a time and returning a new function that takes the next argument.
+ * This process continues until all arguments have been provided, at which point the original function is called with all accumulated arguments.
+ *
+ * @param {(...args: any[]) => any} func - The function to curry.
+ * @returns {(...args: any[]) => any} A curried function that can be called with a single argument at a time.
+ *
+ * @example
+ * function sum(a: number, b: number, c: number) {
+ *   return a + b + c;
+ * }
+ *
+ * const curriedSum = curry(sum);
+ *
+ * // The parameter `a` should be given the value `10`.
+ * const sum10 = curriedSum(10);
+ *
+ * // The parameter `b` should be given the value `15`.
+ * const sum25 = sum10(15);
+ *
+ * // The parameter `c` should be given the value `5`. The function 'sum' has received all its arguments and will now return a value.
+ * const result = sum25(5);
+ */
+declare function curry(func: (...args: any[]) => any): (...args: any[]) => any;
+
+export { curry };

package/dist/function/curry.d.ts

@@ -0,0 +1,127 @@
+/**
+ * Curries a function, allowing it to be called with a single argument at a time and returning a new function that takes the next argument.
+ * This process continues until all arguments have been provided, at which point the original function is called with all accumulated arguments.
+ *
+ * @param {() => R} func - The function to curry.
+ * @returns {() => R} A curried function.
+ *
+ * @example
+ * function noArgFunc() {
+ *   return 42;
+ * }
+ * const curriedNoArgFunc = curry(noArgFunc);
+ * console.log(curriedNoArgFunc()); // 42
+ */
+declare function curry<R>(func: () => R): () => R;
+/**
+ * Curries a function, allowing it to be called with a single argument at a time and returning a new function that takes the next argument.
+ * This process continues until all arguments have been provided, at which point the original function is called with all accumulated arguments.
+ *
+ * @param {(p: P) => R} func - The function to curry.
+ * @returns {(p: P) => R} A curried function.
+ *
+ * @example
+ * function oneArgFunc(a: number) {
+ *   return a * 2;
+ * }
+ * const curriedOneArgFunc = curry(oneArgFunc);
+ * console.log(curriedOneArgFunc(5)); // 10
+ */
+declare function curry<P, R>(func: (p: P) => R): (p: P) => R;
+/**
+ * Curries a function, allowing it to be called with a single argument at a time and returning a new function that takes the next argument.
+ * This process continues until all arguments have been provided, at which point the original function is called with all accumulated arguments.
+ *
+ * @param {(p1: P1, p2: P2) => R} func - The function to curry.
+ * @returns {(p1: P1) => (p2: P2) => R} A curried function.
+ *
+ * @example
+ * function twoArgFunc(a: number, b: number) {
+ *   return a + b;
+ * }
+ * const curriedTwoArgFunc = curry(twoArgFunc);
+ * const add5 = curriedTwoArgFunc(5);
+ * console.log(add5(10)); // 15
+ */
+declare function curry<P1, P2, R>(func: (p1: P1, p2: P2) => R): (p1: P1) => (p2: P2) => R;
+/**
+ * Curries a function, allowing it to be called with a single argument at a time and returning a new function that takes the next argument.
+ * This process continues until all arguments have been provided, at which point the original function is called with all accumulated arguments.
+ *
+ * @param {(p1: P1, p2: P2, p3: P3, p4: P4) => R} func - The function to curry.
+ * @returns {(p1: P1) => (p2: P2) => (p3: P3) => (p4: P4) => R} A curried function.
+ *
+ * @example
+ * function fourArgFunc(a: number, b: number, c: number, d: number) {
+ *   return a + b + c + d;
+ * }
+ * const curriedFourArgFunc = curry(fourArgFunc);
+ * const add1 = curriedFourArgFunc(1);
+ * const add2 = add1(2);
+ * const add3 = add2(3);
+ * console.log(add3(4)); // 10
+ */
+declare function curry<P1, P2, P3, R>(func: (p1: P1, p2: P2, p3: P3) => R): (p1: P1) => (p2: P2) => (p3: P3) => R;
+/**
+ * Curries a function, allowing it to be called with a single argument at a time and returning a new function that takes the next argument.
+ * This process continues until all arguments have been provided, at which point the original function is called with all accumulated arguments.
+ *
+ * @param {(p1: P1, p2: P2, p3: P3, p4: P4) => R} func - The function to curry.
+ * @returns {(p1: P1) => (p2: P2) => (p3: P3) => (p4: P4) => R} A curried function.
+ *
+ * @example
+ * function fourArgFunc(a: number, b: number, c: number, d: number) {
+ *   return a + b + c + d;
+ * }
+ * const curriedFourArgFunc = curry(fourArgFunc);
+ * const add1 = curriedFourArgFunc(1);
+ * const add2 = add1(2);
+ * const add3 = add2(3);
+ * console.log(add3(4)); // 10
+ */
+declare function curry<P1, P2, P3, P4, R>(func: (p1: P1, p2: P2, p3: P3, p4: P4) => R): (p1: P1) => (p2: P2) => (p3: P3) => (p4: P4) => R;
+/**
+ * Curries a function, allowing it to be called with a single argument at a time and returning a new function that takes the next argument.
+ * This process continues until all arguments have been provided, at which point the original function is called with all accumulated arguments.
+ *
+ * @param {(p1: P1, p2: P2, p3: P3, p4: P4, p5: P5) => R} func - The function to curry.
+ * @returns {(p1: P1) => (p2: P2) => (p3: P3) => (p4: P4) => (p5: P5) => R} A curried function.
+ *
+ * @example
+ * function fiveArgFunc(a: number, b: number, c: number, d: number, e: number) {
+ *   return a + b + c + d + e;
+ * }
+ * const curriedFiveArgFunc = curry(fiveArgFunc);
+ * const add1 = curriedFiveArgFunc(1);
+ * const add2 = add1(2);
+ * const add3 = add2(3);
+ * const add4 = add3(4);
+ * console.log(add4(5)); // 15
+ */
+declare function curry<P1, P2, P3, P4, P5, R>(func: (p1: P1, p2: P2, p3: P3, p4: P4, p5: P5) => R): (p1: P1) => (p2: P2) => (p3: P3) => (p4: P4) => (p5: P5) => R;
+/**
+ * Curries a function, allowing it to be called with a single argument at a time and returning a new function that takes the next argument.
+ * This process continues until all arguments have been provided, at which point the original function is called with all accumulated arguments.
+ *
+ * @param {(...args: any[]) => any} func - The function to curry.
+ * @returns {(...args: any[]) => any} A curried function that can be called with a single argument at a time.
+ *
+ * @example
+ * function sum(a: number, b: number, c: number) {
+ *   return a + b + c;
+ * }
+ *
+ * const curriedSum = curry(sum);
+ *
+ * // The parameter `a` should be given the value `10`.
+ * const sum10 = curriedSum(10);
+ *
+ * // The parameter `b` should be given the value `15`.
+ * const sum25 = sum10(15);
+ *
+ * // The parameter `c` should be given the value `5`. The function 'sum' has received all its arguments and will now return a value.
+ * const result = sum25(5);
+ */
+declare function curry(func: (...args: any[]) => any): (...args: any[]) => any;
+
+export { curry };

package/dist/function/curry.mjs

@@ -0,0 +1,21 @@
+function curry(func) {
+    if (func.length === 0 || func.length === 1) {
+        return func;
+    }
+    return function (arg) {
+        return makeCurry(func, func.length, [arg]);
+    };
+}
+function makeCurry(origin, argsLength, args) {
+    if (args.length === argsLength) {
+        return origin(...args);
+    }
+    else {
+        const next = function (arg) {
+            return makeCurry(origin, argsLength, [...args, arg]);
+        };
+        return next;
+    }
+}
+
+export { curry };

package/dist/function/index.d.mts

@@ -11,4 +11,5 @@ export { unary } from './unary.mjs';
 export { partial } from './partial.mjs';
 export { partialRight } from './partialRight.mjs';
 export { rest } from './rest.mjs';
+export { curry } from './curry.mjs';
 export { spread } from './spread.mjs';

package/dist/function/index.d.ts

@@ -11,4 +11,5 @@ export { unary } from './unary.js';
 export { partial } from './partial.js';
 export { partialRight } from './partialRight.js';
 export { rest } from './rest.js';
+export { curry } from './curry.js';
 export { spread } from './spread.js';

package/dist/function/index.js

@@ -2,7 +2,7 @@
 
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
-const rest = require('../_chunk/rest-CXt9w3.js');
+const curry = require('../_chunk/curry-BmwJrK.js');
 
 function spread(func) {
     return function (argsArr) {
@@ -10,17 +10,18 @@ function spread(func) {
     };
 }
 
-exports.after = rest.after;
-exports.ary = rest.ary;
-exports.before = rest.before;
-exports.debounce = rest.debounce;
-exports.memoize = rest.memoize;
-exports.negate = rest.negate;
-exports.noop = rest.noop;
-exports.once = rest.once;
-exports.partial = rest.partial;
-exports.partialRight = rest.partialRight;
-exports.rest = rest.rest;
-exports.throttle = rest.throttle;
-exports.unary = rest.unary;
+exports.after = curry.after;
+exports.ary = curry.ary;
+exports.before = curry.before;
+exports.curry = curry.curry;
+exports.debounce = curry.debounce;
+exports.memoize = curry.memoize;
+exports.negate = curry.negate;
+exports.noop = curry.noop;
+exports.once = curry.once;
+exports.partial = curry.partial;
+exports.partialRight = curry.partialRight;
+exports.rest = curry.rest;
+exports.throttle = curry.throttle;
+exports.unary = curry.unary;
 exports.spread = spread;

package/dist/function/index.mjs

@@ -11,4 +11,5 @@ export { unary } from './unary.mjs';
 export { partial } from './partial.mjs';
 export { partialRight } from './partialRight.mjs';
 export { rest } from './rest.mjs';
+export { curry } from './curry.mjs';
 export { spread } from './spread.mjs';

package/dist/index.d.mts

@@ -69,6 +69,7 @@ export { unary } from './function/unary.mjs';
 export { partial } from './function/partial.mjs';
 export { partialRight } from './function/partialRight.mjs';
 export { rest } from './function/rest.mjs';
+export { curry } from './function/curry.mjs';
 export { spread } from './function/spread.mjs';
 export { clamp } from './math/clamp.mjs';
 export { inRange } from './math/inRange.mjs';

package/dist/index.d.ts

@@ -69,6 +69,7 @@ export { unary } from './function/unary.js';
 export { partial } from './function/partial.js';
 export { partialRight } from './function/partialRight.js';
 export { rest } from './function/rest.js';
+export { curry } from './function/curry.js';
 export { spread } from './function/spread.js';
 export { clamp } from './math/clamp.js';
 export { inRange } from './math/inRange.js';

package/dist/index.js

@@ -5,7 +5,7 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 const zipWith = require('./_chunk/zipWith-CYaH1Y.js');
 const array_index = require('./array/index.js');
 const promise_index = require('./_chunk/index-BGZDR9.js');
-const rest = require('./_chunk/rest-CXt9w3.js');
+const curry = require('./_chunk/curry-BmwJrK.js');
 const function_index = require('./function/index.js');
 const range = require('./_chunk/range-BXlMmn.js');
 const randomInt = require('./_chunk/randomInt-CF7bZK.js');
@@ -80,19 +80,20 @@ exports.TimeoutError = promise_index.TimeoutError;
 exports.delay = promise_index.delay;
 exports.timeout = promise_index.timeout;
 exports.withTimeout = promise_index.withTimeout;
-exports.after = rest.after;
-exports.ary = rest.ary;
-exports.before = rest.before;
-exports.debounce = rest.debounce;
-exports.memoize = rest.memoize;
-exports.negate = rest.negate;
-exports.noop = rest.noop;
-exports.once = rest.once;
-exports.partial = rest.partial;
-exports.partialRight = rest.partialRight;
-exports.rest = rest.rest;
-exports.throttle = rest.throttle;
-exports.unary = rest.unary;
+exports.after = curry.after;
+exports.ary = curry.ary;
+exports.before = curry.before;
+exports.curry = curry.curry;
+exports.debounce = curry.debounce;
+exports.memoize = curry.memoize;
+exports.negate = curry.negate;
+exports.noop = curry.noop;
+exports.once = curry.once;
+exports.partial = curry.partial;
+exports.partialRight = curry.partialRight;
+exports.rest = curry.rest;
+exports.throttle = curry.throttle;
+exports.unary = curry.unary;
 exports.spread = function_index.spread;
 exports.clamp = range.clamp;
 exports.inRange = range.inRange;

package/dist/index.mjs

@@ -69,6 +69,7 @@ export { unary } from './function/unary.mjs';
 export { partial } from './function/partial.mjs';
 export { partialRight } from './function/partialRight.mjs';
 export { rest } from './function/rest.mjs';
+export { curry } from './function/curry.mjs';
 export { spread } from './function/spread.mjs';
 export { clamp } from './math/clamp.mjs';
 export { inRange } from './math/inRange.mjs';

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "es-toolkit",
   "description": "A state-of-the-art, high-performance JavaScript utility library with a small bundle size and strong type annotations.",
-  "version": "1.18.0-dev.587+0c9de474",
+  "version": "1.18.0-dev.589+ff8976e5",
   "homepage": "https://es-toolkit.slash.page",
   "bugs": "https://github.com/toss/es-toolkit/issues",
   "repository": {