es-toolkit 1.15.1 → 1.16.0

package/dist/function/memoize.d.mts

@@ -0,0 +1,87 @@
+/**
+ * Creates a memoized version of the provided function. The memoized function caches
+ * results based on the argument it receives, so if the same argument is passed again,
+ * it returns the cached result instead of recomputing it.
+ *
+ * This function works with functions that take zero or just one argument. If your function
+ * originally takes multiple arguments, you should refactor it to take a single object or array
+ * that combines those arguments.
+ *
+ * If the argument is not primitive (e.g., arrays or objects), provide a
+ * `getCacheKey` function to generate a unique cache key for proper caching.
+ *
+ * @param {F} fn - The function to be memoized. It should accept a single argument and return a value.
+ * @param {MemoizeOptions<Parameters<F>[0], ReturnType<F>>} [options={}] - Optional configuration for the memoization.
+ * @param {MemoizeCache<any, V>} [options.cache] - The cache object used to store results. Defaults to a new `Map`.
+ * @param {(args: A) => unknown} [options.getCacheKey] - An optional function to generate a unique cache key for each argument.
+ *
+ * @returns {F & { cache: MemoizeCache<any, ReturnType<F>> }} - The memoized function with an additional `cache` property that exposes the internal cache.
+ *
+ * @example
+ * // Example using the default cache
+ * const add = (x: number) => x + 10;
+ * const memoizedAdd = memoize(add);
+ *
+ * console.log(memoizedAdd(5)); // 15
+ * console.log(memoizedAdd(5)); // 15 (cached result)
+ * console.log(memoizedAdd.cache.size); // 1
+ *
+ * @example
+ * // Example using a custom resolver
+ * const sum = (arr: number[]) => arr.reduce((x, y) => x + y, 0);
+ * const memoizedSum = memoize(sum, { getCacheKey: (arr: number[]) => arr.join(',') });
+ * console.log(memoizedSum([1, 2])); // 3
+ * console.log(memoizedSum([1, 2])); // 3 (cached result)
+ * console.log(memoizedSum.cache.size); // 1
+ *
+ * @example
+ * // Example using a custom cache implementation
+ * class CustomCache<K, T> implements MemoizeCache<K, T> {
+ *   private cache = new Map<K, T>();
+ *
+ *   set(key: K, value: T): void {
+ *     this.cache.set(key, value);
+ *   }
+ *
+ *   get(key: K): T | undefined {
+ *     return this.cache.get(key);
+ *   }
+ *
+ *   has(key: K): boolean {
+ *     return this.cache.has(key);
+ *   }
+ *
+ *   delete(key: K): boolean {
+ *     return this.cache.delete(key);
+ *   }
+ *
+ *   clear(): void {
+ *     this.cache.clear();
+ *   }
+ *
+ *   get size(): number {
+ *     return this.cache.size;
+ *   }
+ * }
+ * const customCache = new CustomCache<string, number>();
+ * const memoizedSumWithCustomCache = memoize(sum, { cache: customCache });
+ * console.log(memoizedSumWithCustomCache([1, 2])); // 3
+ * console.log(memoizedSumWithCustomCache([1, 2])); // 3 (cached result)
+ * console.log(memoizedAddWithCustomCache.cache.size); // 1
+ */
+declare function memoize<F extends (...args: any) => any>(fn: F, options?: {
+    cache?: MemoizeCache<any, ReturnType<F>>;
+    getCacheKey?: (args: Parameters<F>[0]) => unknown;
+}): F & {
+    cache: MemoizeCache<any, ReturnType<F>>;
+};
+interface MemoizeCache<K, V> {
+    set(key: K, value: V): void;
+    get(key: K): V | undefined;
+    has(key: K): boolean;
+    delete(key: K): boolean | void;
+    clear(): void;
+    size: number;
+}
+
+export { type MemoizeCache, memoize };

package/dist/function/memoize.d.ts

