es-toolkit 1.27.0 → 1.28.0-dev.908

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

@@ -0,0 +1,103 @@
+/**
+ * Assigns the properties of a source object to a target object.
+ *
+ * This function merges the properties of the source object into the target object,
+ * including properties from the prototype chain. If a property in the source object
+ * is equal to the corresponding property in the target object, it will not be overwritten.
+ *
+ * @param {O} object - The target object to which properties will be assigned.
+ * @param {S} source - The source object whose properties will be assigned to the target object.
+ * @returns {O & S} The updated target object with properties from the source object assigned.
+ *
+ * @example
+ * const target = { a: 1, b: 2 };
+ * const source = { b: 3, c: 4 };
+ * const result = assignIn(target, source);
+ * console.log(result); // Output: { a: 1, b: 3, c: 4 }
+ */
+declare function assignIn<O, S>(object: O, source: S): O & S;
+/**
+ * Assigns the properties of two source objects to a target object.
+ *
+ * This function merges the properties of the source objects into the target object,
+ * including properties from the prototype chain. If a property in the source objects
+ * is equal to the corresponding property in the target object, it will not be overwritten.
+ *
+ * @param {O} object - The target object to which properties will be assigned.
+ * @param {S1} source1 - The first source object whose properties will be assigned to the target object.
+ * @param {S2} source2 - The second source object whose properties will be assigned to the target object.
+ * @returns {O & S1 & S2} The updated target object with properties from the source objects assigned.
+ *
+ * @example
+ * const target = { a: 1 };
+ * const source1 = { b: 2 };
+ * const source2 = { c: 3 };
+ * const result = assignIn(target, source1, source2);
+ * console.log(result); // Output: { a: 1, b: 2, c: 3 }
+ */
+declare function assignIn<O, S1, S2>(object: O, source1: S1, source2: S2): O & S1 & S2;
+/**
+ * Assigns the properties of three source objects to a target object.
+ *
+ * This function merges the properties of the source objects into the target object,
+ * including properties from the prototype chain. If a property in the source objects
+ * is equal to the corresponding property in the target object, it will not be overwritten.
+ *
+ * @param {O} object - The target object to which properties will be assigned.
+ * @param {S1} source1 - The first source object whose properties will be assigned to the target object.
+ * @param {S2} source2 - The second source object whose properties will be assigned to the target object.
+ * @param {S3} source3 - The third source object whose properties will be assigned to the target object.
+ * @returns {O & S1 & S2 & S3} The updated target object with properties from the source objects assigned.
+ *
+ * @example
+ * const target = { a: 1 };
+ * const source1 = { b: 2 };
+ * const source2 = { c: 3 };
+ * const source3 = { d: 4 };
+ * const result = assignIn(target, source1, source2, source3);
+ * console.log(result); // Output: { a: 1, b: 2, c: 3, d: 4 }
+ */
+declare function assignIn<O, S1, S2, S3>(object: O, source1: S1, source2: S2, source3: S3): O & S1 & S2 & S3;
+/**
+ * Assigns the properties of four source objects to a target object.
+ *
+ * This function merges the properties of the source objects into the target object,
+ * including properties from the prototype chain. If a property in the source objects
+ * is equal to the corresponding property in the target object, it will not be overwritten.
+ *
+ * @param {O} object - The target object to which properties will be assigned.
+ * @param {S1} source1 - The first source object whose properties will be assigned to the target object.
+ * @param {S2} source2 - The second source object whose properties will be assigned to the target object.
+ * @param {S3} source3 - The third source object whose properties will be assigned to the target object.
+ * @param {S4} source4 - The fourth source object whose properties will be assigned to the target object.
+ * @returns {O & S1 & S2 & S3} The updated target object with properties from the source objects assigned.
+ *
+ * @example
+ * const target = { a: 1 };
+ * const source1 = { b: 2 };
+ * const source2 = { c: 3 };
+ * const source3 = { d: 4 };
+ * const source4 = { e: 5 };
+ * const result = assignIn(target, source1, source2, source3, source4);
+ * console.log(result); // Output: { a: 1, b: 2, c: 3, d: 4, e: 5 }
+ */
+declare function assignIn<O, S1, S2, S3, S4>(object: O, source1: S1, source2: S2, source3: S3, source4: S4): O & S1 & S2 & S3;
+/**
+ * Assigns properties from multiple source objects to a target object.
+ *
+ * This function merges the properties of the source objects into the target object,
+ * including properties from the prototype chain. If a property in the source objects
+ * is equal to the corresponding property in the target object, it will not be overwritten.
+ *
+ * @param {any} object - The target object to which properties will be assigned.
+ * @param {...any[]} sources - The source objects whose properties will be assigned to the target object.
+ * @returns {any} The updated target object with properties from the source objects assigned.
+ *
+ * @example
+ * const target = { a: 1 };
+ * const result = assignIn(target, { b: 2 }, { c: 3 }, { a: 4 });
+ * console.log(result); // Output: { a: 1, b: 2, c: 3 }
+ */
+declare function assignIn(object: any, ...sources: any[]): any;
+
+export { assignIn };

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

