es-toolkit 1.35.0 → 1.36.0-dev.1217

package/dist/compat/array/partition.mjs

@@ -0,0 +1,24 @@
+import { isArrayLike } from '../predicate/isArrayLike.mjs';
+import { iteratee } from '../util/iteratee.mjs';
+
+function partition(source, predicate) {
+    if (!source) {
+        return [[], []];
+    }
+    const collection = isArrayLike(source) ? source : Object.values(source);
+    predicate = iteratee(predicate);
+    const matched = [];
+    const unmatched = [];
+    for (let i = 0; i < collection.length; i++) {
+        const value = collection[i];
+        if (predicate(value)) {
+            matched.push(value);
+        }
+        else {
+            unmatched.push(value);
+        }
+    }
+    return [matched, unmatched];
+}
+
+export { partition };

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

@@ -0,0 +1,59 @@
+/**
+ * Removes and returns elements from an array using a provided comparison function to determine which elements to remove.
+ *
+ * @template T
+ * @param {T[]} array - The array to modify.
+ * @param {T[]} values - The values to remove from the array.
+ * @param {(a: T, b: T) => boolean} comparator - The function to compare elements of `array` with elements of `values`. Should return `true` if the two elements are considered equal.
+ * @returns {T[]} - The array with specified values removed.
+ *
+ * @example
+ * const array = [{ x: 1, y: 2 }, { x: 3, y: 4 }, { x: 5, y: 6 }];
+ * const valuesToRemove = [{ x: 3, y: 4 }];
+ *
+ * const result = pullAllWith(array, valuesToRemove, isEqual);
+ *
+ * console.log(result); // [{ x: 1, y: 2 }, { x: 5, y: 6 }]
+ */
+declare function pullAllWith<T>(array: T[], values?: T[], comparator?: (a: T, b: T) => boolean): T[];
+declare function pullAllWith<T>(array: ArrayLike<T>, values?: ArrayLike<T>, comparator?: (a: T, b: T) => boolean): ArrayLike<T>;
+/**
+ * Removes and returns elements from an array using a provided comparison function to determine which elements to remove.
+ *
+ * @template T1
+ * @template T2
+ * @param {T1[]} array - The array to modify.
+ * @param {ArrayLike<T2>} values - The values to remove from the array.
+ * @param {(a: T1, b: T2) => boolean} comparator - The function to compare elements of `array` with elements of `values`. Should return `true` if the two elements are considered equal.
+ * @returns {T1[]} - The array with specified values removed.
+ *
+ * @example
+ * const array = [{ x: 1, y: 2 }, { x: 3, y: 4 }, { x: 5, y: 6 }];
+ * const valuesToRemove = [{ x: 3, y: 4 }];
+ *
+ * const result = pullAllWith(array, valuesToRemove, isEqual);
+ *
+ * console.log(result); // [{ x: 1, y: 2 }, { x: 5, y: 6 }]
+ */
+declare function pullAllWith<T1, T2>(array: T1[], values: ArrayLike<T2>, comparator: (a: T1, b: T2) => boolean): T1[];
+/**
+ * Removes and returns elements from an array using a provided comparison function to determine which elements to remove.
+ *
+ * @template T1
+ * @template T2
+ * @param {T1[]} array - The array to modify.
+ * @param {ArrayLike<T2>} values - The values to remove from the array.
+ * @param {(a: T1, b: T2) => boolean} comparator - The function to compare elements of `array` with elements of `values`. Should return `true` if the two elements are considered equal.
+ * @returns {ArrayLike<T1>} - The array with specified values removed.
+ *
+ * @example
+ * const array = [{ x: 1, y: 2 }, { x: 3, y: 4 }, { x: 5, y: 6 }];
+ * const valuesToRemove = [{ x: 3, y: 4 }];
+ *
+ * const result = pullAllWith(array, valuesToRemove, isEqual);
+ *
+ * console.log(result); // [{ x: 1, y: 2 }, { x: 5, y: 6 }]
+ */
+declare function pullAllWith<T1, T2>(array: ArrayLike<T1>, values: ArrayLike<T2>, comparator: (a: T1, b: T2) => boolean): ArrayLike<T1>;
+
+export { pullAllWith };

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

