es-toolkit 1.26.1 → 1.27.0-dev.874

package/dist/compat/index.mjs

@@ -1,6 +1,5 @@
 export { at } from '../array/at.mjs';
 export { countBy } from '../array/countBy.mjs';
-export { differenceBy } from '../array/differenceBy.mjs';
 export { differenceWith } from '../array/differenceWith.mjs';
 export { flatMap } from '../array/flatMap.mjs';
 export { flatMapDeep } from '../array/flatMapDeep.mjs';
@@ -9,6 +8,7 @@ export { groupBy } from '../array/groupBy.mjs';
 export { initial } from '../array/initial.mjs';
 export { intersectionWith } from '../array/intersectionWith.mjs';
 export { isSubset } from '../array/isSubset.mjs';
+export { isSubsetWith } from '../array/isSubsetWith.mjs';
 export { keyBy } from '../array/keyBy.mjs';
 export { maxBy } from '../array/maxBy.mjs';
 export { minBy } from '../array/minBy.mjs';
@@ -19,17 +19,13 @@ export { shuffle } from '../array/shuffle.mjs';
 export { takeRightWhile } from '../array/takeRightWhile.mjs';
 export { takeWhile } from '../array/takeWhile.mjs';
 export { toFilled } from '../array/toFilled.mjs';
-export { union } from '../array/union.mjs';
 export { unionBy } from '../array/unionBy.mjs';
 export { unionWith } from '../array/unionWith.mjs';
-export { uniqBy } from '../array/uniqBy.mjs';
 export { uniqWith } from '../array/uniqWith.mjs';
-export { unzip } from '../array/unzip.mjs';
 export { unzipWith } from '../array/unzipWith.mjs';
 export { xor } from '../array/xor.mjs';
 export { xorBy } from '../array/xorBy.mjs';
 export { xorWith } from '../array/xorWith.mjs';
-export { zip } from '../array/zip.mjs';
 export { zipObject } from '../array/zipObject.mjs';
 export { zipWith } from '../array/zipWith.mjs';
 export { AbortError } from '../error/AbortError.mjs';
@@ -50,10 +46,9 @@ export { medianBy } from '../math/medianBy.mjs';
 export { randomInt } from '../math/randomInt.mjs';
 export { range } from '../math/range.mjs';
 export { rangeRight } from '../math/rangeRight.mjs';
-export { sum } from '../math/sum.mjs';
-export { sumBy } from '../math/sumBy.mjs';
 export { clone } from '../object/clone.mjs';
 export { isPrimitive } from '../predicate/isPrimitive.mjs';
+export { findKey } from '../object/findKey.mjs';
 export { flattenObject } from '../object/flattenObject.mjs';
 export { invert } from '../object/invert.mjs';
 export { isObjectLike } from './predicate/isObjectLike.mjs';
@@ -74,6 +69,7 @@ export { delay } from '../promise/delay.mjs';
 export { timeout } from '../promise/timeout.mjs';
 export { withTimeout } from '../promise/withTimeout.mjs';
 export { capitalize } from '../string/capitalize.mjs';
+export { words } from '../string/words.mjs';
 export { constantCase } from '../string/constantCase.mjs';
 export { deburr } from '../string/deburr.mjs';
 export { escapeRegExp } from '../string/escapeRegExp.mjs';
@@ -87,6 +83,7 @@ export { chunk } from './array/chunk.mjs';
 export { compact } from './array/compact.mjs';
 export { concat } from './array/concat.mjs';
 export { difference } from './array/difference.mjs';
+export { differenceBy } from './array/differenceBy.mjs';
 export { drop } from './array/drop.mjs';
 export { dropRight } from './array/dropRight.mjs';
 export { dropRightWhile } from './array/dropRightWhile.mjs';
@@ -100,6 +97,7 @@ export { findLastIndex } from './array/findLastIndex.mjs';
 export { flatten } from './array/flatten.mjs';
 export { flattenDeep } from './array/flattenDeep.mjs';
 export { flattenDepth } from './array/flattenDepth.mjs';