@@ -0,0 +1,103 @@
+/**
+ * Assigns the properties of a source object to a target object.
+ *
+ * This function merges the properties of the source object into the target object,
+ * including properties from the prototype chain. If a property in the source object
+ * is equal to the corresponding property in the target object, it will not be overwritten.
+ *
+ * @param {O} object - The target object to which properties will be assigned.
+ * @param {S} source - The source object whose properties will be assigned to the target object.
+ * @returns {O & S} The updated target object with properties from the source object assigned.
+ *
+ * @example
+ * const target = { a: 1, b: 2 };
+ * const source = { b: 3, c: 4 };
+ * const result = assignIn(target, source);
+ * console.log(result); // Output: { a: 1, b: 3, c: 4 }
+ */
+declare function assignIn<O, S>(object: O, source: S): O & S;
+/**
+ * Assigns the properties of two source objects to a target object.
+ *
+ * This function merges the properties of the source objects into the target object,
+ * including properties from the prototype chain. If a property in the source objects
+ * is equal to the corresponding property in the target object, it will not be overwritten.
+ *
+ * @param {O} object - The target object to which properties will be assigned.
+ * @param {S1} source1 - The first source object whose properties will be assigned to the target object.
+ * @param {S2} source2 - The second source object whose properties will be assigned to the target object.
+ * @returns {O & S1 & S2} The updated target object with properties from the source objects assigned.
+ *
+ * @example
+ * const target = { a: 1 };
+ * const source1 = { b: 2 };
+ * const source2 = { c: 3 };
+ * const result = assignIn(target, source1, source2);
+ * console.log(result); // Output: { a: 1, b: 2, c: 3 }
+ */
+declare function assignIn<O, S1, S2>(object: O, source1: S1, source2: S2): O & S1 & S2;
+/**
+ * Assigns the properties of three source objects to a target object.
+ *
+ * This function merges the properties of the source objects into the target object,
+ * including properties from the prototype chain. If a property in the source objects
+ * is equal to the corresponding property in the target object, it will not be overwritten.
+ *
+ * @param {O} object - The target object to which properties will be assigned.
+ * @param {S1} source1 - The first source object whose properties will be assigned to the target object.
+ * @param {S2} source2 - The second source object whose properties will be assigned to the target object.
+ * @param {S3} source3 - The third source object whose properties will be assigned to the target object.
+ * @returns {O & S1 & S2 & S3} The updated target object with properties from the source objects assigned.
+ *
+ * @example
+ * const target = { a: 1 };
+ * const source1 = { b: 2 };
+ * const source2 = { c: 3 };
+ * const source3 = { d: 4 };
+ * const result = assignIn(target, source1, source2, source3);
+ * console.log(result); // Output: { a: 1, b: 2, c: 3, d: 4 }
+ */
+declare function assignIn<O, S1, S2, S3>(object: O, source1: S1, source2: S2, source3: S3): O & S1 & S2 & S3;
+/**
+ * Assigns the properties of four source objects to a target object.
+ *
+ * This function merges the properties of the source objects into the target object,
+ * including properties from the prototype chain. If a property in the source objects
+ * is equal to the corresponding property in the target object, it will not be overwritten.
+ *
+ * @param {O} object - The target object to which properties will be assigned.
+ * @param {S1} source1 - The first source object whose properties will be assigned to the target object.
+ * @param {S2} source2 - The second source object whose properties will be assigned to the target object.
+ * @param {S3} source3 - The third source object whose properties will be assigned to the target object.
+ * @param {S4} source4 - The fourth source object whose properties will be assigned to the target object.
+ * @returns {O & S1 & S2 & S3} The updated target object with properties from the source objects assigned.
+ *
+ * @example
+ * const target = { a: 1 };
+ * const source1 = { b: 2 };
+ * const source2 = { c: 3 };
+ * const source3 = { d: 4 };
+ * const source4 = { e: 5 };
+ * const result = assignIn(target, source1, source2, source3, source4);
+ * console.log(result); // Output: { a: 1, b: 2, c: 3, d: 4, e: 5 }
+ */
+declare function assignIn<O, S1, S2, S3, S4>(object: O, source1: S1, source2: S2, source3: S3, source4: S4): O & S1 & S2 & S3;
+/**
+ * Assigns properties from multiple source objects to a target object.
+ *
+ * This function merges the properties of the source objects into the target object,
+ * including properties from the prototype chain. If a property in the source objects
+ * is equal to the corresponding property in the target object, it will not be overwritten.
+ *
+ * @param {any} object - The target object to which properties will be assigned.
+ * @param {...any[]} sources - The source objects whose properties will be assigned to the target object.
+ * @returns {any} The updated target object with properties from the source objects assigned.
+ *
+ * @example
+ * const target = { a: 1 };
+ * const result = assignIn(target, { b: 2 }, { c: 3 }, { a: 4 });
+ * console.log(result); // Output: { a: 1, b: 2, c: 3 }
+ */
+declare function assignIn(object: any, ...sources: any[]): any;
+
+export { assignIn };