@@ -0,0 +1,59 @@
+/**
+ * Removes and returns elements from an array using a provided comparison function to determine which elements to remove.
+ *
+ * @template T
+ * @param {T[]} array - The array to modify.
+ * @param {T[]} values - The values to remove from the array.
+ * @param {(a: T, b: T) => boolean} comparator - The function to compare elements of `array` with elements of `values`. Should return `true` if the two elements are considered equal.
+ * @returns {T[]} - The array with specified values removed.
+ *
+ * @example
+ * const array = [{ x: 1, y: 2 }, { x: 3, y: 4 }, { x: 5, y: 6 }];
+ * const valuesToRemove = [{ x: 3, y: 4 }];
+ *
+ * const result = pullAllWith(array, valuesToRemove, isEqual);
+ *
+ * console.log(result); // [{ x: 1, y: 2 }, { x: 5, y: 6 }]
+ */
+declare function pullAllWith<T>(array: T[], values?: T[], comparator?: (a: T, b: T) => boolean): T[];
+declare function pullAllWith<T>(array: ArrayLike<T>, values?: ArrayLike<T>, comparator?: (a: T, b: T) => boolean): ArrayLike<T>;
+/**
+ * Removes and returns elements from an array using a provided comparison function to determine which elements to remove.
+ *
+ * @template T1
+ * @template T2
+ * @param {T1[]} array - The array to modify.
+ * @param {ArrayLike<T2>} values - The values to remove from the array.
+ * @param {(a: T1, b: T2) => boolean} comparator - The function to compare elements of `array` with elements of `values`. Should return `true` if the two elements are considered equal.
+ * @returns {T1[]} - The array with specified values removed.
+ *
+ * @example
+ * const array = [{ x: 1, y: 2 }, { x: 3, y: 4 }, { x: 5, y: 6 }];
+ * const valuesToRemove = [{ x: 3, y: 4 }];
+ *
+ * const result = pullAllWith(array, valuesToRemove, isEqual);
+ *
+ * console.log(result); // [{ x: 1, y: 2 }, { x: 5, y: 6 }]
+ */
+declare function pullAllWith<T1, T2>(array: T1[], values: ArrayLike<T2>, comparator: (a: T1, b: T2) => boolean): T1[];
+/**
+ * Removes and returns elements from an array using a provided comparison function to determine which elements to remove.
+ *
+ * @template T1
+ * @template T2
+ * @param {T1[]} array - The array to modify.
+ * @param {ArrayLike<T2>} values - The values to remove from the array.
+ * @param {(a: T1, b: T2) => boolean} comparator - The function to compare elements of `array` with elements of `values`. Should return `true` if the two elements are considered equal.
+ * @returns {ArrayLike<T1>} - The array with specified values removed.
+ *
+ * @example
+ * const array = [{ x: 1, y: 2 }, { x: 3, y: 4 }, { x: 5, y: 6 }];
+ * const valuesToRemove = [{ x: 3, y: 4 }];
+ *
+ * const result = pullAllWith(array, valuesToRemove, isEqual);
+ *
+ * console.log(result); // [{ x: 1, y: 2 }, { x: 5, y: 6 }]
+ */
+declare function pullAllWith<T1, T2>(array: ArrayLike<T1>, values: ArrayLike<T2>, comparator: (a: T1, b: T2) => boolean): ArrayLike<T1>;
+
+export { pullAllWith };

package/dist/compat/array/pullAllWith.mjs

@@ -0,0 +1,33 @@
+import copyArray from '../_internal/copyArray.mjs';
+import { eq } from '../util/eq.mjs';
+
+function pullAllWith(array, values, comparator) {
+    if (array?.length == null || values?.length == null) {
+        return array;
+    }
+    if (array === values) {
+        values = copyArray(values);
+    }
+    let resultLength = 0;
+    if (comparator == null) {
+        comparator = (a, b) => eq(a, b);
+    }
+    const valuesArray = Array.isArray(values) ? values : Array.from(values);
+    const hasUndefined = valuesArray.includes(undefined);
+    for (let i = 0; i < array.length; i++) {
+        if (i in array) {
+            const shouldRemove = valuesArray.some(value => comparator(array[i], value));
+            if (!shouldRemove) {
+                array[resultLength++] = array[i];
+            }
+            continue;
+        }
+        if (!hasUndefined) {
+            delete array[resultLength++];
+        }
+    }
+    array.length = resultLength;
+    return array;
+}
+
+export { pullAllWith };

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