+export { forEach as each, forEach } from './array/forEach.mjs';
 export { head as first, head } from './array/head.mjs';
 export { includes } from './array/includes.mjs';
 export { indexOf } from './array/indexOf.mjs';
@@ -116,8 +114,12 @@ export { sortBy } from './array/sortBy.mjs';
 export { tail } from './array/tail.mjs';
 export { take } from './array/take.mjs';
 export { takeRight } from './array/takeRight.mjs';
+export { union } from './array/union.mjs';
 export { uniq } from './array/uniq.mjs';
+export { uniqBy } from './array/uniqBy.mjs';
+export { unzip } from './array/unzip.mjs';
 export { without } from './array/without.mjs';
+export { zip } from './array/zip.mjs';
 export { zipObjectDeep } from './array/zipObjectDeep.mjs';
 export { ary } from './function/ary.mjs';
 export { attempt } from './function/attempt.mjs';
@@ -144,6 +146,8 @@ export { min } from './math/min.mjs';
 export { parseInt } from './math/parseInt.mjs';
 export { random } from './math/random.mjs';
 export { round } from './math/round.mjs';
+export { sum } from './math/sum.mjs';
+export { sumBy } from './math/sumBy.mjs';
 export { cloneDeep } from './object/cloneDeep.mjs';
 export { defaults } from './object/defaults.mjs';
 export { fromPairs } from './object/fromPairs.mjs';
@@ -169,6 +173,7 @@ export { isArrayLike } from './predicate/isArrayLike.mjs';
 export { isArrayLikeObject } from './predicate/isArrayLikeObject.mjs';
 export { isBoolean } from './predicate/isBoolean.mjs';
 export { isDate } from './predicate/isDate.mjs';
+export { isEmpty } from './predicate/isEmpty.mjs';
 export { isEqualWith } from './predicate/isEqualWith.mjs';
 export { isError } from './predicate/isError.mjs';
 export { isFinite } from './predicate/isFinite.mjs';
@@ -199,16 +204,18 @@ export { pad } from './string/pad.mjs';
 export { padEnd } from './string/padEnd.mjs';
 export { padStart } from './string/padStart.mjs';
 export { repeat } from './string/repeat.mjs';
+export { replace } from './string/replace.mjs';
 export { snakeCase } from './string/snakeCase.mjs';
 export { startCase } from './string/startCase.mjs';
 export { startsWith } from './string/startsWith.mjs';
-export { upperCase } from './string/upperCase.mjs';
 export { template, templateSettings } from './string/template.mjs';
 export { trim } from './string/trim.mjs';
 export { trimEnd } from './string/trimEnd.mjs';
 export { trimStart } from './string/trimStart.mjs';
+export { upperCase } from './string/upperCase.mjs';
 export { constant } from './util/constant.mjs';
 export { defaultTo } from './util/defaultTo.mjs';
+export { iteratee } from './util/iteratee.mjs';
 export { times } from './util/times.mjs';
 export { toFinite } from './util/toFinite.mjs';
 export { toInteger } from './util/toInteger.mjs';

package/dist/compat/math/sum.d.mts

@@ -0,0 +1,37 @@
+/**
+ * Computes the sum of the `number` values in `array`.
+ *
+ * @param {ArrayLike<number> | null | undefined} array - The array to iterate over.
+ * @returns {number} Returns the sum.
+ *
+ * @example
+ * sum([1, 2, 3]); // => 6
+ * sum(null); // => 0
+ * sum(undefined); // => 0
+ */
+declare function sum(array: ArrayLike<number> | null | undefined): number;
+/**
+ * Computes the sum of the `bigint` values in `array`.
+ *
+ * @param {ArrayLike<bigint>} array - The array to iterate over.
+ * @returns {bigint} Returns the sum.
+ *
+ * @example
+ * sum([1n, 2n, 3n]); // => 6n
+ */
+declare function sum(array: ArrayLike<bigint>): bigint;
+/**
+ * Computes the sum of the values in `array`.
+ *
+ * It does not coerce values to `number`.
+ *
+ * @param {ArrayLike<unknown> | null | undefined} array - The array to iterate over.
+ * @returns {unknown} Returns the sum.
+ *
+ * @example
+ * sum(["1", "2"]); // => "12"
+ * sum([1, undefined, 2]); // => 3
+ */
+declare function sum(array: ArrayLike<unknown> | null | undefined): unknown;
+
+export { sum };

