es-toolkit 1.35.0-dev.1202 → 1.35.0-dev.1209

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

@@ -1,54 +0,0 @@
-/**
- * Iterates over an object's properties and calls the `iteratee` function for each property.
- *
- * It only iterates over the object's own properties, not including inherited properties or properties with `Symbol` keys.
- *
- * The `iteratee` function can terminate the iteration early by returning `false`.
- *
- * @template T - The type of the object.
- * @param {T} object The object to iterate over.
- * @param {(value: T[keyof T], key: string, collection: T) => any} [iteratee=identity] The function invoked per iteration. If not provided, the identity function will be used.
- * @return {T} Returns object.
- *
- * @example
- * function Foo() {
- *   this.a = 1;
- *   this.b = 2;
- * }
- *
- * Foo.prototype.c = 3;
- *
- * forOwn(new Foo(), function(value, key) {
- *   console.log(key);
- * });
- * // => Logs 'a' then 'b' (iteration order is not guaranteed).
- */
-declare function forOwn<T>(object: T, iteratee?: (value: T[keyof T], key: string, collection: T) => any): T;
-/**
- * Iterates over an object's properties and calls the `iteratee` function for each property.
- *
- * It only iterates over the object's own properties, not including inherited properties or properties with `Symbol` keys.
- *
- * The `iteratee` function can terminate the iteration early by returning `false`.
- *
- * @template T - The type of the object.
- * @param {T | null | undefined} object The object to iterate over.
- * @param {(value: T[keyof T], key: string, collection: T) => any} [iteratee=identity] The function invoked per iteration. If not provided, the identity function will be used.
- * @return {T | null | undefined} Returns object.
- *
- * @example
- * function Foo() {
- *   this.a = 1;
- *   this.b = 2;
- * }
- *
- * Foo.prototype.c = 3;
- *
- * forOwn(new Foo(), function(value, key) {
- *   console.log(key);
- * });
- * // => Logs 'a' then 'b' (iteration order is not guaranteed).
- */
-declare function forOwn<T>(object: T | null | undefined, iteratee?: (value: T[keyof T], key: string, collection: T) => any): T | null | undefined;
-
-export { forOwn };

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

@@ -1,54 +0,0 @@
-/**
- * Iterates over an object's properties and calls the `iteratee` function for each property.
- *
- * It only iterates over the object's own properties, not including inherited properties or properties with `Symbol` keys.
- *
- * The `iteratee` function can terminate the iteration early by returning `false`.
- *
- * @template T - The type of the object.
- * @param {T} object The object to iterate over.
- * @param {(value: T[keyof T], key: string, collection: T) => any} [iteratee=identity] The function invoked per iteration. If not provided, the identity function will be used.
- * @return {T} Returns object.
- *
- * @example
- * function Foo() {
- *   this.a = 1;
- *   this.b = 2;
- * }
- *
- * Foo.prototype.c = 3;
- *
- * forOwn(new Foo(), function(value, key) {
- *   console.log(key);
- * });
- * // => Logs 'a' then 'b' (iteration order is not guaranteed).
- */
-declare function forOwn<T>(object: T, iteratee?: (value: T[keyof T], key: string, collection: T) => any): T;
-/**
- * Iterates over an object's properties and calls the `iteratee` function for each property.
- *
- * It only iterates over the object's own properties, not including inherited properties or properties with `Symbol` keys.
- *
- * The `iteratee` function can terminate the iteration early by returning `false`.
- *
- * @template T - The type of the object.
- * @param {T | null | undefined} object The object to iterate over.
- * @param {(value: T[keyof T], key: string, collection: T) => any} [iteratee=identity] The function invoked per iteration. If not provided, the identity function will be used.
- * @return {T | null | undefined} Returns object.
- *
- * @example
- * function Foo() {
- *   this.a = 1;
- *   this.b = 2;
- * }
- *
- * Foo.prototype.c = 3;
- *
- * forOwn(new Foo(), function(value, key) {
- *   console.log(key);
- * });
- * // => Logs 'a' then 'b' (iteration order is not guaranteed).
- */
-declare function forOwn<T>(object: T | null | undefined, iteratee?: (value: T[keyof T], key: string, collection: T) => any): T | null | undefined;
-
-export { forOwn };

