es-toolkit 1.32.0 → 1.33.0-dev.1025

package/dist/compat/index.mjs

@@ -5,11 +5,9 @@ export { flatMapDeep } from '../array/flatMapDeep.mjs';
 export { forEachRight } from '../array/forEachRight.mjs';
 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';
 export { partition } from '../array/partition.mjs';
 export { pullAt } from '../array/pullAt.mjs';
@@ -49,13 +47,13 @@ export { flattenObject } from '../object/flattenObject.mjs';
 export { invert } from '../object/invert.mjs';
 export { isObjectLike } from './predicate/isObjectLike.mjs';
 export { omitBy } from '../object/omitBy.mjs';
-export { pickBy } from '../object/pickBy.mjs';
 export { toMerged } from '../object/toMerged.mjs';
 export { isBlob } from '../predicate/isBlob.mjs';
 export { isEqual } from '../predicate/isEqual.mjs';
 export { eq } from './util/eq.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 { isNotNil } from '../predicate/isNotNil.mjs';
@@ -70,6 +68,7 @@ export { capitalize } from '../string/capitalize.mjs';
 export { constantCase } from '../string/constantCase.mjs';
 import '../string/deburr.mjs';
 export { pascalCase } from '../string/pascalCase.mjs';
+export { reverseString } from '../string/reverseString.mjs';
 export { invariant } from '../util/invariant.mjs';
 export { castArray } from './array/castArray.mjs';
 export { chunk } from './array/chunk.mjs';
@@ -87,6 +86,7 @@ export { fill } from './array/fill.mjs';
 export { filter } from './array/filter.mjs';
 export { find } from './array/find.mjs';
 export { findIndex } from './array/findIndex.mjs';
+export { findLast } from './array/findLast.mjs';
 export { findLastIndex } from './array/findLastIndex.mjs';
 export { flatten } from './array/flatten.mjs';
 export { flattenDeep } from './array/flattenDeep.mjs';
@@ -97,6 +97,7 @@ export { includes } from './array/includes.mjs';
 export { indexOf } from './array/indexOf.mjs';
 export { intersection } from './array/intersection.mjs';
 export { intersectionBy } from './array/intersectionBy.mjs';
+export { intersectionWith } from './array/intersectionWith.mjs';
 export { join } from './array/join.mjs';
 export { last } from './array/last.mjs';
 export { lastIndexOf } from './array/lastIndexOf.mjs';
@@ -105,6 +106,9 @@ export { nth } from './array/nth.mjs';
 export { orderBy } from './array/orderBy.mjs';
 export { pull } from './array/pull.mjs';
 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 { remove } from './array/remove.mjs';
 export { reverse } from './array/reverse.mjs';
 export { sample } from './array/sample.mjs';
@@ -148,9 +152,11 @@ export { throttle } from './function/throttle.mjs';
 export { add } from './math/add.mjs';
 export { ceil } from './math/ceil.mjs';
 export { clamp } from './math/clamp.mjs';
+export { divide } from './math/divide.mjs';
 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 { min } from './math/min.mjs';
 export { multiply } from './math/multiply.mjs';
 export { parseInt } from './math/parseInt.mjs';
@@ -178,11 +184,14 @@ export { merge } from './object/merge.mjs';
 export { mergeWith } from './object/mergeWith.mjs';
 export { omit } from './object/omit.mjs';
 export { pick } from './object/pick.mjs';
+export { pickBy } from './object/pickBy.mjs';
 export { property } from './object/property.mjs';
 export { propertyOf } from './object/propertyOf.mjs';
 export { set } from './object/set.mjs';
 export { toDefaulted } from './object/toDefaulted.mjs';
 export { unset } from './object/unset.mjs';
+export { values } from './object/values.mjs';
+export { valuesIn } from './object/valuesIn.mjs';
 export { conforms } from './predicate/conforms.mjs';
 export { conformsTo } from './predicate/conformsTo.mjs';
 export { isArguments } from './predicate/isArguments.mjs';

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