@@ -0,0 +1,87 @@
+/**
+ * Creates a memoized version of the provided function. The memoized function caches
+ * results based on the argument it receives, so if the same argument is passed again,
+ * it returns the cached result instead of recomputing it.
+ *
+ * This function works with functions that take zero or just one argument. If your function
+ * originally takes multiple arguments, you should refactor it to take a single object or array
+ * that combines those arguments.
+ *
+ * If the argument is not primitive (e.g., arrays or objects), provide a
+ * `getCacheKey` function to generate a unique cache key for proper caching.
+ *
+ * @param {F} fn - The function to be memoized. It should accept a single argument and return a value.
+ * @param {MemoizeOptions<Parameters<F>[0], ReturnType<F>>} [options={}] - Optional configuration for the memoization.
+ * @param {MemoizeCache<any, V>} [options.cache] - The cache object used to store results. Defaults to a new `Map`.
+ * @param {(args: A) => unknown} [options.getCacheKey] - An optional function to generate a unique cache key for each argument.
+ *
+ * @returns {F & { cache: MemoizeCache<any, ReturnType<F>> }} - The memoized function with an additional `cache` property that exposes the internal cache.
+ *
+ * @example
+ * // Example using the default cache
+ * const add = (x: number) => x + 10;
+ * const memoizedAdd = memoize(add);
+ *
+ * console.log(memoizedAdd(5)); // 15
+ * console.log(memoizedAdd(5)); // 15 (cached result)
+ * console.log(memoizedAdd.cache.size); // 1
+ *
+ * @example
+ * // Example using a custom resolver
+ * const sum = (arr: number[]) => arr.reduce((x, y) => x + y, 0);
+ * const memoizedSum = memoize(sum, { getCacheKey: (arr: number[]) => arr.join(',') });
+ * console.log(memoizedSum([1, 2])); // 3
+ * console.log(memoizedSum([1, 2])); // 3 (cached result)
+ * console.log(memoizedSum.cache.size); // 1
+ *
+ * @example
+ * // Example using a custom cache implementation
+ * class CustomCache<K, T> implements MemoizeCache<K, T> {
+ *   private cache = new Map<K, T>();
+ *
+ *   set(key: K, value: T): void {
+ *     this.cache.set(key, value);
+ *   }
+ *
+ *   get(key: K): T | undefined {
+ *     return this.cache.get(key);
+ *   }
+ *
+ *   has(key: K): boolean {
+ *     return this.cache.has(key);
+ *   }
+ *
+ *   delete(key: K): boolean {
+ *     return this.cache.delete(key);
+ *   }
+ *
+ *   clear(): void {
+ *     this.cache.clear();
+ *   }
+ *
+ *   get size(): number {
+ *     return this.cache.size;
+ *   }
+ * }
+ * const customCache = new CustomCache<string, number>();
+ * const memoizedSumWithCustomCache = memoize(sum, { cache: customCache });
+ * console.log(memoizedSumWithCustomCache([1, 2])); // 3
+ * console.log(memoizedSumWithCustomCache([1, 2])); // 3 (cached result)
+ * console.log(memoizedAddWithCustomCache.cache.size); // 1
+ */
+declare function memoize<F extends (...args: any) => any>(fn: F, options?: {
+    cache?: MemoizeCache<any, ReturnType<F>>;
+    getCacheKey?: (args: Parameters<F>[0]) => unknown;
+}): F & {
+    cache: MemoizeCache<any, ReturnType<F>>;
+};
+interface MemoizeCache<K, V> {
+    set(key: K, value: V): void;
+    get(key: K): V | undefined;
+    has(key: K): boolean;
+    delete(key: K): boolean | void;
+    clear(): void;
+    size: number;
+}
+
+export { type MemoizeCache, memoize };

package/dist/function/memoize.mjs

@@ -0,0 +1,16 @@
+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;
+}
+
+export { memoize };

package/dist/function/partial.d.mts