package/dist/compat/math/sum.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Computes the sum of the `number` values in `array`.
+ *
+ * @param {ArrayLike<number> | null | undefined} array - The array to iterate over.
+ * @returns {number} Returns the sum.
+ *
+ * @example
+ * sum([1, 2, 3]); // => 6
+ * sum(null); // => 0
+ * sum(undefined); // => 0
+ */
+declare function sum(array: ArrayLike<number> | null | undefined): number;
+/**
+ * Computes the sum of the `bigint` values in `array`.
+ *
+ * @param {ArrayLike<bigint>} array - The array to iterate over.
+ * @returns {bigint} Returns the sum.
+ *
+ * @example
+ * sum([1n, 2n, 3n]); // => 6n
+ */
+declare function sum(array: ArrayLike<bigint>): bigint;
+/**
+ * Computes the sum of the values in `array`.
+ *
+ * It does not coerce values to `number`.
+ *
+ * @param {ArrayLike<unknown> | null | undefined} array - The array to iterate over.
+ * @returns {unknown} Returns the sum.
+ *
+ * @example
+ * sum(["1", "2"]); // => "12"
+ * sum([1, undefined, 2]); // => 3
+ */
+declare function sum(array: ArrayLike<unknown> | null | undefined): unknown;
+
+export { sum };

package/dist/compat/math/sum.mjs

@@ -0,0 +1,7 @@
+import { sumBy } from './sumBy.mjs';
+
+function sum(array) {
+    return sumBy(array);
+}
+
+export { sum };

package/dist/compat/math/sumBy.d.mts

@@ -0,0 +1,64 @@
+/**
+ * Computes the sum of the `number` values in `array`.
+ *
+ * @param {ArrayLike<number> | null | undefined} array - The array to iterate over.
+ * @returns {number} Returns the sum.
+ *
+ * @example
+ * sumBy([1, 2, 3]); // => 6
+ * sumBy(null); // => 0
+ * sumBy(undefined); // => 0
+ */
+declare function sumBy(array: ArrayLike<number> | null | undefined): number;
+/**
+ * Computes the sum of the `bigint` values in `array`.
+ *
+ * @param {ArrayLike<bigint>} array - The array to iterate over.
+ * @returns {bigint} Returns the sum.
+ *
+ * @example
+ * sumBy([1n, 2n, 3n]); // => 6n
+ */
+declare function sumBy(array: ArrayLike<bigint>): bigint;
+/**
+ * Computes the sum of the values in `array`.
+ *
+ * It does not coerce values to `number`.
+ *
+ * @param {ArrayLike<unknown> | null | undefined} array - The array to iterate over.
+ * @returns {unknown} Returns the sum.
+ *
+ * @example
+ * sumBy(["1", "2"]); // => "12"
+ * sumBy([1, undefined, 2]); // => 3
+ */
+declare function sumBy(array: ArrayLike<unknown> | null | undefined): unknown;
+/**
+ * Compmutes the sum of the `number` values that are returned by the `iteratee` function.
+ *
+ * @template T - The type of the array elements.
+ * @param {ArrayLike<T>} array - The array to iterate over.
+ * @param {(value: T) => number} iteratee - The function invoked per iteration.
+ * @returns {number} Returns the sum.
+ *
+ * @example
+ * sumBy([{ a: 1 }, { a: 2 }, { a: 3 }], object => object.a); // => 6
+ */
+declare function sumBy<T>(array: ArrayLike<T>, iteratee: (value: T) => number): number;
+/**
+ * Compmutes the sum of the `bigint` values that are returned by the `iteratee` function.
+ *
+ * NOTE: If the `array` is empty, the function returns `0`.
+ *
+ * @template T - The type of the array elements.
+ * @param {ArrayLike<T>} array - The array to iterate over.
+ * @param {(value: T) => bigint} iteratee - The function invoked per iteration.
+ * @returns {bigint | number} Returns the sum.
+ *
+ * @example
+ * sumBy([{ a: 1n }, { a: 2n }, { a: 3n }], object => object.a); // => 6n
+ * sumBy([], (item: { a: bigint }) => item.a); // => 0
+ */
+declare function sumBy<T>(array: ArrayLike<T>, iteratee: (value: T) => bigint): bigint | number;
+
+export { sumBy };