@@ -0,0 +1,32 @@
+/**
+ * Removes elements from an array at specified indices and returns the removed elements.
+ *
+ * @template T
+ * @param {T[]} array - The array from which elements will be removed.
+ * @param {Array<number | readonly number[] | string | readonly string[]>} indicesToRemove - An array of indices specifying the positions of elements to remove.
+ * @returns {T[]} An array containing the elements that were removed from the original array.
+ *
+ * @example
+ * const numbers = [10, 20, 30, 40, 50];
+ * const removed = pullAt(numbers, [1, 3, 4]);
+ * console.log(removed); // [20, 40, 50]
+ * console.log(numbers); // [10, 30]
+ */
+declare function pullAt<T>(array: T[], ...indicesToRemove: Array<number | readonly number[] | string | readonly string[]>): T[];
+/**
+ * Removes elements from an array at specified indices and returns the removed elements.
+ *
+ * @template T
+ * @param {ArrayLike<T>} array - The array from which elements will be removed.
+ * @param {Array<number | readonly number[] | string | readonly string[]>} indicesToRemove - An array of indices specifying the positions of elements to remove.
+ * @returns {ArrayLike<T>} An array containing the elements that were removed from the original array.
+ *
+ * @example
+ * const numbers = [10, 20, 30, 40, 50];
+ * const removed = pullAt(numbers, [1, 3, 4]);
+ * console.log(removed); // [20, 40, 50]
+ * console.log(numbers); // [10, 30]
+ */
+declare function pullAt<T>(array: ArrayLike<T>, ...indicesToRemove: Array<number | readonly number[] | string | readonly string[]>): ArrayLike<T>;
+
+export { pullAt };

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

@@ -0,0 +1,32 @@
+/**
+ * Removes elements from an array at specified indices and returns the removed elements.
+ *
+ * @template T
+ * @param {T[]} array - The array from which elements will be removed.
+ * @param {Array<number | readonly number[] | string | readonly string[]>} indicesToRemove - An array of indices specifying the positions of elements to remove.
+ * @returns {T[]} An array containing the elements that were removed from the original array.
+ *
+ * @example
+ * const numbers = [10, 20, 30, 40, 50];
+ * const removed = pullAt(numbers, [1, 3, 4]);
+ * console.log(removed); // [20, 40, 50]
+ * console.log(numbers); // [10, 30]
+ */
+declare function pullAt<T>(array: T[], ...indicesToRemove: Array<number | readonly number[] | string | readonly string[]>): T[];
+/**
+ * Removes elements from an array at specified indices and returns the removed elements.
+ *
+ * @template T
+ * @param {ArrayLike<T>} array - The array from which elements will be removed.
+ * @param {Array<number | readonly number[] | string | readonly string[]>} indicesToRemove - An array of indices specifying the positions of elements to remove.
+ * @returns {ArrayLike<T>} An array containing the elements that were removed from the original array.
+ *
+ * @example
+ * const numbers = [10, 20, 30, 40, 50];
+ * const removed = pullAt(numbers, [1, 3, 4]);
+ * console.log(removed); // [20, 40, 50]
+ * console.log(numbers); // [10, 30]
+ */
+declare function pullAt<T>(array: ArrayLike<T>, ...indicesToRemove: Array<number | readonly number[] | string | readonly string[]>): ArrayLike<T>;
+
+export { pullAt };

package/dist/compat/array/pullAt.mjs