@@ -0,0 +1,33 @@
+/**
+ * Creates a function that invokes `func` with `partialArgs` prepended to the arguments it receives. This method is like `bind` except it does not alter the `this` binding.
+ *
+ * The partial.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 partially applied functions.
+ *
+ * @template F The type of the function to partially apply.
+ * @param {F} func The function to partially apply arguments to.
+ * @param {any[]} partialArgs The arguments to be partially applied.
+ * @returns {F} Returns the new partially applied function.
+ *
+ * @example
+ * function greet(greeting, name) {
+ *   return greeting + ' ' + name;
+ * }
+ *
+ * const sayHelloTo = partial(greet, 'hello');
+ * sayHelloTo('fred');
+ * // => 'hello fred'
+ *
+ * // Partially applied with placeholders.
+ * const greetFred = partial(greet, partial.placeholder, 'fred');
+ * greetFred('hi');
+ * // => 'hi fred'
+ */
+declare function partial<F extends (...args: any[]) => any>(func: F, ...partialArgs: any[]): F;
+declare namespace partial {
+    var placeholder: typeof partialPlaceholder;
+}
+declare const partialPlaceholder: unique symbol;
+
+export { partial };

package/dist/function/partial.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Creates a function that invokes `func` with `partialArgs` prepended to the arguments it receives. This method is like `bind` except it does not alter the `this` binding.
+ *
+ * The partial.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 partially applied functions.
+ *
+ * @template F The type of the function to partially apply.
+ * @param {F} func The function to partially apply arguments to.
+ * @param {any[]} partialArgs The arguments to be partially applied.
+ * @returns {F} Returns the new partially applied function.
+ *
+ * @example
+ * function greet(greeting, name) {
+ *   return greeting + ' ' + name;
+ * }
+ *
+ * const sayHelloTo = partial(greet, 'hello');
+ * sayHelloTo('fred');
+ * // => 'hello fred'
+ *
+ * // Partially applied with placeholders.
+ * const greetFred = partial(greet, partial.placeholder, 'fred');
+ * greetFred('hi');
+ * // => 'hi fred'
+ */
+declare function partial<F extends (...args: any[]) => any>(func: F, ...partialArgs: any[]): F;
+declare namespace partial {
+    var placeholder: typeof partialPlaceholder;
+}
+declare const partialPlaceholder: unique symbol;
+
+export { partial };

package/dist/function/partial.mjs

@@ -0,0 +1,23 @@
+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;
+
+export { partial };

package/dist/function/partialRight.d.mts

@@ -0,0 +1,33 @@
+/**
+ * This method is like `partial` except that partially applied arguments are appended to the arguments it receives.
+ *
+ * The partialRight.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 partially applied functions.
+ *
+ * @template F The type of the function to partially apply.
+ * @param {F} func The function to partially apply arguments to.
+ * @param {any[]} partialArgs The arguments to be partially applied.
+ * @returns {F} Returns the new partially applied function.
+ *
+ * @example
+ * function greet(greeting, name) {
+ *   return greeting + ' ' + name;
+ * }
+ *
+ * const greetFred = partialRight(greet, 'fred');
+ * greetFred('hi');
+ * // => 'hi fred'
+ *
+ * // Partially applied with placeholders.
+ * const sayHelloTo = partialRight(greet, 'hello', partialRight.placeholder);
+ * sayHelloTo('fred');
+ * // => 'hello fred'
+ */
+declare function partialRight<F extends (...args: any[]) => any>(func: F, ...partialArgs: any[]): F;
+declare namespace partialRight {
+    var placeholder: typeof partialRightPlaceholder;
+}
+declare const partialRightPlaceholder: unique symbol;
+
+export { partialRight };

package/dist/function/partialRight.d.ts

@@ -0,0 +1,33 @@
+/**
+ * This method is like `partial` except that partially applied arguments are appended to the arguments it receives.
+ *
+ * The partialRight.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 partially applied functions.
+ *
+ * @template F The type of the function to partially apply.
+ * @param {F} func The function to partially apply arguments to.
+ * @param {any[]} partialArgs The arguments to be partially applied.
+ * @returns {F} Returns the new partially applied function.
+ *
+ * @example
+ * function greet(greeting, name) {
+ *   return greeting + ' ' + name;
+ * }
+ *
+ * const greetFred = partialRight(greet, 'fred');
+ * greetFred('hi');
+ * // => 'hi fred'
+ *
+ * // Partially applied with placeholders.
+ * const sayHelloTo = partialRight(greet, 'hello', partialRight.placeholder);
+ * sayHelloTo('fred');
+ * // => 'hello fred'
+ */
+declare function partialRight<F extends (...args: any[]) => any>(func: F, ...partialArgs: any[]): F;
+declare namespace partialRight {
+    var placeholder: typeof partialRightPlaceholder;
+}
+declare const partialRightPlaceholder: unique symbol;
+
+export { partialRight };

