es-toolkit 1.18.0 → 1.19.0

package/dist/compat/string/snakeCase.mjs

@@ -0,0 +1,8 @@
+import { snakeCase as snakeCase$1 } from '../../string/snakeCase.mjs';
+import { normalizeForCase } from '../_internal/normalizeForCase.mjs';
+
+function snakeCase(str) {
+    return snakeCase$1(normalizeForCase(str));
+}
+
+export { snakeCase };

package/dist/compat/string/startCase.d.mts

@@ -0,0 +1,16 @@
+/**
+ * Converts the first character of each word in a string to uppercase and the remaining characters to lowercase.
+ *
+ * Start case is the naming convention in which each word is written with an initial capital letter.
+ * @param {string} str - The string to convert.
+ * @returns {string} The converted string.
+ *
+ * @example
+ * const result1 = startCase('hello world');  // result will be 'Hello World'
+ * const result2 = startCase('HELLO WORLD');  // result will be 'HELLO WORLD'
+ * const result3 = startCase('hello-world');  // result will be 'Hello World'
+ * const result4 = startCase('hello_world');  // result will be 'Hello World'
+ */
+declare function startCase(str: string | object): string;
+
+export { startCase };

package/dist/compat/string/startCase.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Converts the first character of each word in a string to uppercase and the remaining characters to lowercase.
+ *
+ * Start case is the naming convention in which each word is written with an initial capital letter.
+ * @param {string} str - The string to convert.
+ * @returns {string} The converted string.
+ *
+ * @example
+ * const result1 = startCase('hello world');  // result will be 'Hello World'
+ * const result2 = startCase('HELLO WORLD');  // result will be 'HELLO WORLD'
+ * const result3 = startCase('hello-world');  // result will be 'Hello World'
+ * const result4 = startCase('hello_world');  // result will be 'Hello World'
+ */
+declare function startCase(str: string | object): string;
+
+export { startCase };

package/dist/compat/string/startCase.mjs

@@ -0,0 +1,8 @@
+import { startCase as startCase$1 } from '../../string/startCase.mjs';
+import { normalizeForCase } from '../_internal/normalizeForCase.mjs';
+
+function startCase(str) {
+    return startCase$1(normalizeForCase(str));
+}
+
+export { startCase };

package/dist/compat/string/trim.d.mts

@@ -0,0 +1,16 @@
+/**
+ * Removes leading and trailing whitespace or specified characters from a string.
+ *
+ * @param {string} str - The string from which leading and trailing characters will be trimmed.
+ * @param {string | string[]} chars - The character(s) to remove from the end of the string. Defaults to `" "`.
+ * @param guard
+ * @returns {string} - The resulting string after the specified leading and trailing characters have been removed.
+ *
+ * @example
+ * trim("  hello  "); // "hello"
+ * trim("--hello--", "-"); // "hello"
+ * trim("##hello##", ["#", "o"]); // "hell"
+ */
+declare function trim(str: string, chars?: string | string[], guard?: unknown): string;
+
+export { trim };

package/dist/compat/string/trim.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Removes leading and trailing whitespace or specified characters from a string.
+ *
+ * @param {string} str - The string from which leading and trailing characters will be trimmed.
+ * @param {string | string[]} chars - The character(s) to remove from the end of the string. Defaults to `" "`.
+ * @param guard
+ * @returns {string} - The resulting string after the specified leading and trailing characters have been removed.
+ *
+ * @example
+ * trim("  hello  "); // "hello"
+ * trim("--hello--", "-"); // "hello"
+ * trim("##hello##", ["#", "o"]); // "hell"
+ */
+declare function trim(str: string, chars?: string | string[], guard?: unknown): string;
+
+export { trim };

package/dist/compat/string/trim.mjs

@@ -0,0 +1,25 @@
+import { trim as trim$1 } from '../../string/trim.mjs';
+
+function trim(str, chars, guard) {
+    if (str == null) {
+        return '';
+    }
+    if (guard != null || chars == null) {
+        return str.toString().trim();
+    }
+    switch (typeof chars) {
+        case 'string': {
+            return trim$1(str, chars.toString().split(''));
+        }
+        case 'object': {
+            if (Array.isArray(chars)) {
+                return trim$1(str, chars.map(x => x.toString()));
+            }
+            else {
+                return trim$1(str, chars.toString().split(''));
+            }
+        }
+    }
+}
+
+export { trim };

package/dist/compat/string/trimEnd.d.mts

@@ -0,0 +1,17 @@
+/**
+ * Removes trailing whitespace or specified characters from a string.
+ *
+ * @param {string} str - The string from which trailing characters will be trimmed.
+ * @param {string | string[]} chars - The character(s) to remove from the end of the string. Defaults to `" "`.
+ * @param guard
+ * @returns {string} - The resulting string after the specified trailing character has been removed.
+ *
+ * @example
+ * const trimmedStr1 = trimEnd('hello---', '-') // returns 'hello'
+ * const trimmedStr2 = trimEnd('123000', '0') // returns '123'
+ * const trimmedStr3 = trimEnd('abcabcabc', 'c') // returns 'abcabcab'
+ * const trimmedStr4 = trimEnd('trimmedxxx', 'x') // returns 'trimmed'
+ */
+declare function trimEnd(str: string, chars?: string | string[], guard?: unknown): string;
+
+export { trimEnd };

