es-toolkit 1.24.0 → 1.25.0

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

@@ -0,0 +1,25 @@
+/**
+ * Returns the last element of an array.
+ *
+ * This function takes an array and returns the last element of the array.
+ * If the array is empty, the function returns `undefined`.
+ *
+ * Unlike some implementations, this function is optimized for performance
+ * by directly accessing the last index of the array.
+ *
+ * @template T - The type of elements in the array.
+ * @param {ArrayLike<T> | null | undefined} arr - The array from which to get the last element.
+ * @returns {T | undefined} The last element of the array, or `undefined` if the array is empty.
+ *
+ * @example
+ * const arr = [1, 2, 3];
+ * const lastElement = last(arr);
+ * // lastElement will be 3
+ *
+ * const emptyArr: number[] = [];
+ * const noElement = last(emptyArr);
+ * // noElement will be undefined
+ */
+declare function last<T>(array: ArrayLike<T> | null | undefined): T | undefined;
+
+export { last };

package/dist/compat/array/last.mjs

@@ -0,0 +1,11 @@
+import { last as last$1 } from '../../array/last.mjs';
+import { isArrayLike } from '../predicate/isArrayLike.mjs';
+
+function last(array) {
+    if (!isArrayLike(array)) {
+        return undefined;
+    }
+    return last$1(Array.from(array));
+}
+
+export { last };

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

@@ -0,0 +1,80 @@
+/**
+ * Returns a random element from an array.
+ *
+ * @template T
+ * @param {T[]} array - The array to sample from.
+ * @returns {T | undefined} A random element from the array, or `undefined` if the array is empty.
+ *
+ * @example
+ * const array = [1, 2, 3];
+ * const result = sample(array);
+ * console.log(result); // Output: 1, 2, or 3 (randomly selected)
+ */
+declare function sample<T>(array: readonly T[]): T | undefined;
+/**
+ * Returns a random character from a string.
+ *
+ * @param {string} str - The string to sample from.
+ * @returns {string | undefined} A random character from the string, or `undefined` if the string is empty.
+ *
+ * @example
+ * const str = "hello";
+ * const result = sample(str);
+ * console.log(result); // Output: 'h', 'e', 'l', 'l', or 'o' (randomly selected)
+ */
+declare function sample(str: string): string | undefined;
+/**
+ * Returns a random element from an array.
+ *
+ * @template T
+ * @param {ArrayLike<T>} array - The array-like object to sample from.
+ * @returns {T | undefined} A random element from the array, or `undefined` if the array is empty.
+ *
+ * @example
+ * const arrayLike: ArrayLike<string> = { 0: 'a', 1: 'b', 2: 'c', length: 3 };
+ * const result = sample(arrayLike);
+ * console.log(result); // Output: 'a', 'b', or 'c' (randomly selected)
+ */
+declare function sample<T>(array: ArrayLike<T>): T | undefined;
+/**
+ * Returns a random value from an object.
+ *
+ * @template T - The type of values in the object.
+ * @param {Record<string, T>} obj - The object to sample from.
+ * @returns {T | undefined} A random value from the object, or `undefined` if the object is empty.
+ *
+ * @example
+ * const obj = { a: 1, b: 2, c: 3 };
+ * const result = sample(obj);
+ * console.log(result); // Output: 1, 2, or 3 (randomly selected)
+ */
+declare function sample<T>(obj: Record<string, T>): T | undefined;
+/**
+ * Returns a random element from an array-like object or a regular object.
+ *
+ * This function takes an array-like object (such as an array or string) or a regular object,
+ * and returns a randomly selected element or value. If the collection is empty or invalid, it returns `undefined`.
+ *
+ * @template T - The type of elements in the collection.
+ * @param {ArrayLike<T> | Record<string, T>} collection - The collection to sample from.
+ * @returns {T | string | undefined} A random element from the collection, or `undefined` if the collection is empty or invalid.
+ *
+ * @example
+ * // Array example
+ * const array = [1, 2, 3];
+ * const result = sample(array);
+ * console.log(result); // Output: 1, 2, or 3 (randomly selected)
+ *
+ * // String example
+ * const str = 'abc';
+ * const result2 = sample(str);
+ * console.log(result2); // Output: 'a', 'b', or 'c' (randomly selected)
+ *
+ * // Object example
+ * const obj = { a: 1, b: 2, c: 3 };
+ * const result3 = sample(obj);
+ * console.log(result3); // Output: 1, 2, or 3 (randomly selected)
+ */
+declare function sample<T>(collection: ArrayLike<T> | Record<string, T>): T | string | undefined;
+
+export { sample };

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