package/dist/function/partialRight.mjs

@@ -0,0 +1,25 @@
+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;
+
+export { partialRight };

package/dist/function/rest.d.mts

@@ -0,0 +1,33 @@
+/**
+ * Creates a function that transforms the arguments of the provided function `func`.
+ * The transformed arguments are passed to `func` such that the arguments starting from a specified index
+ * are grouped into an array, while the previous arguments are passed as individual elements.
+ *
+ * @template F - The type of the function being transformed.
+ * @param {F} func - The function whose arguments are to be transformed.
+ * @param {number} [startIndex=func.length - 1] - The index from which to start grouping the remaining arguments into an array.
+ *                                            Defaults to `func.length - 1`, grouping all arguments after the last parameter.
+ * @returns {(...args: any[]) => ReturnType<F>} A new function that, when called, returns the result of calling `func` with the transformed arguments.
+ *
+ * The transformed arguments are:
+ * - The first `start` arguments as individual elements.
+ * - The remaining arguments from index `start` onward grouped into an array.
+ * @example
+ * function fn(a, b, c) {
+ *   return [a, b, c];
+ * }
+ *
+ * // Using default start index (func.length - 1, which is 2 in this case)
+ * const transformedFn = rest(fn);
+ * console.log(transformedFn(1, 2, 3, 4)); // [1, 2, [3, 4]]
+ *
+ * // Using start index 1
+ * const transformedFnWithStart = rest(fn, 1);
+ * console.log(transformedFnWithStart(1, 2, 3, 4)); // [1, [2, 3, 4]]
+ *
+ * // With fewer arguments than the start index
+ * console.log(transformedFn(1)); // [1, undefined, []]
+ */
+declare function rest<F extends (...args: any[]) => any>(func: F, startIndex?: number): (...args: any[]) => ReturnType<F>;
+
+export { rest };

package/dist/function/rest.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Creates a function that transforms the arguments of the provided function `func`.
+ * The transformed arguments are passed to `func` such that the arguments starting from a specified index
+ * are grouped into an array, while the previous arguments are passed as individual elements.
+ *
+ * @template F - The type of the function being transformed.
+ * @param {F} func - The function whose arguments are to be transformed.
+ * @param {number} [startIndex=func.length - 1] - The index from which to start grouping the remaining arguments into an array.
+ *                                            Defaults to `func.length - 1`, grouping all arguments after the last parameter.
+ * @returns {(...args: any[]) => ReturnType<F>} A new function that, when called, returns the result of calling `func` with the transformed arguments.
+ *
+ * The transformed arguments are:
+ * - The first `start` arguments as individual elements.
+ * - The remaining arguments from index `start` onward grouped into an array.
+ * @example
+ * function fn(a, b, c) {
+ *   return [a, b, c];
+ * }
+ *
+ * // Using default start index (func.length - 1, which is 2 in this case)
+ * const transformedFn = rest(fn);
+ * console.log(transformedFn(1, 2, 3, 4)); // [1, 2, [3, 4]]
+ *
+ * // Using start index 1
+ * const transformedFnWithStart = rest(fn, 1);
+ * console.log(transformedFnWithStart(1, 2, 3, 4)); // [1, [2, 3, 4]]
+ *
+ * // With fewer arguments than the start index
+ * console.log(transformedFn(1)); // [1, undefined, []]
+ */
+declare function rest<F extends (...args: any[]) => any>(func: F, startIndex?: number): (...args: any[]) => ReturnType<F>;
+
+export { rest };

package/dist/function/rest.mjs

@@ -0,0 +1,12 @@
+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]);
+    };
+}
+
+export { rest };