package/dist/compat/object/forOwn.mjs

@@ -1,19 +0,0 @@
-import { keys } from './keys.mjs';
-import { identity } from '../../function/identity.mjs';
-
-function forOwn(object, iteratee = identity) {
-    if (object == null) {
-        return object;
-    }
-    const iterable = Object(object);
-    const keys$1 = keys(object);
-    for (let i = 0; i < keys$1.length; ++i) {
-        const key = keys$1[i];
-        if (iteratee(iterable[key], key, iterable) === false) {
-            break;
-        }
-    }
-    return object;
-}
-
-export { forOwn };

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

@@ -1,54 +0,0 @@
-/**
- * Iterates over an object's properties in reverse order and calls the `iteratee` function for each property.
- *
- * It only iterates over the object's own properties, not including inherited properties or properties with `Symbol` keys.
- *
- * The `iteratee` function can terminate the iteration early by returning `false`.
- *
- * @template T - The type of the object.
- * @param {T} object The object to iterate over.
- * @param {(value: T[keyof T], key: string, collection: T) => any} [iteratee=identity] The function invoked per iteration. If not provided, the identity function will be used.
- * @return {T} Returns object.
- *
- * @example
- * function Foo() {
- *   this.a = 1;
- *   this.b = 2;
- * }
- *
- * Foo.prototype.c = 3;
- *
- * forOwnRight(new Foo(), function(value, key) {
- *   console.log(key);
- * });
- * // => Logs 'b' then 'a' (iteration order is not guaranteed).
- */
-declare function forOwnRight<T>(object: T, iteratee?: (value: T[keyof T], key: string, collection: T) => any): T;
-/**
- * Iterates over an object's properties in reverse order and calls the `iteratee` function for each property.
- *
- * It only iterates over the object's own properties, not including inherited properties or properties with `Symbol` keys.
- *
- * The `iteratee` function can terminate the iteration early by returning `false`.
- *
- * @template T - The type of the object.
- * @param {T | null | undefined} object The object to iterate over.
- * @param {(value: T[keyof T], key: string, collection: T) => any} [iteratee=identity] The function invoked per iteration. If not provided, the identity function will be used.
- * @return {T | null | undefined} Returns object.
- *
- * @example
- * function Foo() {
- *   this.a = 1;
- *   this.b = 2;
- * }
- *
- * Foo.prototype.c = 3;
- *
- * forOwnRight(new Foo(), function(value, key) {
- *   console.log(key);
- * });
- * // => Logs 'b' then 'a' (iteration order is not guaranteed).
- */
-declare function forOwnRight<T>(object: T | null | undefined, iteratee?: (value: T[keyof T], key: string, collection: T) => any): T | null | undefined;
-
-export { forOwnRight };

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

@@ -1,54 +0,0 @@
-/**
- * Iterates over an object's properties in reverse order and calls the `iteratee` function for each property.
- *
- * It only iterates over the object's own properties, not including inherited properties or properties with `Symbol` keys.
- *
- * The `iteratee` function can terminate the iteration early by returning `false`.
- *
- * @template T - The type of the object.
- * @param {T} object The object to iterate over.
- * @param {(value: T[keyof T], key: string, collection: T) => any} [iteratee=identity] The function invoked per iteration. If not provided, the identity function will be used.
- * @return {T} Returns object.
- *
- * @example
- * function Foo() {
- *   this.a = 1;
- *   this.b = 2;
- * }
- *
- * Foo.prototype.c = 3;
- *
- * forOwnRight(new Foo(), function(value, key) {
- *   console.log(key);
- * });
- * // => Logs 'b' then 'a' (iteration order is not guaranteed).
- */
-declare function forOwnRight<T>(object: T, iteratee?: (value: T[keyof T], key: string, collection: T) => any): T;
-/**
- * Iterates over an object's properties in reverse order and calls the `iteratee` function for each property.
- *
- * It only iterates over the object's own properties, not including inherited properties or properties with `Symbol` keys.
- *
- * The `iteratee` function can terminate the iteration early by returning `false`.
- *
- * @template T - The type of the object.
- * @param {T | null | undefined} object The object to iterate over.
- * @param {(value: T[keyof T], key: string, collection: T) => any} [iteratee=identity] The function invoked per iteration. If not provided, the identity function will be used.
- * @return {T | null | undefined} Returns object.
- *
- * @example
- * function Foo() {
- *   this.a = 1;
- *   this.b = 2;
- * }
- *
- * Foo.prototype.c = 3;
- *
- * forOwnRight(new Foo(), function(value, key) {
- *   console.log(key);
- * });
- * // => Logs 'b' then 'a' (iteration order is not guaranteed).
- */
-declare function forOwnRight<T>(object: T | null | undefined, iteratee?: (value: T[keyof T], key: string, collection: T) => any): T | null | undefined;
-
-export { forOwnRight };