package/dist/compat/string/trimEnd.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Removes trailing whitespace or specified characters from a string.
+ *
+ * @param {string} str - The string from which trailing characters will be trimmed.
+ * @param {string | string[]} chars - The character(s) to remove from the end of the string. Defaults to `" "`.
+ * @param guard
+ * @returns {string} - The resulting string after the specified trailing character has been removed.
+ *
+ * @example
+ * const trimmedStr1 = trimEnd('hello---', '-') // returns 'hello'
+ * const trimmedStr2 = trimEnd('123000', '0') // returns '123'
+ * const trimmedStr3 = trimEnd('abcabcabc', 'c') // returns 'abcabcab'
+ * const trimmedStr4 = trimEnd('trimmedxxx', 'x') // returns 'trimmed'
+ */
+declare function trimEnd(str: string, chars?: string | string[], guard?: unknown): string;
+
+export { trimEnd };

package/dist/compat/string/trimEnd.mjs

@@ -0,0 +1,25 @@
+import { trimEnd as trimEnd$1 } from '../../string/trimEnd.mjs';
+
+function trimEnd(str, chars, guard) {
+    if (str == null) {
+        return '';
+    }
+    if (guard != null || chars == null) {
+        return str.toString().trimEnd();
+    }
+    switch (typeof chars) {
+        case 'string': {
+            return trimEnd$1(str, chars.toString().split(''));
+        }
+        case 'object': {
+            if (Array.isArray(chars)) {
+                return trimEnd$1(str, chars.map(x => x.toString()));
+            }
+            else {
+                return trimEnd$1(str, chars.toString().split(''));
+            }
+        }
+    }
+}
+
+export { trimEnd };

package/dist/compat/string/trimStart.d.mts

@@ -0,0 +1,17 @@
+/**
+ * Removes leading whitespace or specified characters from a string.
+ *
+ * @param {string} str - The string from which leading characters will be trimmed.
+ * @param {string | string[]} chars - The character(s) to remove from the end of the string. Defaults to `" "`.
+ * @param guard
+ * @returns {string} - The resulting string after the specified leading character has been removed.
+ *
+ * @example
+ * const trimmedStr1 = ltrim('---hello', '-') // returns 'hello'
+ * const trimmedStr2 = ltrim('000123', '0') // returns '123'
+ * const trimmedStr3 = ltrim('abcabcabc', 'a') // returns 'bcabcabc'
+ * const trimmedStr4 = ltrim('xxxtrimmed', 'x') // returns 'trimmed'
+ */
+declare function trimStart(str: string, chars?: string | string[], guard?: unknown): string;
+
+export { trimStart };

package/dist/compat/string/trimStart.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Removes leading whitespace or specified characters from a string.
+ *
+ * @param {string} str - The string from which leading characters will be trimmed.
+ * @param {string | string[]} chars - The character(s) to remove from the end of the string. Defaults to `" "`.
+ * @param guard
+ * @returns {string} - The resulting string after the specified leading character has been removed.
+ *
+ * @example
+ * const trimmedStr1 = ltrim('---hello', '-') // returns 'hello'
+ * const trimmedStr2 = ltrim('000123', '0') // returns '123'
+ * const trimmedStr3 = ltrim('abcabcabc', 'a') // returns 'bcabcabc'
+ * const trimmedStr4 = ltrim('xxxtrimmed', 'x') // returns 'trimmed'
+ */
+declare function trimStart(str: string, chars?: string | string[], guard?: unknown): string;
+
+export { trimStart };

package/dist/compat/string/trimStart.mjs

@@ -0,0 +1,25 @@
+import { trimStart as trimStart$1 } from '../../string/trimStart.mjs';
+
+function trimStart(str, chars, guard) {
+    if (str == null) {
+        return '';
+    }
+    if (guard != null || chars == null) {
+        return str.toString().trimStart();
+    }
+    switch (typeof chars) {
+        case 'string': {
+            return trimStart$1(str, chars.toString().split(''));
+        }
+        case 'object': {
+            if (Array.isArray(chars)) {
+                return trimStart$1(str, chars.map(x => x.toString()));
+            }
+            else {
+                return trimStart$1(str, chars.toString().split(''));
+            }
+        }
+    }
+}
+
+export { trimStart };

package/dist/compat/util/toPath.d.mts