package/dist/compat/math/sumBy.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Computes the sum of the `number` values in `array`.
+ *
+ * @param {ArrayLike<number> | null | undefined} array - The array to iterate over.
+ * @returns {number} Returns the sum.
+ *
+ * @example
+ * sumBy([1, 2, 3]); // => 6
+ * sumBy(null); // => 0
+ * sumBy(undefined); // => 0
+ */
+declare function sumBy(array: ArrayLike<number> | null | undefined): number;
+/**
+ * Computes the sum of the `bigint` values in `array`.
+ *
+ * @param {ArrayLike<bigint>} array - The array to iterate over.
+ * @returns {bigint} Returns the sum.
+ *
+ * @example
+ * sumBy([1n, 2n, 3n]); // => 6n
+ */
+declare function sumBy(array: ArrayLike<bigint>): bigint;
+/**
+ * Computes the sum of the values in `array`.
+ *
+ * It does not coerce values to `number`.
+ *
+ * @param {ArrayLike<unknown> | null | undefined} array - The array to iterate over.
+ * @returns {unknown} Returns the sum.
+ *
+ * @example
+ * sumBy(["1", "2"]); // => "12"
+ * sumBy([1, undefined, 2]); // => 3
+ */
+declare function sumBy(array: ArrayLike<unknown> | null | undefined): unknown;
+/**
+ * Compmutes the sum of the `number` values that are returned by the `iteratee` function.
+ *
+ * @template T - The type of the array elements.
+ * @param {ArrayLike<T>} array - The array to iterate over.
+ * @param {(value: T) => number} iteratee - The function invoked per iteration.
+ * @returns {number} Returns the sum.
+ *
+ * @example
+ * sumBy([{ a: 1 }, { a: 2 }, { a: 3 }], object => object.a); // => 6
+ */
+declare function sumBy<T>(array: ArrayLike<T>, iteratee: (value: T) => number): number;
+/**
+ * Compmutes the sum of the `bigint` values that are returned by the `iteratee` function.
+ *
+ * NOTE: If the `array` is empty, the function returns `0`.
+ *
+ * @template T - The type of the array elements.
+ * @param {ArrayLike<T>} array - The array to iterate over.
+ * @param {(value: T) => bigint} iteratee - The function invoked per iteration.
+ * @returns {bigint | number} Returns the sum.
+ *
+ * @example
+ * sumBy([{ a: 1n }, { a: 2n }, { a: 3n }], object => object.a); // => 6n
+ * sumBy([], (item: { a: bigint }) => item.a); // => 0
+ */
+declare function sumBy<T>(array: ArrayLike<T>, iteratee: (value: T) => bigint): bigint | number;
+
+export { sumBy };

package/dist/compat/math/sumBy.mjs