package/dist/compat/object/forOwnRight.mjs

@@ -1,19 +0,0 @@
-import { keys } from './keys.mjs';
-import { identity } from '../../function/identity.mjs';
-
-function forOwnRight(object, iteratee = identity) {
-    if (object == null) {
-        return object;
-    }
-    const iterable = Object(object);
-    const keys$1 = keys(object);
-    for (let i = keys$1.length - 1; i >= 0; --i) {
-        const key = keys$1[i];
-        if (iteratee(iterable[key], key, iterable) === false) {
-            break;
-        }
-    }
-    return object;
-}
-
-export { forOwnRight };

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

@@ -1,40 +0,0 @@
-/**
- * Checks if a given path exists in an object, **including inherited properties**.
- *
- * You can provide the path as a single property key, an array of property keys,
- * or a string representing a deep path.
- *
- * Unlike `has`, which only checks for own properties, `hasIn` also checks for properties
- * in the prototype chain.
- *
- * If the path is an index and the object is an array or an arguments object, the function will verify
- * if the index is valid and within the bounds of the array or arguments object, even if the array or
- * arguments object is sparse (i.e., not all indexes are defined).
- *
- * @param {object} object - The object to query.
- * @param {PropertyKey | PropertyKey[]} path - The path to check. This can be a single property key,
- *        an array of property keys, or a string representing a deep path.
- * @returns {boolean} Returns `true` if the path exists (own or inherited), `false` otherwise.
- *
- * @example
- *
- * const obj = { a: { b: { c: 3 } } };
- *
- * hasIn(obj, 'a'); // true
- * hasIn(obj, ['a', 'b']); // true
- * hasIn(obj, ['a', 'b', 'c']); // true
- * hasIn(obj, 'a.b.c'); // true
- * hasIn(obj, 'a.b.d'); // false
- * hasIn(obj, ['a', 'b', 'c', 'd']); // false
- *
- * // Example with inherited properties:
- * function Rectangle() {}
- * Rectangle.prototype.area = function() {};
- *
- * const rect = new Rectangle();
- * hasIn(rect, 'area'); // true
- * has(rect, 'area'); // false - has only checks own properties
- */
-declare function hasIn(object: unknown, path: PropertyKey | readonly PropertyKey[]): boolean;
-
-export { hasIn };

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