@@ -0,0 +1,80 @@
+/**
+ * Returns a random element from an array.
+ *
+ * @template T
+ * @param {T[]} array - The array to sample from.
+ * @returns {T | undefined} A random element from the array, or `undefined` if the array is empty.
+ *
+ * @example
+ * const array = [1, 2, 3];
+ * const result = sample(array);
+ * console.log(result); // Output: 1, 2, or 3 (randomly selected)
+ */
+declare function sample<T>(array: readonly T[]): T | undefined;
+/**
+ * Returns a random character from a string.
+ *
+ * @param {string} str - The string to sample from.
+ * @returns {string | undefined} A random character from the string, or `undefined` if the string is empty.
+ *
+ * @example
+ * const str = "hello";
+ * const result = sample(str);
+ * console.log(result); // Output: 'h', 'e', 'l', 'l', or 'o' (randomly selected)
+ */
+declare function sample(str: string): string | undefined;
+/**
+ * Returns a random element from an array.
+ *
+ * @template T
+ * @param {ArrayLike<T>} array - The array-like object to sample from.
+ * @returns {T | undefined} A random element from the array, or `undefined` if the array is empty.
+ *
+ * @example
+ * const arrayLike: ArrayLike<string> = { 0: 'a', 1: 'b', 2: 'c', length: 3 };
+ * const result = sample(arrayLike);
+ * console.log(result); // Output: 'a', 'b', or 'c' (randomly selected)
+ */
+declare function sample<T>(array: ArrayLike<T>): T | undefined;
+/**
+ * Returns a random value from an object.
+ *
+ * @template T - The type of values in the object.
+ * @param {Record<string, T>} obj - The object to sample from.
+ * @returns {T | undefined} A random value from the object, or `undefined` if the object is empty.
+ *
+ * @example
+ * const obj = { a: 1, b: 2, c: 3 };
+ * const result = sample(obj);
+ * console.log(result); // Output: 1, 2, or 3 (randomly selected)
+ */
+declare function sample<T>(obj: Record<string, T>): T | undefined;
+/**
+ * Returns a random element from an array-like object or a regular object.
+ *
+ * This function takes an array-like object (such as an array or string) or a regular object,
+ * and returns a randomly selected element or value. If the collection is empty or invalid, it returns `undefined`.
+ *
+ * @template T - The type of elements in the collection.
+ * @param {ArrayLike<T> | Record<string, T>} collection - The collection to sample from.
+ * @returns {T | string | undefined} A random element from the collection, or `undefined` if the collection is empty or invalid.
+ *
+ * @example
+ * // Array example
+ * const array = [1, 2, 3];
+ * const result = sample(array);
+ * console.log(result); // Output: 1, 2, or 3 (randomly selected)
+ *
+ * // String example
+ * const str = 'abc';
+ * const result2 = sample(str);
+ * console.log(result2); // Output: 'a', 'b', or 'c' (randomly selected)
+ *
+ * // Object example
+ * const obj = { a: 1, b: 2, c: 3 };
+ * const result3 = sample(obj);
+ * console.log(result3); // Output: 1, 2, or 3 (randomly selected)
+ */
+declare function sample<T>(collection: ArrayLike<T> | Record<string, T>): T | string | undefined;
+
+export { sample };

package/dist/compat/array/sample.mjs

@@ -0,0 +1,14 @@
+import { sample as sample$1 } from '../../array/sample.mjs';
+import { isArrayLike } from '../predicate/isArrayLike.mjs';
+
+function sample(collection) {
+    if (collection == null) {
+        return undefined;
+    }
+    if (isArrayLike(collection)) {
+        return sample$1(Array.from(collection));
+    }
+    return sample$1(Object.values(collection));
+}
+
+export { sample };

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

@@ -0,0 +1,27 @@
+/**
+ * Returns a new array with all elements except for the first.
+ *
+ * This function takes an array and returns a new array containing all the elements
+ * except for the first one. If the input array is empty or has only one element,
+ * an empty array is returned.
+ *
+ * @template T - The type of elements in the array.
+ * @param {ArrayLike<T> | null | undefined} arr - The array to get the tail of.
+ * @returns {T[]} A new array containing all elements of the input array except for the first one.
+ *
+ * @example
+ * const arr1 = [1, 2, 3];
+ * const result = tail(arr1);
+ * // result will be [2, 3]
+ *
+ * const arr2 = [1];
+ * const result2 = tail(arr2);
+ * // result2 will be []
+ *
+ * const arr3 = [];
+ * const result3 = tail(arr3);
+ * // result3 will be []
+ */
+declare function tail<T>(arr: ArrayLike<T> | null | undefined): T[];
+
+export { tail };

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