@@ -0,0 +1,20 @@
+import { iteratee } from '../util/iteratee.mjs';
+
+function sumBy(array, iteratee$1) {
+    if (!array || !array.length) {
+        return 0;
+    }
+    if (iteratee$1 != null) {
+        iteratee$1 = iteratee(iteratee$1);
+    }
+    let result = iteratee$1 ? iteratee$1(array[0]) : array[0];
+    for (let i = 1; i < array.length; i++) {
+        const current = iteratee$1 ? iteratee$1(array[i]) : array[i];
+        if (current !== undefined) {
+            result += current;
+        }
+    }
+    return result;
+}
+
+export { sumBy };

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

@@ -0,0 +1,78 @@
+/**
+ * Checks if a given value is empty.
+ *
+ * @returns {true} Always returns true when no arguments are provided.
+ *
+ * @example
+ * isEmpty(); // true
+ */
+declare function isEmpty(): true;
+/**
+ * Checks if a given string is empty.
+ *
+ * @param {string} value - The string to check.
+ * @returns {boolean} `true` if the string is empty, `false` otherwise.
+ *
+ * @example
+ * isEmpty(""); // true
+ * isEmpty("hello"); // false
+ */
+declare function isEmpty(value: string): value is '';
+/**
+ * Checks if a given Map is empty.
+ *
+ * @param {Map<any, any>} value - The Map to check.
+ * @returns {boolean} `true` if the Map is empty, `false` otherwise.
+ *
+ * @example
+ * isEmpty(new Map()); // true
+ * isEmpty(new Map([["key", "value"]])); // false
+ */
+declare function isEmpty(value: Map<any, any>): boolean;
+/**
+ * Checks if a given Set is empty.
+ *
+ * @param {Set<any>} value - The Set to check.
+ * @returns {boolean} `true` if the Set is empty, `false` otherwise.
+ *
+ * @example
+ * isEmpty(new Set()); // true
+ * isEmpty(new Set([1, 2, 3])); // false
+ */
+declare function isEmpty(value: Set<any>): boolean;
+/**
+ * Checks if a given array is empty.
+ *
+ * @param {any[]} value - The array to check.
+ * @returns {boolean} `true` if the array is empty, `false` otherwise.
+ *
+ * @example
+ * isEmpty([]); // true
+ * isEmpty([1, 2, 3]); // false
+ */
+declare function isEmpty(value: any[]): value is [];
+/**
+ * Checks if a given object is empty.
+ *
+ * @param {T | null | undefined} value - The object to check.
+ * @returns {boolean} `true` if the object is empty, `false` otherwise.
+ *
+ * @example
+ * isEmpty({}); // true
+ * isEmpty({ a: 1 }); // false
+ */
+declare function isEmpty<T extends Record<any, any>>(value: T | null | undefined): value is Record<keyof T, never> | null | undefined;
+/**
+ * Checks if a given value is empty.
+ *
+ * @param {unknown} value - The value to check.
+ * @returns {boolean} `true` if the value is empty, `false` otherwise.
+ *
+ * @example
+ * isEmpty(null); // true
+ * isEmpty(undefined); // true
+ * isEmpty(42); // true
+ */
+declare function isEmpty(value: unknown): boolean;
+
+export { isEmpty };

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