@@ -1,40 +0,0 @@
-/**
- * Checks if a given path exists in an object, **including inherited properties**.
- *
- * You can provide the path as a single property key, an array of property keys,
- * or a string representing a deep path.
- *
- * Unlike `has`, which only checks for own properties, `hasIn` also checks for properties
- * in the prototype chain.
- *
- * If the path is an index and the object is an array or an arguments object, the function will verify
- * if the index is valid and within the bounds of the array or arguments object, even if the array or
- * arguments object is sparse (i.e., not all indexes are defined).
- *
- * @param {object} object - The object to query.
- * @param {PropertyKey | PropertyKey[]} path - The path to check. This can be a single property key,
- *        an array of property keys, or a string representing a deep path.
- * @returns {boolean} Returns `true` if the path exists (own or inherited), `false` otherwise.
- *
- * @example
- *
- * const obj = { a: { b: { c: 3 } } };
- *
- * hasIn(obj, 'a'); // true
- * hasIn(obj, ['a', 'b']); // true
- * hasIn(obj, ['a', 'b', 'c']); // true
- * hasIn(obj, 'a.b.c'); // true
- * hasIn(obj, 'a.b.d'); // false
- * hasIn(obj, ['a', 'b', 'c', 'd']); // false
- *
- * // Example with inherited properties:
- * function Rectangle() {}
- * Rectangle.prototype.area = function() {};
- *
- * const rect = new Rectangle();
- * hasIn(rect, 'area'); // true
- * has(rect, 'area'); // false - has only checks own properties
- */
-declare function hasIn(object: unknown, path: PropertyKey | readonly PropertyKey[]): boolean;
-
-export { hasIn };

package/dist/compat/object/hasIn.mjs

@@ -1,34 +0,0 @@
-import { isDeepKey } from '../_internal/isDeepKey.mjs';
-import { isIndex } from '../_internal/isIndex.mjs';
-import { isArguments } from '../predicate/isArguments.mjs';
-import { toPath } from '../util/toPath.mjs';
-
-function hasIn(object, path) {
-    let resolvedPath;
-    if (Array.isArray(path)) {
-        resolvedPath = path;
-    }
-    else if (typeof path === 'string' && isDeepKey(path) && object?.[path] == null) {
-        resolvedPath = toPath(path);
-    }
-    else {
-        resolvedPath = [path];
-    }
-    if (resolvedPath.length === 0) {
-        return false;
-    }
-    let current = object;
-    for (let i = 0; i < resolvedPath.length; i++) {
-        const key = resolvedPath[i];
-        if (current == null || !(key in Object(current))) {
-            const isSparseIndex = (Array.isArray(current) || isArguments(current)) && isIndex(key) && key < current.length;
-            if (!isSparseIndex) {
-                return false;
-            }
-        }
-        current = current[key];
-    }
-    return true;
-}
-
-export { hasIn };

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

@@ -1,19 +0,0 @@
-/**
- * Splits the input string by the specified `separator`
- * and returns a new array containing the split segments.
- *
- * @param {string | null | undefined} [string=''] The string to split.
- * @param {RegExp|string} [separator] The separator pattern to split by.
- * @param {number} [limit] The length to truncate results to.
- * @returns {Array} Returns the string segments.
- *
- * @example
- * split('a-b-c', '-');
- * // => ['a', 'b', 'c']
- *
- * split('a-b-c', '-', 2);
- * // => ['a', 'b']
- */
-declare function split(string?: string | null | undefined, separator?: RegExp | string, limit?: number): string[];
-
-export { split };

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

@@ -1,19 +0,0 @@
-/**
- * Splits the input string by the specified `separator`
- * and returns a new array containing the split segments.
- *
- * @param {string | null | undefined} [string=''] The string to split.
- * @param {RegExp|string} [separator] The separator pattern to split by.
- * @param {number} [limit] The length to truncate results to.
- * @returns {Array} Returns the string segments.
- *
- * @example
- * split('a-b-c', '-');
- * // => ['a', 'b', 'c']
- *
- * split('a-b-c', '-', 2);
- * // => ['a', 'b']
- */
-declare function split(string?: string | null | undefined, separator?: RegExp | string, limit?: number): string[];
-
-export { split };

package/dist/compat/string/split.mjs

@@ -1,7 +0,0 @@
-import { toString } from '../util/toString.mjs';
-
-function split(string = '', separator, limit) {
-    return toString(string).split(separator, limit);
-}
-
-export { split };

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