package/dist/function/unary.d.mts

@@ -5,6 +5,6 @@
  * @param {F} func - The function to cap arguments for.
  * @returns {(...args: any[]) => ReturnType<F>} Returns the new capped function.
  */
-declare function unary<F extends (...args: any[]) => any>(func: F): ((...args: any[]) => ReturnType<F>);
+declare function unary<F extends (...args: any[]) => any>(func: F): (...args: any[]) => ReturnType<F>;
 
 export { unary };

package/dist/function/unary.d.ts

@@ -5,6 +5,6 @@
  * @param {F} func - The function to cap arguments for.
  * @returns {(...args: any[]) => ReturnType<F>} Returns the new capped function.
  */
-declare function unary<F extends (...args: any[]) => any>(func: F): ((...args: any[]) => ReturnType<F>);
+declare function unary<F extends (...args: any[]) => any>(func: F): (...args: any[]) => ReturnType<F>;
 
 export { unary };

package/dist/index.d.mts

@@ -22,6 +22,7 @@ export { maxBy } from './array/maxBy.mjs';
 export { minBy } from './array/minBy.mjs';
 export { orderBy } from './array/orderBy.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';
@@ -59,8 +60,12 @@ 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 { ary } from './function/ary.mjs';
 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 { clamp } from './math/clamp.mjs';
 export { inRange } from './math/inRange.mjs';
 export { mean } from './math/mean.mjs';
@@ -82,6 +87,7 @@ export { mapKeys } from './object/mapKeys.mjs';
 export { mapValues } from './object/mapValues.mjs';
 export { cloneDeep } from './object/cloneDeep.mjs';
 export { merge } from './object/merge.mjs';
+export { toMerged } from './object/toMerged.mjs';
 export { mergeWith } from './object/mergeWith.mjs';
 export { isEqual } from './predicate/isEqual.mjs';
 export { isNil } from './predicate/isNil.mjs';
@@ -95,6 +101,7 @@ export { isTypedArray } from './predicate/isTypedArray.mjs';
 export { isPrimitive } from './predicate/isPrimitive.mjs';
 export { isBoolean } from './predicate/isBoolean.mjs';
 export { isSymbol } from './predicate/isSymbol.mjs';
+export { isString } from './predicate/isString.mjs';
 export { delay } from './promise/delay.mjs';
 export { withTimeout } from './promise/withTimeout.mjs';
 export { camelCase } from './string/camelCase.mjs';

package/dist/index.d.ts

@@ -22,6 +22,7 @@ export { maxBy } from './array/maxBy.js';
 export { minBy } from './array/minBy.js';
 export { orderBy } from './array/orderBy.js';
 export { partition } from './array/partition.js';
+export { sortBy } from './array/sortBy.js';
 export { sample } from './array/sample.js';
 export { sampleSize } from './array/sampleSize.js';
 export { shuffle } from './array/shuffle.js';
@@ -59,8 +60,12 @@ export { noop } from './function/noop.js';
 export { once } from './function/once.js';
 export { throttle } from './function/throttle.js';
 export { negate } from './function/negate.js';
+export { MemoizeCache, memoize } from './function/memoize.js';
 export { ary } from './function/ary.js';
 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 { clamp } from './math/clamp.js';
 export { inRange } from './math/inRange.js';
 export { mean } from './math/mean.js';
@@ -82,6 +87,7 @@ export { mapKeys } from './object/mapKeys.js';
 export { mapValues } from './object/mapValues.js';
 export { cloneDeep } from './object/cloneDeep.js';
 export { merge } from './object/merge.js';
+export { toMerged } from './object/toMerged.js';
 export { mergeWith } from './object/mergeWith.js';
 export { isEqual } from './predicate/isEqual.js';
 export { isNil } from './predicate/isNil.js';
@@ -95,6 +101,7 @@ export { isTypedArray } from './predicate/isTypedArray.js';
 export { isPrimitive } from './predicate/isPrimitive.js';
 export { isBoolean } from './predicate/isBoolean.js';
 export { isSymbol } from './predicate/isSymbol.js';