@@ -0,0 +1,78 @@
+/**
+ * Checks if a given value is empty.
+ *
+ * @returns {true} Always returns true when no arguments are provided.
+ *
+ * @example
+ * isEmpty(); // true
+ */
+declare function isEmpty(): true;
+/**
+ * Checks if a given string is empty.
+ *
+ * @param {string} value - The string to check.
+ * @returns {boolean} `true` if the string is empty, `false` otherwise.
+ *
+ * @example
+ * isEmpty(""); // true
+ * isEmpty("hello"); // false
+ */
+declare function isEmpty(value: string): value is '';
+/**
+ * Checks if a given Map is empty.
+ *
+ * @param {Map<any, any>} value - The Map to check.
+ * @returns {boolean} `true` if the Map is empty, `false` otherwise.
+ *
+ * @example
+ * isEmpty(new Map()); // true
+ * isEmpty(new Map([["key", "value"]])); // false
+ */
+declare function isEmpty(value: Map<any, any>): boolean;
+/**
+ * Checks if a given Set is empty.
+ *
+ * @param {Set<any>} value - The Set to check.
+ * @returns {boolean} `true` if the Set is empty, `false` otherwise.
+ *
+ * @example
+ * isEmpty(new Set()); // true
+ * isEmpty(new Set([1, 2, 3])); // false
+ */
+declare function isEmpty(value: Set<any>): boolean;
+/**
+ * Checks if a given array is empty.
+ *
+ * @param {any[]} value - The array to check.
+ * @returns {boolean} `true` if the array is empty, `false` otherwise.
+ *
+ * @example
+ * isEmpty([]); // true
+ * isEmpty([1, 2, 3]); // false
+ */
+declare function isEmpty(value: any[]): value is [];
+/**
+ * Checks if a given object is empty.
+ *
+ * @param {T | null | undefined} value - The object to check.
+ * @returns {boolean} `true` if the object is empty, `false` otherwise.
+ *
+ * @example
+ * isEmpty({}); // true
+ * isEmpty({ a: 1 }); // false
+ */
+declare function isEmpty<T extends Record<any, any>>(value: T | null | undefined): value is Record<keyof T, never> | null | undefined;
+/**
+ * Checks if a given value is empty.
+ *
+ * @param {unknown} value - The value to check.
+ * @returns {boolean} `true` if the value is empty, `false` otherwise.
+ *
+ * @example
+ * isEmpty(null); // true
+ * isEmpty(undefined); // true
+ * isEmpty(42); // true
+ */
+declare function isEmpty(value: unknown): boolean;
+
+export { isEmpty };

package/dist/compat/predicate/isEmpty.mjs

@@ -0,0 +1,33 @@
+import { isArguments } from './isArguments.mjs';
+import { isArrayLike } from './isArrayLike.mjs';
+import { isTypedArray } from './isTypedArray.mjs';
+import { isPrototype } from '../_internal/isPrototype.mjs';
+
+function isEmpty(value) {
+    if (value == null) {
+        return true;
+    }
+    if (isArrayLike(value)) {
+        if (typeof value.splice !== 'function' &&
+            typeof value !== 'string' &&
+            (typeof Buffer === 'undefined' || !Buffer.isBuffer(value)) &&
+            !isTypedArray(value) &&
+            !isArguments(value)) {
+            return false;
+        }
+        return value.length === 0;
+    }
+    if (typeof value === 'object') {
+        if (value instanceof Map || value instanceof Set) {
+            return value.size === 0;
+        }
+        const keys = Object.keys(value);
+        if (isPrototype(value)) {
+            return keys.filter(x => x !== 'constructor').length === 0;
+        }
+        return keys.length === 0;
+    }
+    return true;
+}
+
+export { isEmpty };

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

@@ -0,0 +1,17 @@
+/**
+ * Replaces the matched pattern with the replacement string.
+ *
+ * @param {string} target - The target string.
+ * @param {string | RegExp} pattern - The pattern to match.
+ * @param {string | ((substring: string, ...args: any[]) => string)} replacement - The replacement string or a function that returns the replacement string.
+ * @returns {string} The new string with the matched pattern replaced.
+ *
+ * @example
+ * replace('abcde', 'de', '123'); // 'abc123'
+ * replace('abcde', /[bd]/g, '-'); // 'a-c-e'
+ * replace('abcde', 'de', substring => substring.toUpperCase()); // 'abcDE'
+ * replace('abcde', /[bd]/g, substring => substring.toUpperCase()); // 'aBcDe'
+ */
+declare function replace(target: string | undefined, pattern: string | RegExp, replacement: string | ((substring: string, ...args: any[]) => string)): string;
+
+export { replace };

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