@@ -1,67 +0,0 @@
-/**
- * Creates a predicate function that checks if a value satisfies all of the given predicates.
- *
- * @template T - The type of the value to be checked.
- * @template U - The first possible type that the value could match.
- * @template V - The second possible type that the value could match.
- *
- * @param {(value: T) => value is U} predicate1 - A function that checks if the value matches type `U`.
- * @param {(value: T) => value is V} predicate2 - A function that checks if the value matches type `V`.
- *
- * @returns {(value: T) => value is U & V} A function that takes a value and returns `true` if all predicates return truthy.
- *
- * @example
- * const func = overEvery(
- *   (value) => typeof value === 'string',
- *   (value) => value === 'hello'
- * );
- *
- * func("hello"); // true
- * func("world"); // false
- * func(42); // false
- */
-declare function overEvery<T, U extends T, V extends T>(predicate1: (value: T) => value is U, predicate2: (value: T) => value is V): (value: T) => value is U & V;
-/**
- * Creates a function that checks if all of the given predicates return truthy for the provided values.
- *
- * @template T - The type of the values to be checked.
- *
- * @param {...Array<((...values: T[]) => boolean) | ReadonlyArray<(...values: T[]) => boolean>>} predicates -
- *   A list of predicates or arrays of predicates. Each predicate is a function that takes one or more values of
- *   type `T` and returns a boolean indicating whether the condition is satisfied for those values.
- *
- * @returns {(...values: T[]) => boolean} A function that takes a list of values and returns `true` if all of the
- *   predicates return truthy for the provided values, and `false` otherwise.
- *
- * @example
- * const func = overEvery(
- *   (value) => typeof value === 'string',
- *   (value) => value.length > 3
- * );
- *
- * func("hello"); // true
- * func("hi"); // false
- * func(42); // false
- *
- * @example
- * const func = overEvery([
- *   (value) => value.a > 0,
- *   (value) => value.b > 0
- * ]);
- *
- * func({ a: 1, b: 2 }); // true
- * func({ a: 0, b: 2 }); // false
- *
- * @example
- * const func = overEvery(
- *   (a, b) => typeof a === 'string' && typeof b === 'string',
- *   (a, b) => a.length > 3 && b.length > 3
- * );
- *
- * func("hello", "world"); // true
- * func("hi", "world"); // false
- * func(1, 10); // false
- */
-declare function overEvery<T>(...predicates: Array<((...args: T[]) => boolean) | ReadonlyArray<(...args: T[]) => boolean>>): (...args: T[]) => boolean;
-
-export { overEvery };

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

@@ -1,67 +0,0 @@
-/**
- * Creates a predicate function that checks if a value satisfies all of the given predicates.
- *
- * @template T - The type of the value to be checked.
- * @template U - The first possible type that the value could match.
- * @template V - The second possible type that the value could match.
- *
- * @param {(value: T) => value is U} predicate1 - A function that checks if the value matches type `U`.
- * @param {(value: T) => value is V} predicate2 - A function that checks if the value matches type `V`.
- *
- * @returns {(value: T) => value is U & V} A function that takes a value and returns `true` if all predicates return truthy.
- *
- * @example
- * const func = overEvery(
- *   (value) => typeof value === 'string',
- *   (value) => value === 'hello'
- * );
- *
- * func("hello"); // true
- * func("world"); // false
- * func(42); // false
- */
-declare function overEvery<T, U extends T, V extends T>(predicate1: (value: T) => value is U, predicate2: (value: T) => value is V): (value: T) => value is U & V;
-/**
- * Creates a function that checks if all of the given predicates return truthy for the provided values.
- *
- * @template T - The type of the values to be checked.
- *
- * @param {...Array<((...values: T[]) => boolean) | ReadonlyArray<(...values: T[]) => boolean>>} predicates -
- *   A list of predicates or arrays of predicates. Each predicate is a function that takes one or more values of
- *   type `T` and returns a boolean indicating whether the condition is satisfied for those values.
- *
- * @returns {(...values: T[]) => boolean} A function that takes a list of values and returns `true` if all of the
- *   predicates return truthy for the provided values, and `false` otherwise.
- *
- * @example
- * const func = overEvery(
- *   (value) => typeof value === 'string',
- *   (value) => value.length > 3
- * );
- *
- * func("hello"); // true
- * func("hi"); // false
- * func(42); // false
- *
- * @example
- * const func = overEvery([
- *   (value) => value.a > 0,
- *   (value) => value.b > 0
- * ]);
- *
- * func({ a: 1, b: 2 }); // true
- * func({ a: 0, b: 2 }); // false
- *
- * @example
- * const func = overEvery(
- *   (a, b) => typeof a === 'string' && typeof b === 'string',
- *   (a, b) => a.length > 3 && b.length > 3
- * );
- *
- * func("hello", "world"); // true
- * func("hi", "world"); // false
- * func(1, 10); // false
- */
-declare function overEvery<T>(...predicates: Array<((...args: T[]) => boolean) | ReadonlyArray<(...args: T[]) => boolean>>): (...args: T[]) => boolean;
-
-export { overEvery };

