es-toolkit 1.15.1 → 1.16.0

package/dist/compat/index.mjs

@@ -16,6 +16,7 @@ export { keyBy } from '../array/keyBy.mjs';
 export { maxBy } from '../array/maxBy.mjs';
 export { minBy } from '../array/minBy.mjs';
 export { partition } from '../array/partition.mjs';
+export { sortBy } from '../array/sortBy.mjs';
 export { sample } from '../array/sample.mjs';
 export { sampleSize } from '../array/sampleSize.mjs';
 export { shuffle } from '../array/shuffle.mjs';
@@ -53,7 +54,10 @@ 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 { memoize } from '../function/memoize.mjs';
 export { unary } from '../function/unary.mjs';
+export { partial } from '../function/partial.mjs';
+export { partialRight } from '../function/partialRight.mjs';
 export { clamp } from '../math/clamp.mjs';
 export { inRange } from '../math/inRange.mjs';
 export { mean } from '../math/mean.mjs';
@@ -73,6 +77,7 @@ export { clone } from '../object/clone.mjs';
 export { flattenObject } from '../object/flattenObject.mjs';
 export { cloneDeep } from '../object/cloneDeep.mjs';
 export { isObjectLike } from './predicate/isObjectLike.mjs';
+export { toMerged } from '../object/toMerged.mjs';
 export { isEqual } from '../predicate/isEqual.mjs';
 export { isNil } from '../predicate/isNil.mjs';
 export { isNotNil } from '../predicate/isNotNil.mjs';
@@ -94,16 +99,21 @@ export { chunk } from './array/chunk.mjs';
 export { concat } from './array/concat.mjs';
 export { difference } from './array/difference.mjs';
 export { fill } from './array/fill.mjs';
+export { find } from './array/find.mjs';
+export { findIndex } from './array/findIndex.mjs';
 export { flatten } from './array/flatten.mjs';
 export { flattenDeep } from './array/flattenDeep.mjs';
 export { flattenDepth } from './array/flattenDepth.mjs';
 export { orderBy } from './array/orderBy.mjs';
 export { size } from './array/size.mjs';
 export { zipObjectDeep } from './array/zipObjectDeep.mjs';
+export { indexOf } from './array/indexOf.mjs';
 export { ary } from './function/ary.mjs';
 export { bind } from './function/bind.mjs';
+export { rest } from './function/rest.mjs';
 export { get } from './object/get.mjs';
 export { set } from './object/set.mjs';
+export { has } from './object/has.mjs';
 export { property } from './object/property.mjs';
 export { mapKeys } from './object/mapKeys.mjs';
 export { mapValues } from './object/mapValues.mjs';
@@ -117,9 +127,12 @@ export { isSymbol } from './predicate/isSymbol.mjs';
 export { isBoolean } from './predicate/isBoolean.mjs';
 export { isTypedArray } from './predicate/isTypedArray.mjs';
 export { isMatch } from './predicate/isMatch.mjs';
+export { isString } from './predicate/isString.mjs';
 export { matches } from './predicate/matches.mjs';
+export { matchesProperty } from './predicate/matchesProperty.mjs';
 export { startsWith } from './string/startsWith.mjs';
 export { endsWith } from './string/endsWith.mjs';
 export { padStart } from './string/padStart.mjs';
+export { padEnd } from './string/padEnd.mjs';
 export { max } from './math/max.mjs';
 export { min } from './math/min.mjs';

package/dist/compat/object/get.mjs

@@ -1,4 +1,5 @@
 import { isDeepKey } from '../_internal/isDeepKey.mjs';