@@ -0,0 +1,17 @@
+/**
+ * Replaces the matched pattern with the replacement string.
+ *
+ * @param {string} target - The target string.
+ * @param {string | RegExp} pattern - The pattern to match.
+ * @param {string | ((substring: string, ...args: any[]) => string)} replacement - The replacement string or a function that returns the replacement string.
+ * @returns {string} The new string with the matched pattern replaced.
+ *
+ * @example
+ * replace('abcde', 'de', '123'); // 'abc123'
+ * replace('abcde', /[bd]/g, '-'); // 'a-c-e'
+ * replace('abcde', 'de', substring => substring.toUpperCase()); // 'abcDE'
+ * replace('abcde', /[bd]/g, substring => substring.toUpperCase()); // 'aBcDe'
+ */
+declare function replace(target: string | undefined, pattern: string | RegExp, replacement: string | ((substring: string, ...args: any[]) => string)): string;
+
+export { replace };

package/dist/compat/string/replace.mjs

@@ -0,0 +1,10 @@
+import { toString } from '../util/toString.mjs';
+
+function replace(target = '', pattern, replacement) {
+    if (arguments.length < 3) {
+        return toString(target);
+    }
+    return toString(target).replace(pattern, replacement);
+}
+
+export { replace };

package/dist/compat/string/startCase.mjs

@@ -1,11 +1,11 @@
-import { getWords } from '../../string/_internal/getWords.mjs';
+import { words } from '../../string/words.mjs';
 import { normalizeForCase } from '../_internal/normalizeForCase.mjs';
 
 function startCase(str) {
-    const words = getWords(normalizeForCase(str).trim());
+    const words$1 = words(normalizeForCase(str).trim());
     let result = '';
-    for (let i = 0; i < words.length; i++) {
-        const word = words[i];
+    for (let i = 0; i < words$1.length; i++) {
+        const word = words$1[i];
         if (result) {
             result += ' ';
         }

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

@@ -0,0 +1,44 @@
+/**
+ * Returns a `identity` function when `value` is `null` or `undefined`.
+ *
+ * @param {null} [value] - The value to convert to an iteratee.
+ * @returns {<T>(value: T) => T} - Returns a `identity` function.
+ *
+ * @example
+ * const func = iteratee();
+ * [{ a: 1 }, { a: 2 }, { a: 3 }].map(func) // => [{ a: 1 }, { a: 2 }, { a: 3 }]
+ */
+declare function iteratee(value?: null): <T>(value: T) => T;
+/**
+ * Returns a given `func` function when `value` is a `function`.
+ *
+ * @template {(...args: any[]) => unknown} F - The function type.
+ * @param {F} func - The function to return.
+ * @returns {F} - Returns the given function.
+ *
+ * @example
+ * const func = iteratee((object) => object.a);
+ * [{ a: 1 }, { a: 2 }, { a: 3 }].map(func) // => [1, 2, 3]
+ */
+declare function iteratee<F extends (...args: any[]) => unknown>(func: F): F;
+/**
+ * Creates a function that invokes `value` with the arguments of the created function.
+ *
+ * The created function returns the property value for a given element.
+ *
+ * @param {symbol | number | string | object} value - The value to convert to an iteratee.
+ * @returns {(...args: any[]) => any} - Returns the new iteratee function.
+ *
+ * @example
+ * const func = iteratee('a');
+ * [{ a: 1 }, { a: 2 }, { a: 3 }].map(func) // => [1, 2, 3]
+ *
+ * const func = iteratee({ a: 1 });
+ * [{ a: 1 }, { a: 2 }, { a: 3 }].find(func) // => { a: 1 }
+ *
+ * const func = iteratee(['a', 1]);
+ * [{ a: 1 }, { a: 2 }, { a: 3 }].find(func) // => { a: 1 }
+ */
+declare function iteratee(value: symbol | number | string | object): (...args: any[]) => any;
+
+export { iteratee };