package/dist/compat/object/assignIn.mjs

@@ -0,0 +1,20 @@
+import { keysIn } from './keysIn.mjs';
+import { eq } from '../util/eq.mjs';
+
+function assignIn(object, ...sources) {
+    for (let i = 0; i < sources.length; i++) {
+        assignInImpl(object, sources[i]);
+    }
+    return object;
+}
+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])) {
+            object[key] = source[key];
+        }
+    }
+}
+
+export { assignIn };

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

@@ -0,0 +1,26 @@
+/**
+ * This function retrieves the names of string-keyed properties 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 {unknown} [object] - The object to inspect for keys.
+ * @returns {string[]} An array of string keys from the object.
+ *
+ * @example
+ * const obj = { a: 1, b: 2 };
+ * console.log(keysIn(obj)); // ['a', 'b']
+ *
+ * const arr = [1, 2, 3];
+ * console.log(keysIn(arr)); // ['0', '1', '2']
+ *
+ * function Foo() {}
+ * Foo.prototype.a = 1;
+ * console.log(keysIn(new Foo())); // ['a']
+ */
+declare function keysIn(object?: unknown): string[];
+
+export { keysIn };

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

@@ -0,0 +1,26 @@
+/**
+ * This function retrieves the names of string-keyed properties 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 {unknown} [object] - The object to inspect for keys.
+ * @returns {string[]} An array of string keys from the object.
+ *
+ * @example
+ * const obj = { a: 1, b: 2 };
+ * console.log(keysIn(obj)); // ['a', 'b']
+ *
+ * const arr = [1, 2, 3];
+ * console.log(keysIn(arr)); // ['0', '1', '2']
+ *
+ * function Foo() {}
+ * Foo.prototype.a = 1;
+ * console.log(keysIn(new Foo())); // ['a']
+ */
+declare function keysIn(object?: unknown): string[];
+
+export { keysIn };

package/dist/compat/object/keysIn.mjs

