es-toolkit 1.33.0 → 1.34.0

package/dist/compat/_internal/assignValue.mjs

@@ -0,0 +1,10 @@
+import { eq } from '../util/eq.mjs';
+
+const assignValue = (object, key, value) => {
+    const objValue = object[key];
+    if (!(Object.hasOwn(object, key) && eq(objValue, value)) || (value === undefined && !(key in object))) {
+        object[key] = value;
+    }
+};
+
+export { assignValue };

package/dist/compat/_internal/isKey.mjs

@@ -10,7 +10,7 @@ function isKey(value, object) {
         return true;
     }
     return ((typeof value === 'string' && (regexIsPlainProp.test(value) || !regexIsDeepProp.test(value))) ||
-        (object != null));
+        (object != null && Object.hasOwn(object, value)));
 }
 
 export { isKey };

package/dist/compat/_internal/toKey.mjs

@@ -1,5 +1,8 @@
 function toKey(value) {
-    if (Object.is(value, -0)) {
+    if (typeof value === 'string' || typeof value === 'symbol') {
+        return value;
+    }
+    if (Object.is(value.valueOf(), -0)) {
         return '-0';
     }
     return value.toString();

package/dist/compat/array/filter.mjs

@@ -1,44 +1,27 @@
-import { identity } from '../../function/identity.mjs';
-import { property } from '../object/property.mjs';
 import { isArray } from '../predicate/isArray.mjs';
-import { matches } from '../predicate/matches.mjs';
-import { matchesProperty } from '../predicate/matchesProperty.mjs';
+import { isArrayLike } from '../predicate/isArrayLike.mjs';
+import { iteratee } from '../util/iteratee.mjs';
 
 function filter(source, predicate) {
     if (!source) {
         return [];
     }
-    if (!predicate) {
-        predicate = identity;
-    }
     const collection = isArray(source) ? source : Object.values(source);
-    switch (typeof predicate) {
-        case 'function': {
-            if (!Array.isArray(source)) {
-                const result = [];
-                const keys = Object.keys(source);
-                for (let i = 0; i < keys.length; i++) {
-                    const key = keys[i];
-                    const value = source[key];
-                    if (predicate(value, key, source)) {
-                        result.push(value);
-                    }
-                }
-                return result;
+    predicate = iteratee(predicate);
+    if (!Array.isArray(source)) {
+        const result = [];
+        const keys = Object.keys(source);
+        const length = isArrayLike(source) ? source.length : keys.length;
+        for (let i = 0; i < length; i++) {
+            const key = keys[i];
+            const value = source[key];
+            if (predicate(value, key, source)) {
+                result.push(value);
             }
-            return collection.filter(predicate);
-        }
-        case 'object': {
-            return isArray(predicate)
-                ? collection.filter(matchesProperty(predicate[0], predicate[1]))
-                : collection.filter(matches(predicate));
-        }
-        case 'symbol':
-        case 'number':
-        case 'string': {
-            return collection.filter(property(predicate));
         }
+        return result;
     }
+    return collection.filter(predicate);
 }
 
 export { filter };

package/dist/compat/array/intersectionWith.mjs

@@ -4,7 +4,6 @@ import { uniq } from './uniq.mjs';
 import { eq } from '../util/eq.mjs';
 
 function intersectionWith(firstArr, ...otherArrs) {
-    console.log(firstArr);
     if (firstArr == null) {
         return [];
     }

package/dist/compat/array/map.d.mts

@@ -117,7 +117,7 @@ declare function map<T, K extends keyof T>(collection: ArrayLike<T>, iteratee: K
  * const arrayLike = {0: 1, 1: 2, 2: 3, length: 3};
  * map(arrayLike); // => {0: 1, 1: 2, 2: 3, length: 3}
  */
-declare function map<T, U>(collection: ArrayLike<T>, iteratee?: null | undefined): ArrayLike<T>;
+declare function map<T>(collection: ArrayLike<T>, iteratee?: null | undefined): ArrayLike<T>;
 /**
  * Maps each value in an object to a new array of values using an iteratee function.
  *

package/dist/compat/array/map.d.ts

@@ -117,7 +117,7 @@ declare function map<T, K extends keyof T>(collection: ArrayLike<T>, iteratee: K
  * const arrayLike = {0: 1, 1: 2, 2: 3, length: 3};
  * map(arrayLike); // => {0: 1, 1: 2, 2: 3, length: 3}
  */
-declare function map<T, U>(collection: ArrayLike<T>, iteratee?: null | undefined): ArrayLike<T>;
+declare function map<T>(collection: ArrayLike<T>, iteratee?: null | undefined): ArrayLike<T>;
 /**
  * Maps each value in an object to a new array of values using an iteratee function.
  *

package/dist/compat/array/reject.d.mts

@@ -0,0 +1,117 @@
+/**
+ * Rejects items from a array and returns an array of elements.
+ *
+ * @template T
+ * @param {ArrayLike<T> | null | undefined} arr - The array to iterate over.
+ * @param {(item: T, index: number, arr: T[]) => unknown} doesMatch - The function invoked per iteration.
+ * @returns {T[]} - Returns a new array of elements that do not satisfy the given doesMatch function.
+ *
+ * @example
+ * reject([1, 2, 3], n => n % 2 === 0)
+ * // => [1, 3]
+ */
+declare function reject<T>(arr: ArrayLike<T> | null | undefined, doesMatch?: (item: T, index: number, arr: readonly T[]) => unknown): T[];
+/**
+ * Rejects elements in a arr that match the properties of the given partial object.
+ *
+ * @template T
+ * @param {ArrayLike<T> | null | undefined} arr - The array to iterate over.
+ * @param {Partial<T>} doesMatch - A partial object that specifies the properties to match.
+ * @returns {T[]} - Returns a new array of elements that do not match the given properties.
+ *
+ * @example
+ * const arr = [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }];
+ * reject(arr, { name: 'Bob' });
+ * // => [{ id: 1, name: 'Alice' }]
+ */
+declare function reject<T>(arr: ArrayLike<T> | null | undefined, doesMatch: Partial<T>): T[];
+/**
+ * Rejects elements in a arr that match the given key-value pair.
+ *
+ * @template T
+ * @param {ArrayLike<T> | null | undefined} arr - The array to iterate over.
+ * @param {[keyof T, unknown]} doesMatchProperty - The key-value pair to match.
+ * @returns {T[]} - Returns a new array of elements that do not match the given key-value pair.
+ *
+ * @example
+ * const arr = [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }];
+ * reject(arr, ['name', 'Alice']);
+ * // => [{ id: 2, name: 'Bob' }]
+ */
+declare function reject<T>(arr: ArrayLike<T> | null | undefined, doesMatchProperty: [keyof T, unknown]): T[];
+/**
+ * Rejects the arr, returning elements that do not contain the given property name.
+ *
+ * @template T
+ * @param {ArrayLike<T> | null | undefined} arr - The array to iterate over.
+ * @param {PropertyKey} propertyToCheck - The property name to check.
+ * @returns {T[]} - Returns a new array of elements that do not have the given property name.
+ *
+ * @example
+ * const arr = [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }, { id: 3, age: 28 }];
+ * reject(arr, 'name');
+ * // => [{ id: 3, age: 28 }]
+ */
+declare function reject<T>(arr: ArrayLike<T> | null | undefined, propertyToCheck: PropertyKey): T[];
+/**
+ * Rejects items from a object and returns an array of elements that match the given predicate function.
+ *
+ * @template T
+ * @param {T | null | undefined} object - The object to iterate over.
+ * @param {(value: T[keyof T], key: keyof T, object: T) => unknown} doesMatch - The function invoked per iteration.
+ * @returns {T[]} - Returns a new array of elements that do not satisfy the given predicate function.
+ *
+ * @example
+ * const obj = { item1: { a: 0 }, item2: { a: 1 }, item3: { a: 0 } }
+ * reject(obj, value => value.a)
+ * // => [{ a: 0 }, { a: 0 }]
+ *
+ * const obj = { a: 1, b: 2, c: 3 };
+ * reject(obj, value => value > 2)
+ * // => [1, 2]
+ */
+declare function reject<T extends Record<string, unknown>>(object: T | null | undefined, doesMatch: (value: T[keyof T], key: keyof T, object: T) => unknown): T[];
+/**
+ * Rejects elements in a object that match the properties of the given partial object.
+ *
+ * @template T
+ * @param {T | null | undefined} object - The object to iterate over.
+ * @param {Partial<T[keyof T]>} doesMatch - The partial object to match
+ * @returns {T[]} - Returns a new array of elements that do not match the given properties.
+ *
+ * @example
+ * const obj = { a: { id: 1, name: 'Alice' }, b: { id: 2, name: 'Bob' } };
+ * reject(obj, { name: 'Bob' });
+ * // => [{ id: 1, name: 'Alice' }]
+ */
+declare function reject<T extends Record<string, unknown>>(object: T | null | undefined, doesMatch: Partial<T[keyof T]>): T[];
+/**
+ * Rejects elements in a arr that match the given key-value pair.
+ *
+ * @template T
+ * @param {T | null | undefined} object - The object to iterate over.
+ * @param {[keyof T[keyof T], unknown]} doesMatchProperty - The key-value pair to match.
+ * @returns {T[]} - Returns a new array of elements that do not match the given key-value pair.
+ *
+ * @example
+ * const obj = { alice: { id: 1, name: 'Alice' }, bob: { id: 2, name: 'Bob' } };
+ * reject(obj, ['name', 'Alice']);
+ * // => [{ id: 2, name: 'Bob' }]
+ */
+declare function reject<T extends Record<string, unknown>>(object: T | null | undefined, doesMatchProperty: [keyof T[keyof T], unknown]): T[];
+/**
+ * Rejects the object, returning elements that do not contain the given property name.
+ *
+ * @template T
+ * @param {T | null | undefined} object - The object to iterate over.
+ * @param {PropertyKey} propertyToCheck - The property name to check.
+ * @returns {T[]} - Returns a new array of elements that do not have the given property name.
+ *
+ * @example
+ * const obj = { a: { id: 1, name: 'Alice' }, b: { id: 2, name: 'Bob' }, c: { id: 3, age: 28 } };
+ * reject(obj, 'name');
+ * // => [{ id: 3, age: 28 }]
+ */
+declare function reject<T extends Record<string, unknown>>(object: T | null | undefined, propertyToCheck: PropertyKey): T[];
+
+export { reject };

package/dist/compat/array/reject.d.ts

@@ -0,0 +1,117 @@
+/**
+ * Rejects items from a array and returns an array of elements.
+ *
+ * @template T
+ * @param {ArrayLike<T> | null | undefined} arr - The array to iterate over.
+ * @param {(item: T, index: number, arr: T[]) => unknown} doesMatch - The function invoked per iteration.
+ * @returns {T[]} - Returns a new array of elements that do not satisfy the given doesMatch function.
+ *
+ * @example
+ * reject([1, 2, 3], n => n % 2 === 0)
+ * // => [1, 3]
+ */
+declare function reject<T>(arr: ArrayLike<T> | null | undefined, doesMatch?: (item: T, index: number, arr: readonly T[]) => unknown): T[];
+/**
+ * Rejects elements in a arr that match the properties of the given partial object.
+ *
+ * @template T
+ * @param {ArrayLike<T> | null | undefined} arr - The array to iterate over.
+ * @param {Partial<T>} doesMatch - A partial object that specifies the properties to match.
+ * @returns {T[]} - Returns a new array of elements that do not match the given properties.
+ *
+ * @example
+ * const arr = [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }];
+ * reject(arr, { name: 'Bob' });
+ * // => [{ id: 1, name: 'Alice' }]
+ */
+declare function reject<T>(arr: ArrayLike<T> | null | undefined, doesMatch: Partial<T>): T[];
+/**
+ * Rejects elements in a arr that match the given key-value pair.
+ *
+ * @template T
+ * @param {ArrayLike<T> | null | undefined} arr - The array to iterate over.
+ * @param {[keyof T, unknown]} doesMatchProperty - The key-value pair to match.
+ * @returns {T[]} - Returns a new array of elements that do not match the given key-value pair.
+ *
+ * @example
+ * const arr = [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }];
+ * reject(arr, ['name', 'Alice']);
+ * // => [{ id: 2, name: 'Bob' }]
+ */
+declare function reject<T>(arr: ArrayLike<T> | null | undefined, doesMatchProperty: [keyof T, unknown]): T[];
+/**
+ * Rejects the arr, returning elements that do not contain the given property name.
+ *
+ * @template T
+ * @param {ArrayLike<T> | null | undefined} arr - The array to iterate over.
+ * @param {PropertyKey} propertyToCheck - The property name to check.
+ * @returns {T[]} - Returns a new array of elements that do not have the given property name.
+ *
+ * @example
+ * const arr = [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }, { id: 3, age: 28 }];
+ * reject(arr, 'name');
+ * // => [{ id: 3, age: 28 }]
+ */
+declare function reject<T>(arr: ArrayLike<T> | null | undefined, propertyToCheck: PropertyKey): T[];
+/**
+ * Rejects items from a object and returns an array of elements that match the given predicate function.
+ *
+ * @template T
+ * @param {T | null | undefined} object - The object to iterate over.
+ * @param {(value: T[keyof T], key: keyof T, object: T) => unknown} doesMatch - The function invoked per iteration.
+ * @returns {T[]} - Returns a new array of elements that do not satisfy the given predicate function.
+ *
+ * @example
+ * const obj = { item1: { a: 0 }, item2: { a: 1 }, item3: { a: 0 } }
+ * reject(obj, value => value.a)
+ * // => [{ a: 0 }, { a: 0 }]
+ *
+ * const obj = { a: 1, b: 2, c: 3 };
+ * reject(obj, value => value > 2)
+ * // => [1, 2]
+ */
+declare function reject<T extends Record<string, unknown>>(object: T | null | undefined, doesMatch: (value: T[keyof T], key: keyof T, object: T) => unknown): T[];
+/**
+ * Rejects elements in a object that match the properties of the given partial object.
+ *
+ * @template T
+ * @param {T | null | undefined} object - The object to iterate over.
+ * @param {Partial<T[keyof T]>} doesMatch - The partial object to match
+ * @returns {T[]} - Returns a new array of elements that do not match the given properties.
+ *
+ * @example
+ * const obj = { a: { id: 1, name: 'Alice' }, b: { id: 2, name: 'Bob' } };
+ * reject(obj, { name: 'Bob' });
+ * // => [{ id: 1, name: 'Alice' }]
+ */
+declare function reject<T extends Record<string, unknown>>(object: T | null | undefined, doesMatch: Partial<T[keyof T]>): T[];
+/**
+ * Rejects elements in a arr that match the given key-value pair.
+ *
+ * @template T
+ * @param {T | null | undefined} object - The object to iterate over.
+ * @param {[keyof T[keyof T], unknown]} doesMatchProperty - The key-value pair to match.
+ * @returns {T[]} - Returns a new array of elements that do not match the given key-value pair.
+ *
+ * @example
+ * const obj = { alice: { id: 1, name: 'Alice' }, bob: { id: 2, name: 'Bob' } };
+ * reject(obj, ['name', 'Alice']);
+ * // => [{ id: 2, name: 'Bob' }]
+ */
+declare function reject<T extends Record<string, unknown>>(object: T | null | undefined, doesMatchProperty: [keyof T[keyof T], unknown]): T[];
+/**
+ * Rejects the object, returning elements that do not contain the given property name.
+ *
+ * @template T
+ * @param {T | null | undefined} object - The object to iterate over.
+ * @param {PropertyKey} propertyToCheck - The property name to check.
+ * @returns {T[]} - Returns a new array of elements that do not have the given property name.
+ *
+ * @example
+ * const obj = { a: { id: 1, name: 'Alice' }, b: { id: 2, name: 'Bob' }, c: { id: 3, age: 28 } };
+ * reject(obj, 'name');
+ * // => [{ id: 3, age: 28 }]
+ */
+declare function reject<T extends Record<string, unknown>>(object: T | null | undefined, propertyToCheck: PropertyKey): T[];
+
+export { reject };

package/dist/compat/array/reject.mjs

@@ -0,0 +1,9 @@
+import { filter } from './filter.mjs';
+import { negate } from '../function/negate.mjs';
+import { iteratee } from '../util/iteratee.mjs';
+
+function reject(source, predicate) {
+    return filter(source, negate(iteratee(predicate)));
+}
+
+export { reject };

package/dist/compat/array/sortedIndexOf.d.mts

@@ -0,0 +1,34 @@
+/**
+ * Finds the index of the first occurrence of a value in a sorted array, similar to how `Array#indexOf` works, but specifically for sorted arrays.
+ *
+ * Make sure to provide a sorted array to this function, as it uses a binary search to quickly find the index.
+ *
+ * @param {ArrayLike<T> | null | undefined} array The sorted array to inspect.
+ * @param {T} value The value to search for.
+ * @returns {number} Returns the index of the matched value, else -1.
+ *
+ * @example
+ * const numbers = [1, 2, 3, 4, 5];
+ * sortedIndexOf(numbers, 11); // Return value: 0
+ * sortedIndexOf(numbers, 30); // Return value: -1
+ *
+ * // If the value is duplicated, it returns the first index of the value.
+ * const duplicateNumbers = [1, 2, 2, 3, 3, 3, 4];
+ * sortedIndexOf(duplicateNumbers, 3); // Return value: 3
+ *
+ * // If the array is unsorted, it can return the wrong index.
+ * const unSortedArray = [55, 33, 22, 11, 44];
+ * sortedIndexOf(unSortedArray, 11); // Return value: -1
+ *
+ * // -0 and 0 are treated the same
+ * const mixedZeroArray = [-0, 0];
+ * sortedIndexOf(mixedZeroArray, 0); // Return value: 0
+ * sortedIndexOf(mixedZeroArray, -0); // Return value: 0
+ *
+ * // It works with array-like objects
+ * const arrayLike = { length: 3, 0: 10, 1: 20, 2: 30 };
+ * sortedIndexOf(arrayLike, 20); // Return value: 1
+ */
+declare function sortedIndexOf<T>(array: ArrayLike<T> | null | undefined, value: T): number;
+
+export { sortedIndexOf };

package/dist/compat/array/sortedIndexOf.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Finds the index of the first occurrence of a value in a sorted array, similar to how `Array#indexOf` works, but specifically for sorted arrays.
+ *
+ * Make sure to provide a sorted array to this function, as it uses a binary search to quickly find the index.
+ *
+ * @param {ArrayLike<T> | null | undefined} array The sorted array to inspect.
+ * @param {T} value The value to search for.
+ * @returns {number} Returns the index of the matched value, else -1.
+ *
+ * @example
+ * const numbers = [1, 2, 3, 4, 5];
+ * sortedIndexOf(numbers, 11); // Return value: 0
+ * sortedIndexOf(numbers, 30); // Return value: -1
+ *
+ * // If the value is duplicated, it returns the first index of the value.
+ * const duplicateNumbers = [1, 2, 2, 3, 3, 3, 4];
+ * sortedIndexOf(duplicateNumbers, 3); // Return value: 3
+ *
+ * // If the array is unsorted, it can return the wrong index.
+ * const unSortedArray = [55, 33, 22, 11, 44];
+ * sortedIndexOf(unSortedArray, 11); // Return value: -1
+ *
+ * // -0 and 0 are treated the same
+ * const mixedZeroArray = [-0, 0];
+ * sortedIndexOf(mixedZeroArray, 0); // Return value: 0
+ * sortedIndexOf(mixedZeroArray, -0); // Return value: 0
+ *
+ * // It works with array-like objects
+ * const arrayLike = { length: 3, 0: 10, 1: 20, 2: 30 };
+ * sortedIndexOf(arrayLike, 20); // Return value: 1
+ */
+declare function sortedIndexOf<T>(array: ArrayLike<T> | null | undefined, value: T): number;
+
+export { sortedIndexOf };

package/dist/compat/array/sortedIndexOf.mjs

@@ -0,0 +1,15 @@
+import { sortedIndex } from './sortedIndex.mjs';
+import { eq } from '../util/eq.mjs';
+
+function sortedIndexOf(array, value) {
+    if (!array?.length) {
+        return -1;
+    }
+    const index = sortedIndex(array, value);
+    if (index < array.length && eq(array[index], value)) {
+        return index;
+    }
+    return -1;
+}
+
+export { sortedIndexOf };

package/dist/compat/index.d.mts

@@ -8,7 +8,6 @@ export { initial } from '../array/initial.mjs';
 export { isSubset } from '../array/isSubset.mjs';
 export { isSubsetWith } from '../array/isSubsetWith.mjs';
 export { keyBy } from '../array/keyBy.mjs';
-export { minBy } from '../array/minBy.mjs';
 export { partition } from '../array/partition.mjs';
 export { pullAt } from '../array/pullAt.mjs';
 export { sampleSize } from '../array/sampleSize.mjs';
@@ -37,8 +36,6 @@ export { partialRight } from '../function/partialRight.mjs';
 export { retry } from '../function/retry.mjs';
 export { ThrottledFunction } from '../function/throttle.mjs';
 export { unary } from '../function/unary.mjs';
-export { mean } from '../math/mean.mjs';
-export { meanBy } from '../math/meanBy.mjs';
 export { median } from '../math/median.mjs';
 export { medianBy } from '../math/medianBy.mjs';
 export { randomInt } from '../math/randomInt.mjs';
@@ -48,12 +45,14 @@ export { invert } from '../object/invert.mjs';
 export { omitBy } from '../object/omitBy.mjs';
 export { toMerged } from '../object/toMerged.mjs';
 export { isBlob } from '../predicate/isBlob.mjs';
+export { isBrowser } from '../predicate/isBrowser.mjs';
 export { isEqual } from '../predicate/isEqual.mjs';
 export { isFile } from '../predicate/isFile.mjs';
 export { isFunction } from '../predicate/isFunction.mjs';
 export { isJSON } from '../predicate/isJSON.mjs';
 export { isJSONArray, isJSONObject, isJSONValue } from '../predicate/isJSONValue.mjs';
 export { isLength } from '../predicate/isLength.mjs';
+export { isNode } from '../predicate/isNode.mjs';
 export { isNotNil } from '../predicate/isNotNil.mjs';
 export { isNull } from '../predicate/isNull.mjs';
 export { isPrimitive } from '../predicate/isPrimitive.mjs';
@@ -67,6 +66,7 @@ export { capitalize } from '../string/capitalize.mjs';
 export { constantCase } from '../string/constantCase.mjs';
 export { pascalCase } from '../string/pascalCase.mjs';
 export { reverseString } from '../string/reverseString.mjs';
+export { attemptAsync } from '../util/attemptAsync.mjs';
 export { invariant } from '../util/invariant.mjs';
 export { castArray } from './array/castArray.mjs';
 export { chunk } from './array/chunk.mjs';
@@ -107,6 +107,7 @@ export { pullAll } from './array/pullAll.mjs';
 export { pullAllBy } from './array/pullAllBy.mjs';
 export { reduce } from './array/reduce.mjs';
 export { reduceRight } from './array/reduceRight.mjs';
+export { reject } from './array/reject.mjs';
 export { remove } from './array/remove.mjs';
 export { reverse } from './array/reverse.mjs';
 export { sample } from './array/sample.mjs';
@@ -116,6 +117,7 @@ export { some } from './array/some.mjs';
 export { sortBy } from './array/sortBy.mjs';
 export { sortedIndex } from './array/sortedIndex.mjs';
 export { sortedIndexBy } from './array/sortedIndexBy.mjs';
+export { sortedIndexOf } from './array/sortedIndexOf.mjs';
 export { tail } from './array/tail.mjs';
 export { take } from './array/take.mjs';
 export { takeRight } from './array/takeRight.mjs';
@@ -155,7 +157,10 @@ export { floor } from './math/floor.mjs';
 export { inRange } from './math/inRange.mjs';
 export { max } from './math/max.mjs';
 export { maxBy } from './math/maxBy.mjs';
+export { mean } from './math/mean.mjs';
+export { meanBy } from './math/meanBy.mjs';
 export { min } from './math/min.mjs';
+export { minBy } from './math/minBy.mjs';
 export { multiply } from './math/multiply.mjs';
 export { parseInt } from './math/parseInt.mjs';
 export { random } from './math/random.mjs';
@@ -171,6 +176,7 @@ export { cloneDeepWith } from './object/cloneDeepWith.mjs';
 export { defaults } from './object/defaults.mjs';
 export { findKey } from './object/findKey.mjs';
 export { fromPairs } from './object/fromPairs.mjs';
+export { functionsIn } from './object/functionsIn.mjs';
 export { get } from './object/get.mjs';
 export { has } from './object/has.mjs';
 export { invertBy } from './object/invertBy.mjs';

package/dist/compat/index.d.ts

@@ -8,7 +8,6 @@ export { initial } from '../array/initial.js';
 export { isSubset } from '../array/isSubset.js';
 export { isSubsetWith } from '../array/isSubsetWith.js';
 export { keyBy } from '../array/keyBy.js';
-export { minBy } from '../array/minBy.js';
 export { partition } from '../array/partition.js';
 export { pullAt } from '../array/pullAt.js';
 export { sampleSize } from '../array/sampleSize.js';
@@ -37,8 +36,6 @@ export { partialRight } from '../function/partialRight.js';
 export { retry } from '../function/retry.js';
 export { ThrottledFunction } from '../function/throttle.js';
 export { unary } from '../function/unary.js';
-export { mean } from '../math/mean.js';
-export { meanBy } from '../math/meanBy.js';
 export { median } from '../math/median.js';
 export { medianBy } from '../math/medianBy.js';
 export { randomInt } from '../math/randomInt.js';
@@ -48,12 +45,14 @@ export { invert } from '../object/invert.js';
 export { omitBy } from '../object/omitBy.js';
 export { toMerged } from '../object/toMerged.js';
 export { isBlob } from '../predicate/isBlob.js';
+export { isBrowser } from '../predicate/isBrowser.js';
 export { isEqual } from '../predicate/isEqual.js';
 export { isFile } from '../predicate/isFile.js';
 export { isFunction } from '../predicate/isFunction.js';
 export { isJSON } from '../predicate/isJSON.js';
 export { isJSONArray, isJSONObject, isJSONValue } from '../predicate/isJSONValue.js';
 export { isLength } from '../predicate/isLength.js';
+export { isNode } from '../predicate/isNode.js';
 export { isNotNil } from '../predicate/isNotNil.js';
 export { isNull } from '../predicate/isNull.js';
 export { isPrimitive } from '../predicate/isPrimitive.js';
@@ -67,6 +66,7 @@ export { capitalize } from '../string/capitalize.js';
 export { constantCase } from '../string/constantCase.js';
 export { pascalCase } from '../string/pascalCase.js';
 export { reverseString } from '../string/reverseString.js';
+export { attemptAsync } from '../util/attemptAsync.js';
 export { invariant } from '../util/invariant.js';
 export { castArray } from './array/castArray.js';
 export { chunk } from './array/chunk.js';
@@ -107,6 +107,7 @@ export { pullAll } from './array/pullAll.js';
 export { pullAllBy } from './array/pullAllBy.js';
 export { reduce } from './array/reduce.js';
 export { reduceRight } from './array/reduceRight.js';
+export { reject } from './array/reject.js';
 export { remove } from './array/remove.js';
 export { reverse } from './array/reverse.js';
 export { sample } from './array/sample.js';
@@ -116,6 +117,7 @@ export { some } from './array/some.js';
 export { sortBy } from './array/sortBy.js';
 export { sortedIndex } from './array/sortedIndex.js';
 export { sortedIndexBy } from './array/sortedIndexBy.js';
+export { sortedIndexOf } from './array/sortedIndexOf.js';
 export { tail } from './array/tail.js';
 export { take } from './array/take.js';
 export { takeRight } from './array/takeRight.js';
@@ -155,7 +157,10 @@ export { floor } from './math/floor.js';
 export { inRange } from './math/inRange.js';
 export { max } from './math/max.js';
 export { maxBy } from './math/maxBy.js';
+export { mean } from './math/mean.js';
+export { meanBy } from './math/meanBy.js';
 export { min } from './math/min.js';
+export { minBy } from './math/minBy.js';
 export { multiply } from './math/multiply.js';
 export { parseInt } from './math/parseInt.js';
 export { random } from './math/random.js';
@@ -171,6 +176,7 @@ export { cloneDeepWith } from './object/cloneDeepWith.js';
 export { defaults } from './object/defaults.js';
 export { findKey } from './object/findKey.js';
 export { fromPairs } from './object/fromPairs.js';
+export { functionsIn } from './object/functionsIn.js';
 export { get } from './object/get.js';
 export { has } from './object/has.js';
 export { invertBy } from './object/invertBy.js';