@@ -0,0 +1,34 @@
+import { flatten } from './flatten.mjs';
+import { isIndex } from '../_internal/isIndex.mjs';
+import { isKey } from '../_internal/isKey.mjs';
+import { toKey } from '../_internal/toKey.mjs';
+import { at } from '../object/at.mjs';
+import { unset } from '../object/unset.mjs';
+import { isArray } from '../predicate/isArray.mjs';
+import { toPath } from '../util/toPath.mjs';
+
+function pullAt(array, ..._indices) {
+    const indices = flatten(_indices, 1);
+    if (!array) {
+        return Array(indices.length);
+    }
+    const result = at(array, indices);
+    const indicesToPull = indices
+        .map(index => (isIndex(index, array.length) ? Number(index) : index))
+        .sort((a, b) => b - a);
+    for (const index of new Set(indicesToPull)) {
+        if (isIndex(index, array.length)) {
+            Array.prototype.splice.call(array, index, 1);
+            continue;
+        }
+        if (isKey(index, array)) {
+            delete array[toKey(index)];
+            continue;
+        }
+        const path = isArray(index) ? index : toPath(index);
+        unset(array, path);
+    }
+    return result;
+}
+
+export { pullAt };

package/dist/compat/compat.d.mts

@@ -0,0 +1,310 @@
+export { countBy } from '../array/countBy.mjs';
+export { flatMapDeep } from '../array/flatMapDeep.mjs';
+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 { sampleSize } from '../array/sampleSize.mjs';
+export { shuffle } from '../array/shuffle.mjs';
+export { toFilled } from '../array/toFilled.mjs';
+export { unzipWith } from '../array/unzipWith.mjs';
+export { windowed } from '../array/windowed.mjs';
+export { xor } from '../array/xor.mjs';
+export { xorBy } from '../array/xorBy.mjs';
+export { xorWith } from '../array/xorWith.mjs';
+export { AbortError } from '../error/AbortError.mjs';
+export { TimeoutError } from '../error/TimeoutError.mjs';
+export { asyncNoop } from '../function/asyncNoop.mjs';
+export { identity } from '../function/identity.mjs';
+export { MemoizeCache, memoize } from '../function/memoize.mjs';
+export { noop } from '../function/noop.mjs';
+export { once } from '../function/once.mjs';
+export { retry } from '../function/retry.mjs';
+export { ThrottledFunction } from '../function/throttle.mjs';
+export { unary } from '../function/unary.mjs';
+export { median } from '../math/median.mjs';
+export { medianBy } from '../math/medianBy.mjs';
+export { randomInt } from '../math/randomInt.mjs';
+export { clone } from '../object/clone.mjs';
+export { flattenObject } from '../object/flattenObject.mjs';
+export { invert } from '../object/invert.mjs';
+export { omitBy } from '../object/omitBy.mjs';
+export { toCamelCaseKeys } from '../object/toCamelCaseKeys.mjs';
+export { toMerged } from '../object/toMerged.mjs';
+export { toSnakeCaseKeys } from '../object/toSnakeCaseKeys.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';
+export { isPromise } from '../predicate/isPromise.mjs';
+export { isUndefined } from '../predicate/isUndefined.mjs';
+export { Mutex } from '../promise/mutex.mjs';
+export { Semaphore } from '../promise/semaphore.mjs';
+export { timeout } from '../promise/timeout.mjs';
+export { withTimeout } from '../promise/withTimeout.mjs';
+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';
+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 { differenceWith } from './array/differenceWith.mjs';
+export { drop } from './array/drop.mjs';
+export { dropRight } from './array/dropRight.mjs';
+export { dropRightWhile } from './array/dropRightWhile.mjs';
+export { dropWhile } from './array/dropWhile.mjs';
+export { every } from './array/every.mjs';
+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 { flatMap } from './array/flatMap.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 { forEachRight as eachRight, forEachRight } from './array/forEachRight.mjs';
+export { groupBy } from './array/groupBy.mjs';
+export { head as first, head } from './array/head.mjs';
+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';
+export { map } from './array/map.mjs';
+export { nth } from './array/nth.mjs';
+export { orderBy } from './array/orderBy.mjs';
+export { partition } from './array/partition.mjs';
+export { pull } from './array/pull.mjs';
+export { pullAll } from './array/pullAll.mjs';
+export { pullAllBy } from './array/pullAllBy.mjs';
+export { pullAllWith } from './array/pullAllWith.mjs';
+export { pullAt } from './array/pullAt.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';
+export { size } from './array/size.mjs';
+export { slice } from './array/slice.mjs';
+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 { sortedLastIndex } from './array/sortedLastIndex.mjs';
+export { sortedLastIndexBy } from './array/sortedLastIndexBy.mjs';
+export { tail } from './array/tail.mjs';
+export { take } from './array/take.mjs';
+export { takeRight } from './array/takeRight.mjs';
+export { takeRightWhile } from './array/takeRightWhile.mjs';
+export { takeWhile } from './array/takeWhile.mjs';
+export { union } from './array/union.mjs';
+export { unionBy } from './array/unionBy.mjs';
+export { unionWith } from './array/unionWith.mjs';
+export { uniq } from './array/uniq.mjs';
+export { uniqBy } from './array/uniqBy.mjs';
+export { uniqWith } from './array/uniqWith.mjs';
+export { unzip } from './array/unzip.mjs';
+export { without } from './array/without.mjs';
+export { zip } from './array/zip.mjs';
+export { zipObject } from './array/zipObject.mjs';
+export { zipObjectDeep } from './array/zipObjectDeep.mjs';
+export { zipWith } from './array/zipWith.mjs';
+export { after } from './function/after.mjs';
+export { ary } from './function/ary.mjs';
+export { attempt } from './function/attempt.mjs';
+export { before } from './function/before.mjs';
+export { bind } from './function/bind.mjs';
+export { bindKey } from './function/bindKey.mjs';
+export { curry } from './function/curry.mjs';
+export { curryRight } from './function/curryRight.mjs';
+export { DebouncedFunction as DebouncedFunc, DebouncedFunction, debounce } from './function/debounce.mjs';
+export { defer } from './function/defer.mjs';
+export { delay } from './function/delay.mjs';
+export { flip } from './function/flip.mjs';
+export { flow } from './function/flow.mjs';
+export { flowRight } from './function/flowRight.mjs';
+export { negate } from './function/negate.mjs';
+export { nthArg } from './function/nthArg.mjs';
+export { partial } from './function/partial.mjs';
+export { partialRight } from './function/partialRight.mjs';
+export { rearg } from './function/rearg.mjs';
+export { rest } from './function/rest.mjs';
+export { spread } from './function/spread.mjs';
+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 { 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';
+export { range } from './math/range.mjs';
+export { rangeRight } from './math/rangeRight.mjs';
+export { round } from './math/round.mjs';
+export { subtract } from './math/subtract.mjs';
+export { sum } from './math/sum.mjs';
+export { sumBy } from './math/sumBy.mjs';
+export { assign } from './object/assign.mjs';
+export { assignIn, assignIn as extend } from './object/assignIn.mjs';
+export { assignInWith, assignInWith as extendWith } from './object/assignInWith.mjs';
+export { assignWith } from './object/assignWith.mjs';
+export { at } from './object/at.mjs';
+export { cloneDeep } from './object/cloneDeep.mjs';
+export { cloneDeepWith } from './object/cloneDeepWith.mjs';
+export { create } from './object/create.mjs';
+export { defaults } from './object/defaults.mjs';
+export { findKey } from './object/findKey.mjs';
+export { forIn } from './object/forIn.mjs';
+export { forInRight } from './object/forInRight.mjs';
+export { forOwn } from './object/forOwn.mjs';
+export { forOwnRight } from './object/forOwnRight.mjs';
+export { fromPairs } from './object/fromPairs.mjs';
+export { functions } from './object/functions.mjs';
+export { functionsIn } from './object/functionsIn.mjs';
+export { get } from './object/get.mjs';
+export { has } from './object/has.mjs';
+export { hasIn } from './object/hasIn.mjs';
+export { invertBy } from './object/invertBy.mjs';
+export { keys } from './object/keys.mjs';
+export { keysIn } from './object/keysIn.mjs';
+export { mapKeys } from './object/mapKeys.mjs';
+export { mapValues } from './object/mapValues.mjs';
+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 { toPairs } from './object/toPairs.mjs';
+export { toPairsIn } from './object/toPairsIn.mjs';
+export { unset } from './object/unset.mjs';
+export { update } from './object/update.mjs';
+export { updateWith } from './object/updateWith.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';
+export { isArray } from './predicate/isArray.mjs';
+export { isArrayBuffer } from './predicate/isArrayBuffer.mjs';
+export { isArrayLike } from './predicate/isArrayLike.mjs';
+export { isArrayLikeObject } from './predicate/isArrayLikeObject.mjs';
+export { isBoolean } from './predicate/isBoolean.mjs';
+export { isBuffer } from './predicate/isBuffer.mjs';
+export { isDate } from './predicate/isDate.mjs';
+export { isElement } from './predicate/isElement.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';
+export { isInteger } from './predicate/isInteger.mjs';
+export { isMap } from './predicate/isMap.mjs';
+export { isMatch } from './predicate/isMatch.mjs';
+export { isNaN } from './predicate/isNaN.mjs';
+export { isNil } from './predicate/isNil.mjs';
+export { isNumber } from './predicate/isNumber.mjs';
+export { isObject } from './predicate/isObject.mjs';
+export { isObjectLike } from './predicate/isObjectLike.mjs';
+export { isPlainObject } from './predicate/isPlainObject.mjs';
+export { isRegExp } from './predicate/isRegExp.mjs';
+export { isSafeInteger } from './predicate/isSafeInteger.mjs';
+export { isSet } from './predicate/isSet.mjs';
+export { isString } from './predicate/isString.mjs';
+export { isSymbol } from './predicate/isSymbol.mjs';
+export { isTypedArray } from './predicate/isTypedArray.mjs';
+export { isWeakMap } from './predicate/isWeakMap.mjs';
+export { isWeakSet } from './predicate/isWeakSet.mjs';
+export { matches } from './predicate/matches.mjs';
+export { matchesProperty } from './predicate/matchesProperty.mjs';
+export { camelCase } from './string/camelCase.mjs';
+export { deburr } from './string/deburr.mjs';
+export { endsWith } from './string/endsWith.mjs';
+export { escape } from './string/escape.mjs';
+export { escapeRegExp } from './string/escapeRegExp.mjs';
+export { kebabCase } from './string/kebabCase.mjs';
+export { lowerCase } from './string/lowerCase.mjs';
+export { lowerFirst } from './string/lowerFirst.mjs';
+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 { split } from './string/split.mjs';
+export { startCase } from './string/startCase.mjs';
+export { startsWith } from './string/startsWith.mjs';
+export { template, templateSettings } from './string/template.mjs';
+export { toLower } from './string/toLower.mjs';
+export { toUpper } from './string/toUpper.mjs';
+export { trim } from './string/trim.mjs';
+export { trimEnd } from './string/trimEnd.mjs';
+export { trimStart } from './string/trimStart.mjs';
+export { unescape } from './string/unescape.mjs';
+export { upperCase } from './string/upperCase.mjs';
+export { upperFirst } from './string/upperFirst.mjs';
+export { words } from './string/words.mjs';
+export { cond } from './util/cond.mjs';
+export { constant } from './util/constant.mjs';
+export { defaultTo } from './util/defaultTo.mjs';
+export { eq } from './util/eq.mjs';
+export { gt } from './util/gt.mjs';
+export { gte } from './util/gte.mjs';
+export { invoke } from './util/invoke.mjs';
+export { iteratee } from './util/iteratee.mjs';
+export { lt } from './util/lt.mjs';
+export { lte } from './util/lte.mjs';
+export { method } from './util/method.mjs';
+export { methodOf } from './util/methodOf.mjs';
+export { now } from './util/now.mjs';
+export { over } from './util/over.mjs';
+export { overEvery } from './util/overEvery.mjs';
+export { overSome } from './util/overSome.mjs';
+export { stubArray } from './util/stubArray.mjs';
+export { stubFalse } from './util/stubFalse.mjs';
+export { stubObject } from './util/stubObject.mjs';
+export { stubString } from './util/stubString.mjs';
+export { stubTrue } from './util/stubTrue.mjs';
+export { times } from './util/times.mjs';
+export { toArray } from './util/toArray.mjs';
+export { toFinite } from './util/toFinite.mjs';
+export { toInteger } from './util/toInteger.mjs';
+export { toLength } from './util/toLength.mjs';
+export { toNumber } from './util/toNumber.mjs';
+export { toPath } from './util/toPath.mjs';
+export { toPlainObject } from './util/toPlainObject.mjs';
+export { toSafeInteger } from './util/toSafeInteger.mjs';
+export { toString } from './util/toString.mjs';
+export { uniqueId } from './util/uniqueId.mjs';