+export { isString } from './predicate/isString.js';
 export { delay } from './promise/delay.js';
 export { withTimeout } from './promise/withTimeout.js';
 export { camelCase } from './string/camelCase.js';

package/dist/index.js

@@ -2,15 +2,15 @@
 
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
-const initial = require('./_chunk/initial-CBsbzo.js');
+const initial = require('./_chunk/initial-y0QrPY.js');
 const array_index = require('./array/index.js');
 const promise_index = require('./_chunk/index-CwRt_M.js');
 const function_index = require('./function/index.js');
 const math_index = require('./math/index.js');
 const randomInt = require('./_chunk/randomInt-CF7bZK.js');
-const isObjectLike = require('./_chunk/isObjectLike-BeLCsr.js');
+const toMerged = require('./_chunk/toMerged-BGwYW5.js');
 const object_index = require('./object/index.js');
-const isFunction = require('./_chunk/isFunction-D0hq6d.js');
+const isFunction = require('./_chunk/isFunction-aCEz9d.js');
 const isTypedArray = require('./_chunk/isTypedArray-BBEkFl.js');
 const predicate_index = require('./predicate/index.js');
 const string_index = require('./string/index.js');
@@ -46,6 +46,7 @@ exports.partition = initial.partition;
 exports.sample = initial.sample;
 exports.sampleSize = initial.sampleSize;
 exports.shuffle = initial.shuffle;
+exports.sortBy = initial.sortBy;
 exports.tail = initial.tail;
 exports.take = initial.take;
 exports.takeRight = initial.takeRight;
@@ -77,9 +78,13 @@ exports.after = function_index.after;
 exports.ary = function_index.ary;
 exports.before = function_index.before;
 exports.debounce = function_index.debounce;
+exports.memoize = function_index.memoize;
 exports.negate = function_index.negate;
 exports.noop = function_index.noop;
 exports.once = function_index.once;
+exports.partial = function_index.partial;
+exports.partialRight = function_index.partialRight;
+exports.rest = function_index.rest;
 exports.throttle = function_index.throttle;
 exports.unary = function_index.unary;
 exports.clamp = math_index.clamp;
@@ -92,17 +97,18 @@ exports.sum = math_index.sum;
 exports.sumBy = math_index.sumBy;
 exports.random = randomInt.random;
 exports.randomInt = randomInt.randomInt;
-exports.clone = isObjectLike.clone;
-exports.cloneDeep = isObjectLike.cloneDeep;
-exports.flattenObject = isObjectLike.flattenObject;
-exports.invert = isObjectLike.invert;
-exports.mapKeys = isObjectLike.mapKeys;
-exports.mapValues = isObjectLike.mapValues;
-exports.omit = isObjectLike.omit;
-exports.omitBy = isObjectLike.omitBy;
-exports.pick = isObjectLike.pick;
-exports.pickBy = isObjectLike.pickBy;
-exports.merge = object_index.merge;
+exports.clone = toMerged.clone;
+exports.cloneDeep = toMerged.cloneDeep;
+exports.flattenObject = toMerged.flattenObject;
+exports.invert = toMerged.invert;
+exports.mapKeys = toMerged.mapKeys;
+exports.mapValues = toMerged.mapValues;
+exports.merge = toMerged.merge;
+exports.omit = toMerged.omit;
+exports.omitBy = toMerged.omitBy;
+exports.pick = toMerged.pick;
+exports.pickBy = toMerged.pickBy;
+exports.toMerged = toMerged.toMerged;
 exports.mergeWith = object_index.mergeWith;
 exports.isEqual = isFunction.isEqual;
 exports.isFunction = isFunction.isFunction;
@@ -115,6 +121,7 @@ exports.isPlainObject = isTypedArray.isPlainObject;
 exports.isPrimitive = isTypedArray.isPrimitive;
 exports.isTypedArray = isTypedArray.isTypedArray;
 exports.isBoolean = predicate_index.isBoolean;
+exports.isString = predicate_index.isString;
 exports.isSymbol = predicate_index.isSymbol;
 exports.camelCase = string_index.camelCase;
 exports.capitalize = string_index.capitalize;