package/dist/compat/util/overEvery.mjs

@@ -1,23 +0,0 @@
-import { iteratee } from './iteratee.mjs';
-
-function overEvery(...predicates) {
-    return function (...values) {
-        for (let i = 0; i < predicates.length; ++i) {
-            const predicate = predicates[i];
-            if (!Array.isArray(predicate)) {
-                if (!iteratee(predicate).apply(this, values)) {
-                    return false;
-                }
-                continue;
-            }
-            for (let j = 0; j < predicate.length; ++j) {
-                if (!iteratee(predicate[j]).apply(this, values)) {
-                    return false;
-                }
-            }
-        }
-        return true;
-    };
-}
-
-export { overEvery };

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

@@ -1,69 +0,0 @@
-/**
- * Creates a predicate function that checks if a value satisfies at least one of the given predicates.
- *
- * @template T - The type of the value to be checked.
- * @template U - The first possible type that the value could match.
- * @template V - The second possible type that the value could match.
- *
- * @param {(value: T) => value is U} predicate1 - A function that checks if the value matches type `U`.
- * @param {(value: T) => value is V} predicate2 - A function that checks if the value matches type `V`.
- *
- * @returns {(value: T) => value is U | V} A function that takes a value and returns `true` if any predicates return truthy.
- *
- * @example
- * const func = overSome(
- *   (value) => typeof value === 'string',
- *   (value) => typeof value === 'number'
- * );
- *
- * func("hello"); // true
- * func(42); // true
- * func([]); // false
- */
-declare function overSome<T, U extends T, V extends T>(predicate1: (value: T) => value is U, predicate2: (value: T) => value is V): (value: T) => value is U | V;
-/**
- * Creates a function that checks if any of the given predicates return truthy for the provided values.
- *
- * @template T - The type of the values to be checked.
- *
- * @param {...Array<((...values: T[]) => boolean) | ReadonlyArray<(...values: T[]) => boolean>>} predicates -
- *   A list of predicates or arrays of predicates. Each predicate is a function that takes one or more values of
- *   type `T` and returns a boolean indicating whether the condition is satisfied for those values.
- *
- * @returns {(...values: T[]) => boolean} A function that takes a list of values and returns `true` if any of the
- *   predicates return truthy for the provided values, and `false` otherwise.
- *
- * @example
- * const func = overSome(
- *   (value) => typeof value === 'string',
- *   (value) => typeof value === 'number',
- *   (value) => typeof value === 'symbol'
- * );
- *
- * func("hello"); // true
- * func(42); // true
- * func(Symbol()); // true
- * func([]); // false
- *
- * @example
- * const func = overSome([
- *   (value) => value.a > 0,
- *   (value) => value.b > 0
- * ]);
- *
- * func({ a: 0, b: 2 }); // true
- * func({ a: 0, b: 0 }); // false
- *
- * @example
- * const func = overSome(
- *   (a, b) => typeof a === 'string' && typeof b === 'string',
- *   (a, b) => a > 0 && b > 0
- * );
- *
- * func("hello", "world"); // true
- * func(1, 10); // true
- * func(0, 2); // false
- */
-declare function overSome<T>(...predicates: Array<((...values: T[]) => boolean) | ReadonlyArray<(...values: T[]) => boolean>>): (...values: T[]) => boolean;
-
-export { overSome };