@@ -0,0 +1,27 @@
+/**
+ * Returns a new array with all elements except for the first.
+ *
+ * This function takes an array and returns a new array containing all the elements
+ * except for the first one. If the input array is empty or has only one element,
+ * an empty array is returned.
+ *
+ * @template T - The type of elements in the array.
+ * @param {ArrayLike<T> | null | undefined} arr - The array to get the tail of.
+ * @returns {T[]} A new array containing all elements of the input array except for the first one.
+ *
+ * @example
+ * const arr1 = [1, 2, 3];
+ * const result = tail(arr1);
+ * // result will be [2, 3]
+ *
+ * const arr2 = [1];
+ * const result2 = tail(arr2);
+ * // result2 will be []
+ *
+ * const arr3 = [];
+ * const result3 = tail(arr3);
+ * // result3 will be []
+ */
+declare function tail<T>(arr: ArrayLike<T> | null | undefined): T[];
+
+export { tail };

package/dist/compat/array/tail.mjs

@@ -0,0 +1,11 @@
+import { tail as tail$1 } from '../../array/tail.mjs';
+import { isArrayLike } from '../predicate/isArrayLike.mjs';
+
+function tail(arr) {
+    if (!isArrayLike(arr)) {
+        return [];
+    }
+    return tail$1(Array.from(arr));
+}
+
+export { tail };

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

@@ -4,8 +4,8 @@
  *
  * @template T - Type of elements in the input array.
  *
- * @param {T[]} arr - The array to take elements from.
- * @param {number} count - The number of elements to take.
+ * @param {ArrayLike<T> | null | undefined} arr - The array to take elements from.
+ * @param {number} [count=1] - The number of elements to take.
  * @returns {T[]} A new array containing the first `count` elements from `arr`.
  *
  * @example
@@ -20,6 +20,6 @@
  * // Returns [1, 2, 3]
  * take([1, 2, 3], 5);
  */
-declare function take<T>(arr: readonly T[], count: number): T[];
+declare function take<T>(arr: ArrayLike<T> | null | undefined, count?: number): T[];
 
 export { take };

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

@@ -4,8 +4,8 @@
  *
  * @template T - Type of elements in the input array.
  *
- * @param {T[]} arr - The array to take elements from.
- * @param {number} count - The number of elements to take.
+ * @param {ArrayLike<T> | null | undefined} arr - The array to take elements from.
+ * @param {number} [count=1] - The number of elements to take.
  * @returns {T[]} A new array containing the first `count` elements from `arr`.
  *
  * @example
@@ -20,6 +20,6 @@
  * // Returns [1, 2, 3]
  * take([1, 2, 3], 5);
  */
-declare function take<T>(arr: readonly T[], count: number): T[];
+declare function take<T>(arr: ArrayLike<T> | null | undefined, count?: number): T[];
 
 export { take };

package/dist/compat/array/take.mjs

@@ -1,10 +1,11 @@
 import { take as take$1 } from '../../array/take.mjs';
+import { isArrayLike } from '../predicate/isArrayLike.mjs';
 