+import { toKey } from '../_internal/toKey.mjs';
 import { toPath } from '../_internal/toPath.mjs';
 
 function get(object, path, defaultValue) {
@@ -18,10 +19,7 @@ function get(object, path, defaultValue) {
     let current = object;
     let index;
     for (index = 0; index < resolvedPath.length && current != null; index++) {
-        let key = resolvedPath[index];
-        if (Object.is(key.valueOf(), -0)) {
-            key = '-0';
-        }
+        const key = toKey(resolvedPath[index]);
         current = current[key];
     }
     if (current === null && index === resolvedPath.length) {

package/dist/compat/object/has.d.mts

@@ -0,0 +1,32 @@
+/**
+ * Checks if a given path exists within an object.
+ *
+ * You can provide the path as a single property key, an array of property keys,
+ * or a string representing a deep path.
+ *
+ * If the path is an index and the object is an array or an arguments object, the function will verify
+ * if the index is valid and within the bounds of the array or arguments object, even if the array or
+ * arguments object is sparse (i.e., not all indexes are defined).
+ *
+ * @param {object} object - The object to query.
+ * @param {PropertyKey | PropertyKey[]} path - The path to check. This can be a single property key,
+ *        an array of property keys, or a string representing a deep path.
+ * @returns {boolean} Returns `true` if the path exists in the object, `false` otherwise.
+ *
+ * @example
+ *
+ * const obj = { a: { b: { c: 3 } } };
+ *
+ * has(obj, 'a'); // true
+ * has(obj, ['a', 'b']); // true
+ * has(obj, ['a', 'b', 'c']); // true
+ * has(obj, 'a.b.c'); // true
+ * has(obj, 'a.b.d'); // false
+ * has(obj, ['a', 'b', 'c', 'd']); // false
+ * has([], 0); // false
+ * has([1, 2, 3], 2); // true
+ * has([1, 2, 3], 5); // false
+ */
+declare function has(object: unknown, path: PropertyKey | readonly PropertyKey[]): boolean;
+
+export { has };

package/dist/compat/object/has.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Checks if a given path exists within an object.
+ *
+ * You can provide the path as a single property key, an array of property keys,
+ * or a string representing a deep path.
+ *
+ * If the path is an index and the object is an array or an arguments object, the function will verify
+ * if the index is valid and within the bounds of the array or arguments object, even if the array or
+ * arguments object is sparse (i.e., not all indexes are defined).
+ *
+ * @param {object} object - The object to query.
+ * @param {PropertyKey | PropertyKey[]} path - The path to check. This can be a single property key,
+ *        an array of property keys, or a string representing a deep path.
+ * @returns {boolean} Returns `true` if the path exists in the object, `false` otherwise.
+ *
+ * @example
+ *
+ * const obj = { a: { b: { c: 3 } } };
+ *
+ * has(obj, 'a'); // true
+ * has(obj, ['a', 'b']); // true
+ * has(obj, ['a', 'b', 'c']); // true
+ * has(obj, 'a.b.c'); // true
+ * has(obj, 'a.b.d'); // false
+ * has(obj, ['a', 'b', 'c', 'd']); // false
+ * has([], 0); // false
+ * has([1, 2, 3], 2); // true
+ * has([1, 2, 3], 5); // false
+ */
+declare function has(object: unknown, path: PropertyKey | readonly PropertyKey[]): boolean;
+
+export { has };

package/dist/compat/object/has.mjs

@@ -0,0 +1,34 @@
+import { isDeepKey } from '../_internal/isDeepKey.mjs';
+import { isIndex } from '../_internal/isIndex.mjs';
+import { toPath } from '../_internal/toPath.mjs';
+import { isArguments } from '../predicate/isArguments.mjs';
+
+function has(object, path) {
+    let resolvedPath;
+    if (Array.isArray(path)) {
+        resolvedPath = path;
+    }
+    else if (typeof path === 'string' && isDeepKey(path) && object?.[path] == null) {
+        resolvedPath = toPath(path);
+    }
+    else {
+        resolvedPath = [path];
+    }
+    if (resolvedPath.length === 0) {
+        return false;
+    }
+    let current = object;
+    for (let i = 0; i < resolvedPath.length; i++) {
+        const key = resolvedPath[i];
+        if (current == null || !Object.prototype.hasOwnProperty.call(current, key)) {
+            const isSparseIndex = (Array.isArray(current) || isArguments(current)) && isIndex(key) && key < current.length;
+            if (!isSparseIndex) {
+                return false;
+            }
+        }
+        current = current[key];
+    }
+    return true;
+}
+
+export { has };

package/dist/compat/object/merge.d.mts

@@ -184,6 +184,7 @@ declare function merge<O, S1, S2, S3, S4>(object: O, source1: S1, source2: S2, s
  * The function can handle multiple source objects and will merge them all into the target object.
  *
  * @param {any} any - The target object into which the source object properties will be merged. This object is modified in place.
+ * @param object
  * @param {any[]} sources - The source objects whose properties will be merged into the target object.
  * @returns {any} The updated target object with properties from the source object(s) merged in.
  *

package/dist/compat/object/merge.d.ts

@@ -184,6 +184,7 @@ declare function merge<O, S1, S2, S3, S4>(object: O, source1: S1, source2: S2, s
  * The function can handle multiple source objects and will merge them all into the target object.
  *
  * @param {any} any - The target object into which the source object properties will be merged. This object is modified in place.
+ * @param object
  * @param {any[]} sources - The source objects whose properties will be merged into the target object.
  * @returns {any} The updated target object with properties from the source object(s) merged in.
  *

package/dist/compat/object/mergeWith.d.mts

@@ -20,6 +20,7 @@
  *
  * @param {T} target - The target object into which the source object properties will be merged. This object is modified in place.
  * @param {S} source - The first source object whose properties will be merged into the target object.
+ * @param merge
  * @returns {T & S} The updated target object with properties from the source object(s) merged in.
  *
  * @template T - Type of the target object.
@@ -71,6 +72,7 @@ declare function mergeWith<T, S>(target: T, source: S, merge: (targetValue: any,
  * @param {O} object - The target object into which the source object properties will be merged. This object is modified in place.
  * @param {S1} source1 - The first source object to be merged into the target object.
  * @param {S2} source2 - The second source object to be merged into the target object.
+ * @param merge
  * @returns {O & S1 & S2} The updated target object with properties from the source objects merged in.
  *
  * @template O - Type of the target object.
@@ -124,6 +126,7 @@ declare function mergeWith<O, S1, S2>(object: O, source1: S1, source2: S2, merge
  * @param {S1} source1 - The first source object whose properties will be merged into the target object.
  * @param {S2} source2 - The second source object whose properties will be merged into the target object.
  * @param {S3} source3 - The third source object whose properties will be merged into the target object.
+ * @param merge
  * @returns {O & S1 & S2 & S3} The updated target object with properties from the source object(s) merged in.
  *
  * @template O - Type of the target object.
@@ -179,6 +182,7 @@ declare function mergeWith<O, S1, S2, S3>(object: O, source1: S1, source2: S2, s
  * @param {S2} source2 - The second source object whose properties will be merged into the target object.
  * @param {S3} source3 - The third source object whose properties will be merged into the target object.
  * @param {S4} source4 - The fourth source object whose properties will be merged into the target object.
+ * @param merge
  * @returns {O & S1 & S2 & S3 & S4} The updated target object with properties from the source object(s) merged in.
  *
  * @template O - Type of the target object.
@@ -232,6 +236,8 @@ declare function mergeWith<O, S1, S2, S3, S4>(object: O, source1: S1, source2: S
  *
  * @param {any} any - The target object into which the source object properties will be merged. This object is modified in place.
  * @param {any[]} sources - The source objects whose properties will be merged into the target object.
+ * @param object
+ * @param {...any} otherArgs
  * @returns {any} The updated target object with properties from the source object(s) merged in.
  *
  * @example

package/dist/compat/object/mergeWith.d.ts

@@ -20,6 +20,7 @@
  *
  * @param {T} target - The target object into which the source object properties will be merged. This object is modified in place.
  * @param {S} source - The first source object whose properties will be merged into the target object.
+ * @param merge
  * @returns {T & S} The updated target object with properties from the source object(s) merged in.
  *
  * @template T - Type of the target object.
@@ -71,6 +72,7 @@ declare function mergeWith<T, S>(target: T, source: S, merge: (targetValue: any,
  * @param {O} object - The target object into which the source object properties will be merged. This object is modified in place.
  * @param {S1} source1 - The first source object to be merged into the target object.
  * @param {S2} source2 - The second source object to be merged into the target object.
+ * @param merge
  * @returns {O & S1 & S2} The updated target object with properties from the source objects merged in.
  *
  * @template O - Type of the target object.
@@ -124,6 +126,7 @@ declare function mergeWith<O, S1, S2>(object: O, source1: S1, source2: S2, merge
  * @param {S1} source1 - The first source object whose properties will be merged into the target object.
  * @param {S2} source2 - The second source object whose properties will be merged into the target object.
  * @param {S3} source3 - The third source object whose properties will be merged into the target object.
+ * @param merge
  * @returns {O & S1 & S2 & S3} The updated target object with properties from the source object(s) merged in.
  *
  * @template O - Type of the target object.
@@ -179,6 +182,7 @@ declare function mergeWith<O, S1, S2, S3>(object: O, source1: S1, source2: S2, s
  * @param {S2} source2 - The second source object whose properties will be merged into the target object.
  * @param {S3} source3 - The third source object whose properties will be merged into the target object.
  * @param {S4} source4 - The fourth source object whose properties will be merged into the target object.
+ * @param merge
  * @returns {O & S1 & S2 & S3 & S4} The updated target object with properties from the source object(s) merged in.
  *
  * @template O - Type of the target object.
@@ -232,6 +236,8 @@ declare function mergeWith<O, S1, S2, S3, S4>(object: O, source1: S1, source2: S
  *
  * @param {any} any - The target object into which the source object properties will be merged. This object is modified in place.
  * @param {any[]} sources - The source objects whose properties will be merged into the target object.
+ * @param object
+ * @param {...any} otherArgs
  * @returns {any} The updated target object with properties from the source object(s) merged in.
  *
  * @example

package/dist/compat/object/mergeWith.mjs

@@ -56,9 +56,6 @@ function mergeWithDeep(target, source, merge, stack) {
         else if (isObjectLike(targetValue) && isObjectLike(sourceValue)) {
             target[key] = mergeWithDeep(targetValue, sourceValue, merge, stack);
         }
-        else if (targetValue == null && Array.isArray(sourceValue)) {
-            target[key] = mergeWithDeep([], sourceValue, merge, stack);
-        }
         else if (targetValue == null && isPlainObject(sourceValue)) {
             target[key] = mergeWithDeep({}, sourceValue, merge, stack);
         }

package/dist/compat/object/set.mjs

@@ -2,11 +2,7 @@ import { isIndex } from '../_internal/isIndex.mjs';
 import { toPath } from '../_internal/toPath.mjs';
 
 function set(obj, path, value) {
-    const resolvedPath = Array.isArray(path)
-        ? path
-        : typeof path === 'string'
-            ? toPath(path)
-            : [path];
+    const resolvedPath = Array.isArray(path) ? path : typeof path === 'string' ? toPath(path) : [path];
     let current = obj;
     for (let i = 0; i < resolvedPath.length - 1; i++) {
         const key = resolvedPath[i];

package/dist/compat/predicate/isArrayLike.mjs

@@ -1,8 +1,7 @@
 import { isLength } from '../../predicate/isLength.mjs';
 
 function isArrayLike(value) {
-    return value != null && typeof value !== "function" &&
-        isLength(value.length);
+    return value != null && typeof value !== 'function' && isLength(value.length);
 }
 
 export { isArrayLike };

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

@@ -0,0 +1,20 @@
+/**
+ * Checks if a given value is stirng.
+ *
+ * This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to `string`.
+ *
+ * @param {unknown} value The value to check if it is string.
+ * @returns {value is string} Returns `true` if `value` is a stirng, else `false`.
+ *
+ * @example
+ * const value1 = 'abc';
+ * const value2 = 123;
+ * const value3 = true;
+ *
+ * console.log(isString(value1)); // true
+ * console.log(isString(value2)); // false
+ * console.log(isString(value3)); // false
+ */
+declare function isString(value: unknown): value is string;
+
+export { isString };

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

@@ -0,0 +1,20 @@
+/**
+ * Checks if a given value is stirng.
+ *
+ * This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to `string`.
+ *
+ * @param {unknown} value The value to check if it is string.
+ * @returns {value is string} Returns `true` if `value` is a stirng, else `false`.
+ *
+ * @example
+ * const value1 = 'abc';
+ * const value2 = 123;
+ * const value3 = true;
+ *
+ * console.log(isString(value1)); // true
+ * console.log(isString(value2)); // false
+ * console.log(isString(value3)); // false
+ */
+declare function isString(value: unknown): value is string;
+
+export { isString };

package/dist/compat/predicate/isString.mjs

@@ -0,0 +1,13 @@
+import { getTag } from '../_internal/getTag.mjs';
+
+function isString(value) {
+    if (typeof value === 'string') {
+        return true;
+    }
+    if (typeof value === 'object' && value != null && getTag(value) === '[object String]') {
+        return true;
+    }
+    return false;
+}
+
+export { isString };

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

@@ -0,0 +1,28 @@
+/**
+ * Creates a function that checks if a given target object matches a specific property value.
+ *
+ * The returned function takes a target object and determines if the property at the
+ * specified path within the target object is equal to the given value.
+ *
+ * @param {PropertyKey | PropertyKey[]} property - The property path to check within the target object.
+ *     This can be a single property key or an array of property keys.
+ * @param {unknown} source - The value to compare against the property value in the target object.
+ *
+ * @returns {(target: unknown) => boolean} - A function that takes a target object and returns
+ *     `true` if the property value at the given path in the target object matches the provided value,
+ *     otherwise returns `false`.
+ *
+ * @example
+ * // Using a single property key
+ * const checkName = matchesProperty('name', 'Alice');
+ * console.log(checkName({ name: 'Alice' })); // true
+ * console.log(checkName({ name: 'Bob' })); // false
+ *
+ * // Using an array of property keys
+ * const checkNested = matchesProperty(['address', 'city'], 'New York');
+ * console.log(checkNested({ address: { city: 'New York' } })); // true
+ * console.log(checkNested({ address: { city: 'Los Angeles' } })); // false
+ */
+declare function matchesProperty(property: PropertyKey | readonly PropertyKey[], source: unknown): (target?: unknown) => boolean;
+
+export { matchesProperty };

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

@@ -0,0 +1,28 @@
+/**
+ * Creates a function that checks if a given target object matches a specific property value.
+ *
+ * The returned function takes a target object and determines if the property at the
+ * specified path within the target object is equal to the given value.
+ *
+ * @param {PropertyKey | PropertyKey[]} property - The property path to check within the target object.
+ *     This can be a single property key or an array of property keys.
+ * @param {unknown} source - The value to compare against the property value in the target object.
+ *
+ * @returns {(target: unknown) => boolean} - A function that takes a target object and returns
+ *     `true` if the property value at the given path in the target object matches the provided value,
+ *     otherwise returns `false`.
+ *
+ * @example
+ * // Using a single property key
+ * const checkName = matchesProperty('name', 'Alice');
+ * console.log(checkName({ name: 'Alice' })); // true
+ * console.log(checkName({ name: 'Bob' })); // false
+ *
+ * // Using an array of property keys
+ * const checkNested = matchesProperty(['address', 'city'], 'New York');
+ * console.log(checkNested({ address: { city: 'New York' } })); // true
+ * console.log(checkNested({ address: { city: 'Los Angeles' } })); // false
+ */
+declare function matchesProperty(property: PropertyKey | readonly PropertyKey[], source: unknown): (target?: unknown) => boolean;
+
+export { matchesProperty };

package/dist/compat/predicate/matchesProperty.mjs

@@ -0,0 +1,22 @@
+import { toKey } from '../_internal/toKey.mjs';
+import { cloneDeep } from '../object/cloneDeep.mjs';
+import { get } from '../object/get.mjs';
+import { has } from '../object/has.mjs';
+import { isMatch } from './isMatch.mjs';
+
+function matchesProperty(property, source) {
+    property = Array.isArray(property) ? property : toKey(property);
+    source = cloneDeep(source);
+    return function (target) {
+        const result = get(target, property);
+        if (result === undefined) {
+            return has(target, property);
+        }
+        if (source === undefined) {
+            return result === undefined;
+        }
+        return isMatch(result, source);
+    };
+}
+
+export { matchesProperty };

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

@@ -0,0 +1,20 @@
+/**
+ * Pads the end of a string with a given character until it reaches the specified length.
+ *
+ * If the length is less than or equal to the original string's length, or if the padding character is an empty string,
+ * the original string is returned unchanged.
+ *
+ * @param {string} str - The string to pad.
+ * @param {number} [length] - The length of the resulting string once padded.
+ * @param {string} [chars] - The character(s) to use for padding.
+ * @returns {string} - The padded string, or the original string if padding is not required.
+ *
+ * @example
+ * const result1 = padEnd('abc', 6);          // result will be 'abc   '
+ * const result2 = padEnd('abc', 6, '_-');    // result will be 'abc_-_'
+ * const result3 = padEnd('abc', 3);          // result will be 'abc'
+ * const result4 = padEnd('abc', 2);          // result will be 'abc'
+ */
+declare function padEnd(str: string, length?: number, chars?: string): string;
+
+export { padEnd };

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

@@ -0,0 +1,20 @@
+/**
+ * Pads the end of a string with a given character until it reaches the specified length.
+ *
+ * If the length is less than or equal to the original string's length, or if the padding character is an empty string,
+ * the original string is returned unchanged.
+ *
+ * @param {string} str - The string to pad.
+ * @param {number} [length] - The length of the resulting string once padded.
+ * @param {string} [chars] - The character(s) to use for padding.
+ * @returns {string} - The padded string, or the original string if padding is not required.
+ *
+ * @example
+ * const result1 = padEnd('abc', 6);          // result will be 'abc   '
+ * const result2 = padEnd('abc', 6, '_-');    // result will be 'abc_-_'
+ * const result3 = padEnd('abc', 3);          // result will be 'abc'
+ * const result4 = padEnd('abc', 2);          // result will be 'abc'
+ */
+declare function padEnd(str: string, length?: number, chars?: string): string;
+
+export { padEnd };

package/dist/compat/string/padEnd.mjs

@@ -0,0 +1,5 @@
+function padEnd(str, length = 0, chars = ' ') {
+    return str.padEnd(length, chars);
+}
+
+export { padEnd };

package/dist/function/ary.d.mts

@@ -7,6 +7,6 @@
  * @param {any} guard - Enables use as an iteratee for methods like `map`.
  * @returns {(...args: any[]) => ReturnType<F>} Returns the new capped function.
  */
-declare function ary<F extends (...args: any[]) => any>(func: F, n: number): ((...args: any[]) => ReturnType<F>);
+declare function ary<F extends (...args: any[]) => any>(func: F, n: number): (...args: any[]) => ReturnType<F>;
 
 export { ary };

package/dist/function/ary.d.ts

@@ -7,6 +7,6 @@
  * @param {any} guard - Enables use as an iteratee for methods like `map`.
  * @returns {(...args: any[]) => ReturnType<F>} Returns the new capped function.
  */
-declare function ary<F extends (...args: any[]) => any>(func: F, n: number): ((...args: any[]) => ReturnType<F>);
+declare function ary<F extends (...args: any[]) => any>(func: F, n: number): (...args: any[]) => ReturnType<F>;
 
 export { ary };

package/dist/function/index.d.mts

@@ -5,5 +5,9 @@ export { noop } from './noop.mjs';
 export { once } from './once.mjs';
 export { throttle } from './throttle.mjs';
 export { negate } from './negate.mjs';
+export { MemoizeCache, memoize } from './memoize.mjs';
 export { ary } from './ary.mjs';
 export { unary } from './unary.mjs';
+export { partial } from './partial.mjs';
+export { partialRight } from './partialRight.mjs';
+export { rest } from './rest.mjs';

package/dist/function/index.d.ts

@@ -5,5 +5,9 @@ export { noop } from './noop.js';
 export { once } from './once.js';
 export { throttle } from './throttle.js';
 export { negate } from './negate.js';
+export { MemoizeCache, memoize } from './memoize.js';
 export { ary } from './ary.js';
 export { unary } from './unary.js';
+export { partial } from './partial.js';
+export { partialRight } from './partialRight.js';
+export { rest } from './rest.js';

package/dist/function/index.js

@@ -87,6 +87,21 @@ function negate(func) {
     return ((...args) => !func(...args));
 }
 
+function memoize(fn, options = {}) {
+    const { cache = new Map(), getCacheKey } = options;
+    const memoizedFn = function (arg) {
+        const key = getCacheKey ? getCacheKey(arg) : arg;
+        if (cache.has(key)) {
+            return cache.get(key);
+        }
+        const result = fn.call(this, arg);
+        cache.set(key, result);
+        return result;
+    };
+    memoizedFn.cache = cache;
+    return memoizedFn;
+}
+
 function ary(func, n) {
     return function (...args) {
         return func.apply(this, args.slice(0, n));
@@ -97,12 +112,73 @@ function unary(func) {
     return ary(func, 1);
 }
 
+function partial(func, ...partialArgs) {
+    return function (...providedArgs) {
+        const args = [];
+        let startIndex = 0;
+        for (let i = 0; i < partialArgs.length; i++) {
+            const arg = partialArgs[i];
+            if (arg === partial.placeholder) {
+                args.push(providedArgs[startIndex++]);
+            }
+            else {
+                args.push(arg);
+            }
+        }
+        for (let i = startIndex; i < providedArgs.length; i++) {
+            args.push(providedArgs[i]);
+        }
+        return func.apply(this, args);
+    };
+}
+const partialPlaceholder = Symbol('partial.placeholder');
+partial.placeholder = partialPlaceholder;
+
+function partialRight(func, ...partialArgs) {
+    return function (...providedArgs) {
+        const placeholderLength = partialArgs.filter(arg => arg === partialRightPlaceholder).length;
+        const rangeLength = Math.max(providedArgs.length - placeholderLength, 0);
+        const args = [];
+        let providedIndex = 0;
+        for (let i = 0; i < rangeLength; i++) {
+            args.push(providedArgs[providedIndex++]);
+        }
+        for (let i = 0; i < partialArgs.length; i++) {
+            const arg = partialArgs[i];
+            if (arg === partialRight.placeholder) {
+                args.push(providedArgs[providedIndex++]);
+            }
+            else {
+                args.push(arg);
+            }
+        }
+        return func.apply(this, args);
+    };
+}
+const partialRightPlaceholder = Symbol('partialRight.placeholder');
+partialRight.placeholder = partialRightPlaceholder;
+
+function rest(func, startIndex = func.length - 1) {
+    return function (...args) {
+        const rest = args.slice(startIndex);
+        const params = args.slice(0, startIndex);
+        while (params.length < startIndex) {
+            params.push(undefined);
+        }
+        return func.apply(this, [...params, rest]);
+    };
+}
+
 exports.after = after;
 exports.ary = ary;
 exports.before = before;
 exports.debounce = debounce;
+exports.memoize = memoize;
 exports.negate = negate;
 exports.noop = noop;
 exports.once = once;
+exports.partial = partial;
+exports.partialRight = partialRight;
+exports.rest = rest;
 exports.throttle = throttle;
 exports.unary = unary;

package/dist/function/index.mjs

@@ -5,5 +5,9 @@ export { noop } from './noop.mjs';
 export { once } from './once.mjs';
 export { throttle } from './throttle.mjs';
 export { negate } from './negate.mjs';
+export { memoize } from './memoize.mjs';
 export { ary } from './ary.mjs';
 export { unary } from './unary.mjs';
+export { partial } from './partial.mjs';
+export { partialRight } from './partialRight.mjs';
+export { rest } from './rest.mjs';