@@ -0,0 +1,20 @@
+/**
+ * Converts a deep key string into an array of path segments.
+ *
+ * This function takes a string representing a deep key (e.g., 'a.b.c' or 'a[b][c]') and breaks it down into an array of strings, each representing a segment of the path.
+ *
+ * @param {string} deepKey - The deep key string to convert.
+ * @returns {string[]} An array of strings, each representing a segment of the path.
+ *
+ * Examples:
+ *
+ * toPath('a.b.c') // Returns ['a', 'b', 'c']
+ * toPath('a[b][c]') // Returns ['a', 'b', 'c']
+ * toPath('.a.b.c') // Returns ['', 'a', 'b', 'c']
+ * toPath('a["b.c"].d') // Returns ['a', 'b.c', 'd']
+ * toPath('') // Returns []
+ * toPath('.a[b].c.d[e]["f.g"].h') // Returns ['', 'a', 'b', 'c', 'd', 'e', 'f.g', 'h']
+ */
+declare function toPath(deepKey: string): string[];
+
+export { toPath };

package/dist/compat/util/toPath.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Converts a deep key string into an array of path segments.
+ *
+ * This function takes a string representing a deep key (e.g., 'a.b.c' or 'a[b][c]') and breaks it down into an array of strings, each representing a segment of the path.
+ *
+ * @param {string} deepKey - The deep key string to convert.
+ * @returns {string[]} An array of strings, each representing a segment of the path.
+ *
+ * Examples:
+ *
+ * toPath('a.b.c') // Returns ['a', 'b', 'c']
+ * toPath('a[b][c]') // Returns ['a', 'b', 'c']
+ * toPath('.a.b.c') // Returns ['', 'a', 'b', 'c']
+ * toPath('a["b.c"].d') // Returns ['a', 'b.c', 'd']
+ * toPath('') // Returns []
+ * toPath('.a[b].c.d[e]["f.g"].h') // Returns ['', 'a', 'b', 'c', 'd', 'e', 'f.g', 'h']
+ */
+declare function toPath(deepKey: string): string[];
+
+export { toPath };

package/dist/compat/util/toPath.mjs

@@ -0,0 +1,37 @@
+const DOTS_KEY = /^[\w.]+$/g;
+const ESCAPE_REGEXP = /\\(\\)?/g;
+const PROPERTY_REGEXP = RegExp('[^.[\\]]+' +
+    '|' +
+    '\\[(?:' +
+    '([^"\'][^[]*)' +
+    '|' +
+    '(["\'])((?:(?!\\2)[^\\\\]|\\\\.)*?)\\2' +
+    ')\\]' +
+    '|' +
+    '(?=(?:\\.|\\[\\])(?:\\.|\\[\\]|$))', 'g');
+function toPath(deepKey) {
+    if (DOTS_KEY.test(deepKey)) {
+        return deepKey.split('.');
+    }
+    const result = [];
+    if (deepKey[0] === '.') {
+        result.push('');
+    }
+    const matches = deepKey.matchAll(PROPERTY_REGEXP);
+    for (const match of matches) {
+        let key = match[0];
+        const expr = match[1];
+        const quote = match[2];
+        const substr = match[3];
+        if (quote) {
+            key = substr.replace(ESCAPE_REGEXP, '$1');
+        }
+        else if (expr) {
+            key = expr;
+        }
+        result.push(key);
+    }
+    return result;
+}
+
+export { toPath };

package/dist/compat/util/toString.d.mts

@@ -0,0 +1,19 @@
+/**
+ * Converts `value` to a string.
+ *
+ * An empty string is returned for `null` and `undefined` values.
+ * The sign of `-0` is preserved.
+ *
+ * @param {unknown} value - The value to convert.
+ * @returns {string} Returns the converted string.
+ *
+ * @example
+ * toString(null) // returns ''
+ * toString(undefined) // returns ''
+ * toString(-0) // returns '-0'
+ * toString([1, 2, -0]) // returns '1,2,-0'
+ * toString([Symbol('a'), Symbol('b')]) // returns 'Symbol(a),Symbol(b)'
+ */
+declare function toString(value?: unknown): string;
+
+export { toString };

package/dist/compat/util/toString.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Converts `value` to a string.
+ *
+ * An empty string is returned for `null` and `undefined` values.
+ * The sign of `-0` is preserved.
+ *
+ * @param {unknown} value - The value to convert.
+ * @returns {string} Returns the converted string.
+ *
+ * @example
+ * toString(null) // returns ''
+ * toString(undefined) // returns ''
+ * toString(-0) // returns '-0'
+ * toString([1, 2, -0]) // returns '1,2,-0'
+ * toString([Symbol('a'), Symbol('b')]) // returns 'Symbol(a),Symbol(b)'
+ */
+declare function toString(value?: unknown): string;
+
+export { toString };

package/dist/compat/util/toString.mjs

@@ -0,0 +1,15 @@
+function toString(value) {
+    if (value == null) {
+        return '';
+    }
+    if (Array.isArray(value)) {
+        return value.map(toString).join(',');
+    }
+    const result = String(value);
+    if (result === '0' && Object.is(Number(value), -0)) {
+        return '-0';
+    }
+    return result;
+}
+
+export { toString };

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';