@@ -0,0 +1,18 @@
+/**
+ * Divide two numbers.
+ *
+ * If either of the numbers is `NaN`, the function returns `NaN`.
+ *
+ * @param {number} value The first number in a division.
+ * @param {number} other The second number in a division.
+ * @returns {number} The quotient of value and other.
+ *
+ * @example
+ * divide(6, 3); // => 2
+ * divide(2, NaN); // => NaN
+ * divide(NaN, 3); // => NaN
+ * divide(NaN, NaN); // => NaN
+ */
+declare function divide(value: number, other: number): number;
+
+export { divide };

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

@@ -0,0 +1,18 @@
+/**
+ * Divide two numbers.
+ *
+ * If either of the numbers is `NaN`, the function returns `NaN`.
+ *
+ * @param {number} value The first number in a division.
+ * @param {number} other The second number in a division.
+ * @returns {number} The quotient of value and other.
+ *
+ * @example
+ * divide(6, 3); // => 2
+ * divide(2, NaN); // => NaN
+ * divide(NaN, 3); // => NaN
+ * divide(NaN, NaN); // => NaN
+ */
+declare function divide(value: number, other: number): number;
+
+export { divide };

package/dist/compat/math/divide.mjs

@@ -0,0 +1,23 @@
+import { toNumber } from '../util/toNumber.mjs';
+import { toString } from '../util/toString.mjs';
+
+function divide(value, other) {
+    console.log(value, other);
+    if (value === undefined && other === undefined) {
+        return 1;
+    }
+    if (value === undefined || other === undefined) {
+        return value ?? other;
+    }
+    if (typeof value === 'string' || typeof other === 'string') {
+        value = toString(value);
+        other = toString(other);
+    }
+    else {
+        value = toNumber(value);
+        other = toNumber(other);
+    }
+    return value / other;
+}
+
+export { divide };

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

@@ -0,0 +1,31 @@
+/**
+ * Finds the element in an array that has the maximum value when applying
+ * the `iteratee` to each element.
+ *
+ * @template T - The type of elements in the array.
+ * @param {T[]} items The array of elements to search.
+ * @param {((element: T) => number) | keyof T | [keyof T, unknown] | Partial<T>} iteratee
+ * The criteria used to determine the maximum value.
+ *  - If a **function** is provided, it extracts a numeric value from each element.
+ *  - If a **string** is provided, it is treated as a key to extract values from the objects.
+ *  - If a **[key, value]** pair is provided, it matches elements with the specified key-value pair.
+ *  - If an **object** is provided, it matches elements that contain the specified properties.
+ * @returns {T | undefined} The element with the maximum value as determined by the `iteratee`.
+ * @example
+ * maxBy([{ a: 1 }, { a: 2 }, { a: 3 }], x => x.a); // Returns: { a: 3 }
+ * maxBy([], x => x.a); // Returns: undefined
+ * maxBy(
+ *   [
+ *     { name: 'john', age: 30 },
+ *     { name: 'jane', age: 28 },
+ *     { name: 'joe', age: 26 },
+ *   ],
+ *   x => x.age
+ * ); // Returns: { name: 'john', age: 30 }
+ * maxBy([{ a: 1 }, { a: 2 }], 'a'); // Returns: { a: 2 }
+ * maxBy([{ a: 1 }, { a: 2 }], ['a', 1]); // Returns: { a: 1 }
+ * maxBy([{ a: 1 }, { a: 2 }], { a: 1 }); // Returns: { a: 1 }
+ */
+declare function maxBy<T>(items: ArrayLike<T> | null | undefined, iteratee: ((element: T) => number) | keyof T | [keyof T, unknown] | Partial<T>): T | undefined;
+
+export { maxBy };

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