@@ -0,0 +1,53 @@
+import { isBuffer } from '../../predicate/isBuffer.mjs';
+import { isPrototype } from '../_internal/isPrototype.mjs';
+import { isArrayLike } from '../predicate/isArrayLike.mjs';
+import { isTypedArray } from '../predicate/isTypedArray.mjs';
+import { times } from '../util/times.mjs';
+
+function keysIn(object) {
+    if (object == null) {
+        return [];
+    }
+    switch (typeof object) {
+        case 'object':
+        case 'function': {
+            if (isArrayLike(object)) {
+                return arrayLikeKeysIn(object);
+            }
+            if (isPrototype(object)) {
+                return prototypeKeysIn(object);
+            }
+            return keysInImpl(object);
+        }
+        default: {
+            return keysInImpl(Object(object));
+        }
+    }
+}
+function keysInImpl(object) {
+    const result = [];
+    for (const key in object) {
+        result.push(key);
+    }
+    return result;
+}
+function prototypeKeysIn(object) {
+    const keys = keysInImpl(object);
+    return keys.filter(key => key !== 'constructor');
+}
+function arrayLikeKeysIn(object) {
+    const indices = times(object.length, index => `${index}`);
+    const filteredKeys = new Set(indices);
+    if (isBuffer(object)) {
+        filteredKeys.add('offset');
+        filteredKeys.add('parent');
+    }
+    if (isTypedArray(object)) {
+        filteredKeys.add('buffer');
+        filteredKeys.add('byteLength');
+        filteredKeys.add('byteOffset');
+    }
+    return [...indices, ...keysInImpl(object).filter(key => !filteredKeys.has(key))];
+}
+
+export { keysIn };

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

@@ -0,0 +1,13 @@
+/**
+ * Checks if `value` is likely a DOM element.
+ *
+ * @param {any} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a DOM element, else `false`.
+ *
+ * @example
+ * console.log(isElement(document.body)); // true
+ * console.log(isElement('<body>')); // false
+ */
+declare function isElement(value: any): boolean;
+
+export { isElement };

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

@@ -0,0 +1,13 @@
+/**
+ * Checks if `value` is likely a DOM element.
+ *
+ * @param {any} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a DOM element, else `false`.
+ *
+ * @example
+ * console.log(isElement(document.body)); // true
+ * console.log(isElement('<body>')); // false
+ */
+declare function isElement(value: any): boolean;
+
+export { isElement };

package/dist/compat/predicate/isElement.mjs

@@ -0,0 +1,8 @@
+import { isObjectLike } from './isObjectLike.mjs';
+import { isPlainObject } from './isPlainObject.mjs';
+
+function isElement(value) {
+    return isObjectLike(value) && value.nodeType === 1 && !isPlainObject(value);
+}
+
+export { isElement };

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

@@ -0,0 +1,20 @@
+/**
+ * Converts `string`, as a whole, to upper case just like
+ * [String#toUpperCase](https://mdn.io/toUpperCase).
+ *
+ * @param {unknown} [value=''] The value to convert.
+ * @returns {string} Returns the upper cased string.
+ * @example
+ *
+ * toUpper('--foo-bar--');
+ * // => '--FOO-BAR--'
+ *
+ * toUpper(null);
+ * // => ''
+ *
+ * toUpper([1, 2, 3]);
+ * // => '1,2,3'
+ */
+declare function toUpper(value?: unknown): string;
+
+export { toUpper };

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

@@ -0,0 +1,20 @@
+/**
+ * Converts `string`, as a whole, to upper case just like
+ * [String#toUpperCase](https://mdn.io/toUpperCase).
+ *
+ * @param {unknown} [value=''] The value to convert.
+ * @returns {string} Returns the upper cased string.
+ * @example
+ *
+ * toUpper('--foo-bar--');
+ * // => '--FOO-BAR--'
+ *
+ * toUpper(null);
+ * // => ''
+ *
+ * toUpper([1, 2, 3]);
+ * // => '1,2,3'
+ */
+declare function toUpper(value?: unknown): string;
+
+export { toUpper };

package/dist/compat/string/toUpper.mjs

@@ -0,0 +1,7 @@
+import { toString } from '../util/toString.mjs';
+
+function toUpper(value) {
+    return toString(value).toUpperCase();
+}
+
+export { toUpper };