-function take(arr, count) {
-    if (count < 1) {
+function take(arr, count = 1) {
+    if (count < 1 || !isArrayLike(arr)) {
         return [];
     }
-    return take$1(arr, count);
+    return take$1(Array.from(arr), count);
 }
 
 export { take };

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

@@ -0,0 +1,24 @@
+/**
+ * Returns a new array containing the last `count` elements from the input array `arr`.
+ * If `count` is greater than the length of `arr`, the entire array is returned.
+ *
+ * @template T - The type of elements in the array.
+ * @param {ArrayLike<T> | null | undefined} arr - The array to take elements from.
+ * @param {number} [count=1] - The number of elements to take.
+ * @returns {T[]} A new array containing the last `count` elements from `arr`.
+ *
+ * @example
+ * // Returns [4, 5]
+ * takeRight([1, 2, 3, 4, 5], 2);
+ *
+ * @example
+ * // Returns ['b', 'c']
+ * takeRight(['a', 'b', 'c'], 2);
+ *
+ * @example
+ * // Returns [1, 2, 3]
+ * takeRight([1, 2, 3], 5);
+ */
+declare function takeRight<T>(arr: ArrayLike<T> | null | undefined, count?: number): T[];
+
+export { takeRight };

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

@@ -0,0 +1,24 @@
+/**
+ * Returns a new array containing the last `count` elements from the input array `arr`.
+ * If `count` is greater than the length of `arr`, the entire array is returned.
+ *
+ * @template T - The type of elements in the array.
+ * @param {ArrayLike<T> | null | undefined} arr - The array to take elements from.
+ * @param {number} [count=1] - The number of elements to take.
+ * @returns {T[]} A new array containing the last `count` elements from `arr`.
+ *
+ * @example
+ * // Returns [4, 5]
+ * takeRight([1, 2, 3, 4, 5], 2);
+ *
+ * @example
+ * // Returns ['b', 'c']
+ * takeRight(['a', 'b', 'c'], 2);
+ *
+ * @example
+ * // Returns [1, 2, 3]
+ * takeRight([1, 2, 3], 5);
+ */
+declare function takeRight<T>(arr: ArrayLike<T> | null | undefined, count?: number): T[];
+
+export { takeRight };

package/dist/compat/array/takeRight.mjs

@@ -0,0 +1,11 @@
+import { takeRight as takeRight$1 } from '../../array/takeRight.mjs';
+import { isArrayLike } from '../predicate/isArrayLike.mjs';
+
+function takeRight(arr, count = 1) {
+    if (count <= 0 || !isArrayLike(arr)) {
+        return [];
+    }
+    return takeRight$1(Array.from(arr), count);
+}
+
+export { takeRight };

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

@@ -0,0 +1,18 @@
+/**
+ * Creates a duplicate-free version of an array.
+ *
+ * This function takes an array and returns a new array containing only the unique values
+ * from the original array, preserving the order of first occurrence.
+ *
+ * @template T - The type of elements in the array.
+ * @param {ArrayLike<T> | null | undefined} arr - The array to process.
+ * @returns {T[]} A new array with only unique values from the original array.
+ *
+ * @example
+ * const array = [1, 2, 2, 3, 4, 4, 5];
+ * const result = uniq(array);
+ * // result will be [1, 2, 3, 4, 5]
+ */
+declare function uniq<T>(arr: ArrayLike<T> | null | undefined): T[];
+
+export { uniq };

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

@@ -0,0 +1,18 @@
+/**
+ * Creates a duplicate-free version of an array.
+ *
+ * This function takes an array and returns a new array containing only the unique values
+ * from the original array, preserving the order of first occurrence.
+ *
+ * @template T - The type of elements in the array.
+ * @param {ArrayLike<T> | null | undefined} arr - The array to process.
+ * @returns {T[]} A new array with only unique values from the original array.
+ *
+ * @example
+ * const array = [1, 2, 2, 3, 4, 4, 5];
+ * const result = uniq(array);
+ * // result will be [1, 2, 3, 4, 5]
+ */
+declare function uniq<T>(arr: ArrayLike<T> | null | undefined): T[];
+
+export { uniq };

package/dist/compat/array/uniq.mjs

@@ -0,0 +1,11 @@
+import { uniq as uniq$1 } from '../../array/uniq.mjs';
+import { isArrayLike } from '../predicate/isArrayLike.mjs';
+
+function uniq(arr) {
+    if (!isArrayLike(arr)) {
+        return [];
+    }
+    return uniq$1(Array.from(arr));
+}
+
+export { uniq };

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

@@ -0,0 +1,23 @@
+/**
+ * Creates an array that excludes all specified values.
+ *
+ * It correctly excludes `NaN`, as it compares values using [SameValueZero](https://tc39.es/ecma262/multipage/abstract-operations.html#sec-samevaluezero).
+ *
+ * @template T The type of elements in the array.
+ * @param {ArrayLike<T> | null | undefined} array - The array to filter.
+ * @param {...T[]} values - The values to exclude.
+ * @returns {T[]} A new array without the specified values.
+ *
+ * @example
+ * // Removes the specified values from the array
+ * without([1, 2, 3, 4, 5], 2, 4);
+ * // Returns: [1, 3, 5]
+ *
+ * @example
+ * // Removes specified string values from the array
+ * without(['a', 'b', 'c', 'a'], 'a');
+ * // Returns: ['b', 'c']
+ */
+declare function without<T>(array: ArrayLike<T> | null | undefined, ...values: T[]): T[];
+
+export { without };

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

@@ -0,0 +1,23 @@
+/**
+ * Creates an array that excludes all specified values.
+ *
+ * It correctly excludes `NaN`, as it compares values using [SameValueZero](https://tc39.es/ecma262/multipage/abstract-operations.html#sec-samevaluezero).
+ *
+ * @template T The type of elements in the array.
+ * @param {ArrayLike<T> | null | undefined} array - The array to filter.
+ * @param {...T[]} values - The values to exclude.
+ * @returns {T[]} A new array without the specified values.
+ *
+ * @example
+ * // Removes the specified values from the array
+ * without([1, 2, 3, 4, 5], 2, 4);
+ * // Returns: [1, 3, 5]
+ *
+ * @example
+ * // Removes specified string values from the array
+ * without(['a', 'b', 'c', 'a'], 'a');
+ * // Returns: ['b', 'c']
+ */
+declare function without<T>(array: ArrayLike<T> | null | undefined, ...values: T[]): T[];
+
+export { without };

package/dist/compat/array/without.mjs

@@ -0,0 +1,11 @@
+import { without as without$1 } from '../../array/without.mjs';
+import { isArrayLikeObject } from '../predicate/isArrayLikeObject.mjs';
+
+function without(array, ...values) {
+    if (!isArrayLikeObject(array)) {
+        return [];
+    }
+    return without$1(Array.from(array), ...values);
+}
+
+export { without };

package/dist/compat/index.d.mts

@@ -1,42 +1,32 @@
 export { at } from '../array/at.mjs';
-export { compact } from '../array/compact.mjs';
 export { countBy } from '../array/countBy.mjs';
 export { differenceBy } from '../array/differenceBy.mjs';
 export { differenceWith } from '../array/differenceWith.mjs';
-export { dropRight } from '../array/dropRight.mjs';
 export { flatMap } from '../array/flatMap.mjs';
 export { flatMapDeep } from '../array/flatMapDeep.mjs';
 export { forEachRight } from '../array/forEachRight.mjs';
 export { groupBy } from '../array/groupBy.mjs';
-export { head as first, head } from '../array/head.mjs';
 export { initial } from '../array/initial.mjs';
-export { intersection } from '../array/intersection.mjs';
 export { intersectionBy } from '../array/intersectionBy.mjs';
 export { intersectionWith } from '../array/intersectionWith.mjs';
 export { isSubset } from '../array/isSubset.mjs';
 export { keyBy } from '../array/keyBy.mjs';
-export { last } from '../array/last.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';
-export { sample } from '../array/sample.mjs';
 export { sampleSize } from '../array/sampleSize.mjs';
 export { shuffle } from '../array/shuffle.mjs';
-export { tail } from '../array/tail.mjs';
-export { takeRight } from '../array/takeRight.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 { uniq } from '../array/uniq.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 { without } from '../array/without.mjs';
 export { xor } from '../array/xor.mjs';
 export { xorBy } from '../array/xorBy.mjs';
 export { xorWith } from '../array/xorWith.mjs';
@@ -68,6 +58,7 @@ 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 { isFile } from '../predicate/isFile.mjs';
 export { isFunction } from '../predicate/isFunction.mjs';
 export { isJSONArray } from '../predicate/isJSONArray.mjs';
 export { isJSONObject } from '../predicate/isJSONObject.mjs';
@@ -83,7 +74,6 @@ export { withTimeout } from '../promise/withTimeout.mjs';
 export { capitalize } from '../string/capitalize.mjs';
 export { constantCase } from '../string/constantCase.mjs';
 export { deburr } from '../string/deburr.mjs';
-export { escape } from '../string/escape.mjs';
 export { escapeRegExp } from '../string/escapeRegExp.mjs';
 export { lowerFirst } from '../string/lowerFirst.mjs';
 export { pascalCase } from '../string/pascalCase.mjs';
@@ -91,9 +81,11 @@ export { unescape } from '../string/unescape.mjs';
 export { upperFirst } from '../string/upperFirst.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 { 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';
@@ -105,15 +97,23 @@ 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 { 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 { join } from './array/join.mjs';
+export { last } from './array/last.mjs';
 export { orderBy } from './array/orderBy.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 { tail } from './array/tail.mjs';
 export { take } from './array/take.mjs';
+export { takeRight } from './array/takeRight.mjs';
+export { uniq } from './array/uniq.mjs';
+export { without } from './array/without.mjs';
 export { zipObjectDeep } from './array/zipObjectDeep.mjs';
 export { ary } from './function/ary.mjs';
 export { attempt } from './function/attempt.mjs';
@@ -189,6 +189,7 @@ export { matches } from './predicate/matches.mjs';
 export { matchesProperty } from './predicate/matchesProperty.mjs';
 export { camelCase } from './string/camelCase.mjs';
 export { endsWith } from './string/endsWith.mjs';
+export { escape } from './string/escape.mjs';
 export { kebabCase } from './string/kebabCase.mjs';
 export { lowerCase } from './string/lowerCase.mjs';
 export { pad } from './string/pad.mjs';
@@ -211,4 +212,5 @@ 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 { toSafeInteger } from './util/toSafeInteger.mjs';
 export { toString } from './util/toString.mjs';