@@ -0,0 +1,31 @@
+/**
+ * Finds the element in an array that has the maximum value when applying
+ * the `iteratee` to each element.
+ *
+ * @template T - The type of elements in the array.
+ * @param {T[]} items The array of elements to search.
+ * @param {((element: T) => number) | keyof T | [keyof T, unknown] | Partial<T>} iteratee
+ * The criteria used to determine the maximum value.
+ *  - If a **function** is provided, it extracts a numeric value from each element.
+ *  - If a **string** is provided, it is treated as a key to extract values from the objects.
+ *  - If a **[key, value]** pair is provided, it matches elements with the specified key-value pair.
+ *  - If an **object** is provided, it matches elements that contain the specified properties.
+ * @returns {T | undefined} The element with the maximum value as determined by the `iteratee`.
+ * @example
+ * maxBy([{ a: 1 }, { a: 2 }, { a: 3 }], x => x.a); // Returns: { a: 3 }
+ * maxBy([], x => x.a); // Returns: undefined
+ * maxBy(
+ *   [
+ *     { name: 'john', age: 30 },
+ *     { name: 'jane', age: 28 },
+ *     { name: 'joe', age: 26 },
+ *   ],
+ *   x => x.age
+ * ); // Returns: { name: 'john', age: 30 }
+ * maxBy([{ a: 1 }, { a: 2 }], 'a'); // Returns: { a: 2 }
+ * maxBy([{ a: 1 }, { a: 2 }], ['a', 1]); // Returns: { a: 1 }
+ * maxBy([{ a: 1 }, { a: 2 }], { a: 1 }); // Returns: { a: 1 }
+ */
+declare function maxBy<T>(items: ArrayLike<T> | null | undefined, iteratee: ((element: T) => number) | keyof T | [keyof T, unknown] | Partial<T>): T | undefined;
+
+export { maxBy };

package/dist/compat/math/maxBy.mjs

@@ -0,0 +1,11 @@
+import { maxBy as maxBy$1 } from '../../array/maxBy.mjs';
+import { iteratee } from '../util/iteratee.mjs';
+
+function maxBy(items, iteratee$1) {
+    if (items == null) {
+        return undefined;
+    }
+    return maxBy$1(Array.from(items), iteratee(iteratee$1));
+}
+
+export { maxBy };

package/dist/compat/math/multiply.mjs

@@ -1,3 +1,4 @@
+import { toNumber } from '../util/toNumber.mjs';
 import { toString } from '../util/toString.mjs';
 
 function multiply(value, other) {
@@ -5,15 +6,15 @@ function multiply(value, other) {
         return 1;
     }
     if (value === undefined || other === undefined) {
-        return value || other;
+        return value ?? other;
     }
     if (typeof value === 'string' || typeof other === 'string') {
         value = toString(value);
         other = toString(other);
     }
     else {
-        value = Number(value);
-        other = Number(other);
+        value = toNumber(value);
+        other = toNumber(other);
     }
     return value * other;
 }

package/dist/compat/math/sumBy.mjs