package/dist/compat/string/trim.mjs

@@ -13,7 +13,7 @@ function trim(str, chars, guard) {
         }
         case 'object': {
             if (Array.isArray(chars)) {
-                return trim$1(str, chars.map(x => x.toString()));
+                return trim$1(str, chars.flatMap(x => x.toString().split('')));
             }
             else {
                 return trim$1(str, chars.toString().split(''));

package/dist/compat/string/trimEnd.mjs

@@ -13,7 +13,7 @@ function trimEnd(str, chars, guard) {
         }
         case 'object': {
             if (Array.isArray(chars)) {
-                return trimEnd$1(str, chars.map(x => x.toString()));
+                return trimEnd$1(str, chars.flatMap(x => x.toString().split('')));
             }
             else {
                 return trimEnd$1(str, chars.toString().split(''));

package/dist/compat/string/trimStart.mjs

@@ -13,7 +13,7 @@ function trimStart(str, chars, guard) {
         }
         case 'object': {
             if (Array.isArray(chars)) {
-                return trimStart$1(str, chars.map(x => x.toString()));
+                return trimStart$1(str, chars.flatMap(x => x.toString().split('')));
             }
             else {
                 return trimStart$1(str, chars.toString().split(''));

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

@@ -0,0 +1,15 @@
+/**
+ * Splits `string` into an array of its words.
+ *
+ * @param {string | object} str - The string or object that is to be split into words.
+ * @param {RegExp | string} [pattern] - The pattern to match words.
+ * @returns {string[]} - Returns the words of `string`.
+ *
+ * @example
+ * const wordsArray1 = words('fred, barney, & pebbles');
+ * // => ['fred', 'barney', 'pebbles']
+ *
+ */
+declare function words(str?: string | object, pattern?: RegExp | string): string[];
+
+export { words };

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

@@ -0,0 +1,15 @@
+/**
+ * Splits `string` into an array of its words.
+ *
+ * @param {string | object} str - The string or object that is to be split into words.
+ * @param {RegExp | string} [pattern] - The pattern to match words.
+ * @returns {string[]} - Returns the words of `string`.
+ *
+ * @example
+ * const wordsArray1 = words('fred, barney, & pebbles');
+ * // => ['fred', 'barney', 'pebbles']
+ *
+ */
+declare function words(str?: string | object, pattern?: RegExp | string): string[];
+
+export { words };

package/dist/compat/string/words.mjs

@@ -0,0 +1,10 @@
+import { CASE_SPLIT_PATTERN } from '../../string/words.mjs';
+import { toString } from '../util/toString.mjs';
+
+function words(str, pattern = CASE_SPLIT_PATTERN) {
+    const input = toString(str);
+    const words = Array.from(input.match(pattern) ?? []);
+    return words.filter(x => x !== '');
+}
+
+export { words };

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

@@ -0,0 +1,15 @@
+/**
+ * Checks if value is greater than other.
+ *
+ * @param {unknown} value The value to compare.
+ * @param {unknown} other The other value to compare.
+ * @returns {boolean} Returns `true` if value is greater than other, else `false`.
+ *
+ * @example
+ * gt(3, 1); // true
+ * gt(3, 3); // false
+ * gt(1, 3); // false
+ */
+declare function gt(value: unknown, other: unknown): boolean;
+
+export { gt };

package/dist/compat/util/gt.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Checks if value is greater than other.
+ *
+ * @param {unknown} value The value to compare.
+ * @param {unknown} other The other value to compare.
+ * @returns {boolean} Returns `true` if value is greater than other, else `false`.
+ *
+ * @example
+ * gt(3, 1); // true
+ * gt(3, 3); // false
+ * gt(1, 3); // false
+ */
+declare function gt(value: unknown, other: unknown): boolean;
+
+export { gt };

package/dist/compat/util/gt.mjs

@@ -0,0 +1,10 @@
+import { toNumber } from './toNumber.mjs';
+
+function gt(value, other) {
+    if (typeof value === 'string' && typeof other === 'string') {
+        return value > other;
+    }
+    return toNumber(value) > toNumber(other);
+}
+
+export { gt };

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

@@ -0,0 +1,15 @@
+/**
+ * Checks if value is greater than or equal to other.
+ *
+ * @param {unknown} value The value to compare.
+ * @param {unknown} other The other value to compare.
+ * @returns {boolean} Returns `true` if value is greater than or equal to other, else `false`.
+ *
+ * @example
+ * gte(3, 1); // => true
+ * gte(3, 3); // => true
+ * gte(1, 3); // => false
+ */
+declare function gte(value: unknown, other: unknown): boolean;
+
+export { gte };

package/dist/compat/util/gte.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Checks if value is greater than or equal to other.
+ *
+ * @param {unknown} value The value to compare.
+ * @param {unknown} other The other value to compare.
+ * @returns {boolean} Returns `true` if value is greater than or equal to other, else `false`.
+ *
+ * @example
+ * gte(3, 1); // => true
+ * gte(3, 3); // => true
+ * gte(1, 3); // => false
+ */
+declare function gte(value: unknown, other: unknown): boolean;
+
+export { gte };

package/dist/compat/util/gte.mjs

@@ -0,0 +1,10 @@
+import { toNumber } from './toNumber.mjs';
+
+function gte(value, other) {
+    if (typeof value === 'string' && typeof other === 'string') {
+        return value >= other;
+    }
+    return toNumber(value) >= toNumber(other);
+}
+
+export { gte };

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

@@ -39,6 +39,6 @@ declare function iteratee<F extends (...args: any[]) => unknown>(func: F): F;
  * const func = iteratee(['a', 1]);
  * [{ a: 1 }, { a: 2 }, { a: 3 }].find(func) // => { a: 1 }
  */
-declare function iteratee(value: symbol | number | string | object): (...args: any[]) => any;
+declare function iteratee(value?: symbol | number | string | object): (...args: any[]) => any;
 
 export { iteratee };

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

@@ -39,6 +39,6 @@ declare function iteratee<F extends (...args: any[]) => unknown>(func: F): F;
  * const func = iteratee(['a', 1]);
  * [{ a: 1 }, { a: 2 }, { a: 3 }].find(func) // => { a: 1 }
  */
-declare function iteratee(value: symbol | number | string | object): (...args: any[]) => any;
+declare function iteratee(value?: symbol | number | string | object): (...args: any[]) => any;
 
 export { iteratee };

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

@@ -0,0 +1,15 @@
+/**
+ * Converts a value to an array.
+ *
+ * @param {unknown} value - The value to convert.
+ * @returns {any[]} Returns the converted array.
+ *
+ * @example
+ * toArray({ 'a': 1, 'b': 2 }) // => returns [1,2]
+ * toArray('abc') // => returns ['a', 'b', 'c']
+ * toArray(1) // => returns []
+ * toArray(null) // => returns []
+ */
+declare function toArray(value?: unknown): any[];
+
+export { toArray };

package/dist/compat/util/toArray.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Converts a value to an array.
+ *
+ * @param {unknown} value - The value to convert.
+ * @returns {any[]} Returns the converted array.
+ *
+ * @example
+ * toArray({ 'a': 1, 'b': 2 }) // => returns [1,2]
+ * toArray('abc') // => returns ['a', 'b', 'c']
+ * toArray(1) // => returns []
+ * toArray(null) // => returns []
+ */
+declare function toArray(value?: unknown): any[];
+
+export { toArray };

package/dist/compat/util/toArray.mjs

@@ -0,0 +1,20 @@
+import { isArrayLike } from '../predicate/isArrayLike.mjs';
+import { isMap } from '../predicate/isMap.mjs';
+
+function toArray(value) {
+    if (value == null) {
+        return [];
+    }
+    if (isArrayLike(value) || isMap(value)) {
+        return Array.from(value);
+    }
+    if (typeof value === 'string') {
+        return value.split('');
+    }
+    if (typeof value === 'object') {
+        return Object.values(value);
+    }
+    return [];
+}
+
+export { toArray };