@@ -7,11 +7,16 @@ function sumBy(array, iteratee$1) {
     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++) {
+    let result = undefined;
+    for (let i = 0; i < array.length; i++) {
         const current = iteratee$1 ? iteratee$1(array[i]) : array[i];
         if (current !== undefined) {
-            result += current;
+            if (result === undefined) {
+                result = current;
+            }
+            else {
+                result += current;
+            }
         }
     }
     return result;

package/dist/compat/object/assignIn.mjs

@@ -11,7 +11,7 @@ function assignInImpl(object, source) {
     const keys = keysIn(source);
     for (let i = 0; i < keys.length; i++) {
         const key = keys[i];
-        if (!eq(object[key], source[key])) {
+        if (!(key in object) || !eq(object[key], source[key])) {
             object[key] = source[key];
         }
     }

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

@@ -0,0 +1,22 @@
+/**
+ * Creates a new object composed of the properties that satisfy the predicate function.
+ *
+ * This function takes an object and a predicate function, and returns a new object that
+ * includes only the properties for which the predicate function returns true.
+ *
+ * @template T - The type of object.
+ * @param {T} obj - The object to pick properties from.
+ * @param {(value: T[keyof T], key: keyof T) => boolean} shouldPick - A predicate function that determines
+ * whether a property should be picked. It takes the property's key and value as arguments and returns `true`
+ * if the property should be picked, and `false` otherwise.
+ * @returns {Partial<T>} A new object with the properties that satisfy the predicate function.
+ *
+ * @example
+ * const obj = { a: 1, b: 'pick', c: 3 };
+ * const shouldPick = (value) => typeof value === 'string';
+ * const result = pickBy(obj, shouldPick);
+ * // result will be { b: 'pick' }
+ */
+declare function pickBy<T extends Record<string, any>>(obj: T, shouldPick?: (value: T[keyof T], key: keyof T, obj: T) => boolean): Partial<T>;
+
+export { pickBy };

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

@@ -0,0 +1,22 @@
+/**
+ * Creates a new object composed of the properties that satisfy the predicate function.
+ *
+ * This function takes an object and a predicate function, and returns a new object that
+ * includes only the properties for which the predicate function returns true.
+ *
+ * @template T - The type of object.
+ * @param {T} obj - The object to pick properties from.
+ * @param {(value: T[keyof T], key: keyof T) => boolean} shouldPick - A predicate function that determines
+ * whether a property should be picked. It takes the property's key and value as arguments and returns `true`
+ * if the property should be picked, and `false` otherwise.
+ * @returns {Partial<T>} A new object with the properties that satisfy the predicate function.
+ *
+ * @example
+ * const obj = { a: 1, b: 'pick', c: 3 };
+ * const shouldPick = (value) => typeof value === 'string';
+ * const result = pickBy(obj, shouldPick);
+ * // result will be { b: 'pick' }
+ */
+declare function pickBy<T extends Record<string, any>>(obj: T, shouldPick?: (value: T[keyof T], key: keyof T, obj: T) => boolean): Partial<T>;
+
+export { pickBy };

package/dist/compat/object/pickBy.mjs

@@ -0,0 +1,23 @@
+import { range } from '../../math/range.mjs';
+import { isArrayLike } from '../predicate/isArrayLike.mjs';
+
+function pickBy(obj, shouldPick) {
+    if (obj == null) {
+        return {};
+    }
+    const result = {};
+    if (shouldPick == null) {
+        return obj;
+    }
+    const keys = isArrayLike(obj) ? range(0, obj.length) : Object.keys(obj);
+    for (let i = 0; i < keys.length; i++) {
+        const key = keys[i].toString();
+        const value = obj[key];
+        if (shouldPick(value, key, obj)) {
+            result[key] = value;
+        }
+    }
+    return result;
+}
+
+export { pickBy };

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

@@ -0,0 +1,32 @@
+/**
+ * Creates an array of the own enumerable property values of `object`.
+ *
+ * @param {Record<PropertyKey, T> | null | undefined} object The object to query.
+ * @returns {T[]} Returns an array of property values.
+ * @example
+ * const object = { a: 1, b: 2 };
+ * values(object); // => [1, 2]
+ */
+declare function values<T>(object: Record<PropertyKey, T> | null | undefined): T[];
+/**
+ * Creates an array of the values of an array or array-like object.
+ *
+ * @param {ArrayLike<T>} arr The array or array-like object to query.
+ * @returns {T[]} Returns an array of values.
+ * @example
+ * const array = ['a', 'b'];
+ * values(arrayLike); // => ['a', 'b']
+ */
+declare function values<T>(arr: ArrayLike<T>): T[];
+/**
+ * Creates an array of the own enumerable property values of `object`.
+ *
+ * @param {T | null | undefined} object The object to query.
+ * @returns {Array<T[keyof T]>} Returns an array of property values.
+ * @example
+ * const obj = { x: 1, y: 2, z: 3 };
+ * values(obj); // => [1, 2, 3]
+ */
+declare function values<T extends object>(object: T | null | undefined): Array<T[keyof T]>;
+
+export { values };

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

@@ -0,0 +1,32 @@
+/**
+ * Creates an array of the own enumerable property values of `object`.
+ *
+ * @param {Record<PropertyKey, T> | null | undefined} object The object to query.
+ * @returns {T[]} Returns an array of property values.
+ * @example
+ * const object = { a: 1, b: 2 };
+ * values(object); // => [1, 2]
+ */
+declare function values<T>(object: Record<PropertyKey, T> | null | undefined): T[];
+/**
+ * Creates an array of the values of an array or array-like object.
+ *
+ * @param {ArrayLike<T>} arr The array or array-like object to query.
+ * @returns {T[]} Returns an array of values.
+ * @example
+ * const array = ['a', 'b'];
+ * values(arrayLike); // => ['a', 'b']
+ */
+declare function values<T>(arr: ArrayLike<T>): T[];
+/**
+ * Creates an array of the own enumerable property values of `object`.
+ *
+ * @param {T | null | undefined} object The object to query.
+ * @returns {Array<T[keyof T]>} Returns an array of property values.
+ * @example
+ * const obj = { x: 1, y: 2, z: 3 };
+ * values(obj); // => [1, 2, 3]
+ */
+declare function values<T extends object>(object: T | null | undefined): Array<T[keyof T]>;
+
+export { values };

package/dist/compat/object/values.mjs

@@ -0,0 +1,5 @@
+function values(object) {
+    return Object.values(object);
+}
+
+export { values };

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

@@ -0,0 +1,63 @@
+/**
+ * Retrieves the values from an object, including those inherited from its prototype.
+ *
+ * - If the value is not an object, it is converted to an object.
+ * - Array-like objects are treated like arrays.
+ * - Sparse arrays with some missing indices are treated like dense arrays.
+ * - If the value is `null` or `undefined`, an empty array is returned.
+ * - When handling prototype objects, the `constructor` property is excluded from the results.
+ *
+ * @param {Record<PropertyKey, T> | null | undefined} object The object to query.
+ * @returns {T[]} Returns an array of property values.
+ * @example
+ * const object = { a: 1, b: 2 };
+ * valuesIn(object); // => [1, 2]
+ *
+ * const arr = [1, 2, 3];
+ * valuesIn(arr); // => [1, 2, 3]
+ *
+ * function Foo() {
+ *   this.a = 1;
+ * }
+ * Foo.prototype.b = 2;
+ * const foo = new Foo();
+ * valuesIn(foo); // => [1] (includes inherited properties)
+ *
+ * const objWithLength = { 0: 'a', 1: 'b', length: 2 };
+ * valuesIn(objWithLength); // => ['a', 'b', 2]
+ */
+declare function valuesIn<T>(object: Record<PropertyKey, T> | null | undefined): T[];
+/**
+ * Retrieves the values from an object, including those inherited from its prototype.
+ *
+ * - If the value is not an object, it is converted to an object.
+ * - Array-like objects are treated like arrays.
+ * - Sparse arrays with some missing indices are treated like dense arrays.
+ * - If the value is `null` or `undefined`, an empty array is returned.
+ * - When handling prototype objects, the `constructor` property is excluded from the results.
+ *
+ * @param {ArrayLike<T>} arr The array or array-like object to query.
+ * @returns {T[]} Returns an array of values.
+ * @example
+ * const arrayLike = { 0: 'a', 1: 'b', length: 2 };
+ * valuesIn(arrayLike); // => ['a', 'b']
+ */
+declare function valuesIn<T>(arr: ArrayLike<T>): T[];
+/**
+ * Retrieves the values from an object, including those inherited from its prototype.
+ *
+ * - If the value is not an object, it is converted to an object.
+ * - Array-like objects are treated like arrays.
+ * - Sparse arrays with some missing indices are treated like dense arrays.
+ * - If the value is `null` or `undefined`, an empty array is returned.
+ * - When handling prototype objects, the `constructor` property is excluded from the results.
+ *
+ * @param {T | null | undefined} object The object to query.
+ * @returns {Array<T[keyof T]>} Returns an array of property values.
+ * @example
+ * const obj = { x: 1, y: 2, z: 3 };
+ * valuesIn(obj); // => [1, 2, 3]
+ */
+declare function valuesIn<T extends object>(object: T | null | undefined): Array<T[keyof T]>;
+
+export { valuesIn };

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

@@ -0,0 +1,63 @@
+/**
+ * Retrieves the values from an object, including those inherited from its prototype.
+ *
+ * - If the value is not an object, it is converted to an object.
+ * - Array-like objects are treated like arrays.
+ * - Sparse arrays with some missing indices are treated like dense arrays.
+ * - If the value is `null` or `undefined`, an empty array is returned.
+ * - When handling prototype objects, the `constructor` property is excluded from the results.
+ *
+ * @param {Record<PropertyKey, T> | null | undefined} object The object to query.
+ * @returns {T[]} Returns an array of property values.
+ * @example
+ * const object = { a: 1, b: 2 };
+ * valuesIn(object); // => [1, 2]
+ *
+ * const arr = [1, 2, 3];
+ * valuesIn(arr); // => [1, 2, 3]
+ *
+ * function Foo() {
+ *   this.a = 1;
+ * }
+ * Foo.prototype.b = 2;
+ * const foo = new Foo();
+ * valuesIn(foo); // => [1] (includes inherited properties)
+ *
+ * const objWithLength = { 0: 'a', 1: 'b', length: 2 };
+ * valuesIn(objWithLength); // => ['a', 'b', 2]
+ */
+declare function valuesIn<T>(object: Record<PropertyKey, T> | null | undefined): T[];
+/**
+ * Retrieves the values from an object, including those inherited from its prototype.
+ *
+ * - If the value is not an object, it is converted to an object.
+ * - Array-like objects are treated like arrays.
+ * - Sparse arrays with some missing indices are treated like dense arrays.
+ * - If the value is `null` or `undefined`, an empty array is returned.
+ * - When handling prototype objects, the `constructor` property is excluded from the results.
+ *
+ * @param {ArrayLike<T>} arr The array or array-like object to query.
+ * @returns {T[]} Returns an array of values.
+ * @example
+ * const arrayLike = { 0: 'a', 1: 'b', length: 2 };
+ * valuesIn(arrayLike); // => ['a', 'b']
+ */
+declare function valuesIn<T>(arr: ArrayLike<T>): T[];
+/**
+ * Retrieves the values from an object, including those inherited from its prototype.
+ *
+ * - If the value is not an object, it is converted to an object.
+ * - Array-like objects are treated like arrays.
+ * - Sparse arrays with some missing indices are treated like dense arrays.
+ * - If the value is `null` or `undefined`, an empty array is returned.
+ * - When handling prototype objects, the `constructor` property is excluded from the results.
+ *
+ * @param {T | null | undefined} object The object to query.
+ * @returns {Array<T[keyof T]>} Returns an array of property values.
+ * @example
+ * const obj = { x: 1, y: 2, z: 3 };
+ * valuesIn(obj); // => [1, 2, 3]
+ */
+declare function valuesIn<T extends object>(object: T | null | undefined): Array<T[keyof T]>;
+
+export { valuesIn };

package/dist/compat/object/valuesIn.mjs

@@ -0,0 +1,13 @@
+import { keysIn } from './keysIn.mjs';
+
+function valuesIn(object) {
+    const keys = keysIn(object);
+    const result = new Array(keys.length);
+    for (let i = 0; i < keys.length; i++) {
+        const key = keys[i];
+        result[i] = object[key];
+    }
+    return result;
+}
+
+export { valuesIn };

package/dist/index.d.mts

@@ -119,6 +119,7 @@ export { isEqualWith } from './predicate/isEqualWith.mjs';
 export { isError } from './predicate/isError.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 { isMap } from './predicate/isMap.mjs';
@@ -152,6 +153,7 @@ export { lowerCase } from './string/lowerCase.mjs';
 export { lowerFirst } from './string/lowerFirst.mjs';
 export { pad } from './string/pad.mjs';
 export { pascalCase } from './string/pascalCase.mjs';
+export { reverseString } from './string/reverseString.mjs';
 export { snakeCase } from './string/snakeCase.mjs';
 export { startCase } from './string/startCase.mjs';
 export { trim } from './string/trim.mjs';

package/dist/index.d.ts

@@ -119,6 +119,7 @@ export { isEqualWith } from './predicate/isEqualWith.js';
 export { isError } from './predicate/isError.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 { isMap } from './predicate/isMap.js';
@@ -152,6 +153,7 @@ export { lowerCase } from './string/lowerCase.js';
 export { lowerFirst } from './string/lowerFirst.js';
 export { pad } from './string/pad.js';
 export { pascalCase } from './string/pascalCase.js';
+export { reverseString } from './string/reverseString.js';
 export { snakeCase } from './string/snakeCase.js';
 export { startCase } from './string/startCase.js';
 export { trim } from './string/trim.js';

package/dist/index.js

@@ -12,14 +12,14 @@ const noop = require('./_chunk/noop-2IwLUk.js');
 const range = require('./_chunk/range-HnEIT7.js');
 const randomInt = require('./_chunk/randomInt-CF7bZK.js');
 const math_index = require('./math/index.js');
-const toMerged = require('./_chunk/toMerged-BQTfB8.js');
+const toMerged = require('./_chunk/toMerged-CwnQF6.js');
 const object_index = require('./object/index.js');
-const isWeakSet = require('./_chunk/isWeakSet-DoHqUM.js');
+const isWeakSet = require('./_chunk/isWeakSet-TIM260.js');
 const predicate_index = require('./predicate/index.js');
 const isPlainObject = require('./_chunk/isPlainObject-Xaozpc.js');
 const delay = require('./_chunk/delay-_VMfFa.js');
 const promise_index = require('./promise/index.js');
-const upperFirst = require('./_chunk/upperFirst-CorAVn.js');
+const upperFirst = require('./_chunk/upperFirst-nA5L7X.js');
 const string_index = require('./string/index.js');
 const util_index = require('./util/index.js');
 
@@ -131,11 +131,11 @@ exports.mapKeys = toMerged.mapKeys;
 exports.mapValues = toMerged.mapValues;
 exports.merge = toMerged.merge;
 exports.omitBy = toMerged.omitBy;
-exports.pickBy = toMerged.pickBy;
 exports.toMerged = toMerged.toMerged;
 exports.mergeWith = object_index.mergeWith;
 exports.omit = object_index.omit;
 exports.pick = object_index.pick;
+exports.pickBy = object_index.pickBy;
 exports.isArrayBuffer = isWeakSet.isArrayBuffer;
 exports.isBlob = isWeakSet.isBlob;
 exports.isBuffer = isWeakSet.isBuffer;
@@ -144,6 +144,7 @@ exports.isEqual = isWeakSet.isEqual;
 exports.isEqualWith = isWeakSet.isEqualWith;
 exports.isFile = isWeakSet.isFile;
 exports.isFunction = isWeakSet.isFunction;
+exports.isJSON = isWeakSet.isJSON;
 exports.isJSONArray = isWeakSet.isJSONArray;
 exports.isJSONObject = isWeakSet.isJSONObject;
 exports.isJSONValue = isWeakSet.isJSONValue;
@@ -181,6 +182,7 @@ exports.lowerCase = upperFirst.lowerCase;
 exports.lowerFirst = upperFirst.lowerFirst;
 exports.pad = upperFirst.pad;
 exports.pascalCase = upperFirst.pascalCase;
+exports.reverseString = upperFirst.reverseString;
 exports.snakeCase = upperFirst.snakeCase;
 exports.trim = upperFirst.trim;
 exports.trimEnd = upperFirst.trimEnd;