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

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

@@ -1,49 +0,0 @@
-/**
- * Combines an array of property names into a single object.
- *
- * This function takes one array containing property names and returns a new object where the property names
- * are keys, and the values are all set to `undefined`.
- *
- * @template P - The type of elements in the array.
- * @param {ArrayLike<K>} keys - An array of property names.
- * @returns {Record<K, undefined>} - A new object composed of the given property names and undefined.
- *
- * @example
- * const keys = ['a', 'b', 'c'];
- * const result = zipObject(keys);
- * // result will be { a: undefined, b: undefined, c: undefined }
- */
-declare function zipObject<K extends PropertyKey>(keys?: ArrayLike<K>): Record<K, undefined>;
-/**
- * Combines two arrays, one of property names and one of corresponding values, into a single object.
- *
- * This function takes two arrays: one containing property names and another containing corresponding values.
- * It returns a new object where the property names from the first array are keys, and the corresponding elements
- * from the second array are values. If the `keys` array is longer than the `values` array, the remaining keys will
- * have `undefined` as their values.
- *
- * @template P - The type of elements in the array.
- * @template V - The type of elements in the array.
- * @param {ArrayLike<K>} keys - An array of property names.
- * @param {ArrayLike<V>} values - An array of values corresponding to the property names.
- * @returns {Record<K, V>} - A new object composed of the given property names and values.
- *
- * @example
- * const keys = ['a', 'b', 'c'];
- * const values = [1, 2, 3];
- * const result = zipObject(keys, values);
- * // result will be { a: 1, b: 2, c: 3 }
- *
- * const keys2 = ['a', 'b', 'c'];
- * const values2 = [1, 2];
- * const result2 = zipObject(keys2, values2);
- * // result2 will be { a: 1, b: 2, c: undefined }
- *
- * const keys2 = ['a', 'b'];
- * const values2 = [1, 2, 3];
- * const result2 = zipObject(keys2, values2);
- * // result2 will be { a: 1, b: 2 }
- */
-declare function zipObject<K extends PropertyKey, V>(keys: ArrayLike<K>, values: ArrayLike<V>): Record<K, V>;
-
-export { zipObject };

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

@@ -1,49 +0,0 @@
-/**
- * Combines an array of property names into a single object.
- *
- * This function takes one array containing property names and returns a new object where the property names
- * are keys, and the values are all set to `undefined`.
- *
- * @template P - The type of elements in the array.
- * @param {ArrayLike<K>} keys - An array of property names.
- * @returns {Record<K, undefined>} - A new object composed of the given property names and undefined.
- *
- * @example
- * const keys = ['a', 'b', 'c'];
- * const result = zipObject(keys);
- * // result will be { a: undefined, b: undefined, c: undefined }
- */
-declare function zipObject<K extends PropertyKey>(keys?: ArrayLike<K>): Record<K, undefined>;
-/**
- * Combines two arrays, one of property names and one of corresponding values, into a single object.
- *
- * This function takes two arrays: one containing property names and another containing corresponding values.
- * It returns a new object where the property names from the first array are keys, and the corresponding elements
- * from the second array are values. If the `keys` array is longer than the `values` array, the remaining keys will
- * have `undefined` as their values.
- *
- * @template P - The type of elements in the array.
- * @template V - The type of elements in the array.
- * @param {ArrayLike<K>} keys - An array of property names.
- * @param {ArrayLike<V>} values - An array of values corresponding to the property names.
- * @returns {Record<K, V>} - A new object composed of the given property names and values.
- *
- * @example
- * const keys = ['a', 'b', 'c'];
- * const values = [1, 2, 3];
- * const result = zipObject(keys, values);
- * // result will be { a: 1, b: 2, c: 3 }
- *
- * const keys2 = ['a', 'b', 'c'];
- * const values2 = [1, 2];
- * const result2 = zipObject(keys2, values2);
- * // result2 will be { a: 1, b: 2, c: undefined }
- *
- * const keys2 = ['a', 'b'];
- * const values2 = [1, 2, 3];
- * const result2 = zipObject(keys2, values2);
- * // result2 will be { a: 1, b: 2 }
- */
-declare function zipObject<K extends PropertyKey, V>(keys: ArrayLike<K>, values: ArrayLike<V>): Record<K, V>;
-
-export { zipObject };

package/dist/compat/array/zipObject.mjs

@@ -1,11 +0,0 @@
-import { assignValue } from '../_internal/assignValue.mjs';
-
-function zipObject(keys = [], values = []) {
-    const result = {};
-    for (let i = 0; i < keys.length; i++) {
-        assignValue(result, keys[i], values[i]);
-    }
-    return result;
-}
-
-export { zipObject };

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

@@ -1,92 +0,0 @@
-/**
- * Combines one array into a single array using a custom combiner function.
- *
- * @template T - The type of elements in the first array.
- * @template R - The type of elements in the resulting array.
- * @param {ArrayLike<T>} arr1 - The first array to zip.
- * @param {(item: T) => R} combine - The combiner function that takes corresponding elements from each array and returns a single value.
- * @returns {R[]} A new array where each element is the result of applying the combiner function to the corresponding elements of the input arrays.
- */
-declare function zipWith<T, R>(arr1: ArrayLike<T>, combine: (item: T) => R): R[];
-/**
- * Combines two arrays into a single array using a custom combiner function.
- *
- * @template T - The type of elements in the first array.
- * @template U - The type of elements in the second array.
- * @template R - The type of elements in the resulting array.
- * @param {ArrayLike<T>} arr1 - The first array to zip.
- * @param {ArrayLike<U>} arr2 - The second array to zip.
- * @param {(item1: T, item2: U) => R} combine - The combiner function that takes corresponding elements from each array and returns a single value.
- * @returns {R[]} A new array where each element is the result of applying the combiner function to the corresponding elements of the input arrays.
- */
-declare function zipWith<T, U, R>(arr1: ArrayLike<T>, arr2: ArrayLike<U>, combine: (item1: T, item2: U) => R): R[];
-/**
- * Combines three arrays into a single array using a custom combiner function.
- *
- * @template T - The type of elements in the first array.
- * @template U - The type of elements in the second array.
- * @template V - The type of elements in the third array.
- * @template R - The type of elements in the resulting array.
- * @param {ArrayLike<T>} arr1 - The first array to zip.
- * @param {ArrayLike<U>} arr2 - The second array to zip.
- * @param {ArrayLike<V>} arr3 - The third array to zip.
- * @param {(item1: T, item2: U, item3: V) => R} combine - The combiner function that takes corresponding elements from each array and returns a single value.
- * @returns {R[]} A new array where each element is the result of applying the combiner function to the corresponding elements of the input arrays.
- */
-declare function zipWith<T, U, V, R>(arr1: ArrayLike<T>, arr2: ArrayLike<U>, arr3: ArrayLike<V>, combine: (item1: T, item2: U, item3: V) => R): R[];
-/**
- * Combines four arrays into a single array using a custom combiner function.
- *
- * @template T - The type of elements in the first array.
- * @template U - The type of elements in the second array.
- * @template V - The type of elements in the third array.
- * @template W - The type of elements in the fourth array.
- * @template R - The type of elements in the resulting array.
- * @param {ArrayLike<T>} arr1 - The first array to zip.
- * @param {ArrayLike<U>} arr2 - The second array to zip.
- * @param {ArrayLike<V>} arr3 - The third array to zip.
- * @param {ArrayLike<W>} arr4 - The fourth array to zip.
- * @param {(item1: T, item2: U, item3: V, item4: W) => R} combine - The combiner function that takes corresponding elements from each array and returns a single value.
- * @returns {R[]} A new array where each element is the result of applying the combiner function to the corresponding elements of the input arrays.
- */
-declare function zipWith<T, U, V, W, R>(arr1: ArrayLike<T>, arr2: ArrayLike<U>, arr3: ArrayLike<V>, arr4: ArrayLike<W>, combine: (item1: T, item2: U, item3: V, item4: W) => R): R[];
-/**
- * Combines five arrays into a single array using a custom combiner function.
- *
- * @template T - The type of elements in the first array.
- * @template U - The type of elements in the second array.
- * @template V - The type of elements in the third array.
- * @template W - The type of elements in the fourth array.
- * @template X - The type of elements in the fifth array.
- * @template R - The type of elements in the resulting array.
- * @param {ArrayLike<T>} arr1 - The first array to zip.
- * @param {ArrayLike<U>} arr2 - The second array to zip.
- * @param {ArrayLike<V>} arr3 - The third array to zip.
- * @param {ArrayLike<W>} arr4 - The fourth array to zip.
- * @param {ArrayLike<X>} arr5 - The fifth array to zip.
- * @param {(item1: T, item2: U, item3: V, item4: W, item5: X) => R} combine - The combiner function that takes corresponding elements from each array and returns a single value.
- * @returns {R[]} A new array where each element is the result of applying the combiner function to the corresponding elements of the input arrays.
- */
-declare function zipWith<T, U, V, W, X, R>(arr1: ArrayLike<T>, arr2: ArrayLike<U>, arr3: ArrayLike<V>, arr4: ArrayLike<W>, arr5: ArrayLike<X>, combine: (item1: T, item2: U, item3: V, item4: W, item5: X) => R): R[];
-/**
- * Combines multiple arrays into a single array using a custom combiner function.
- *
- * This function takes one array and a variable number of additional arrays,
- * applying the provided combiner function to the corresponding elements of each array.
- * If the input arrays are of different lengths, the resulting array will have the length
- * of the longest input array, with undefined values for missing elements.
- *
- * @template T - The type of elements in the input arrays.
- * @template R - The type of elements in the resulting array.
- * @param {Array<((...group: T[]) => R) | ArrayLike<T> | null | undefined>} combine - The combiner function that takes corresponding elements from each array and returns a single value.
- * @returns {R[]} A new array where each element is the result of applying the combiner function to the corresponding elements of the input arrays.
- *
- * @example
- * const arr1 = [1, 2, 3];
- * const arr2 = ['a', 'b', 'c'];
- * const result = zipWith(arr1, arr2, (num, char) => `${num}${char}`);
- * // result will be ['1a', '2b', '3c']
- */
-declare function zipWith<T, R>(...combine: Array<((...group: T[]) => R) | ArrayLike<T> | null | undefined>): R[];
-
-export { zipWith };

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

@@ -1,92 +0,0 @@
-/**
- * Combines one array into a single array using a custom combiner function.
- *
- * @template T - The type of elements in the first array.
- * @template R - The type of elements in the resulting array.
- * @param {ArrayLike<T>} arr1 - The first array to zip.
- * @param {(item: T) => R} combine - The combiner function that takes corresponding elements from each array and returns a single value.
- * @returns {R[]} A new array where each element is the result of applying the combiner function to the corresponding elements of the input arrays.
- */
-declare function zipWith<T, R>(arr1: ArrayLike<T>, combine: (item: T) => R): R[];
-/**
- * Combines two arrays into a single array using a custom combiner function.
- *
- * @template T - The type of elements in the first array.
- * @template U - The type of elements in the second array.
- * @template R - The type of elements in the resulting array.
- * @param {ArrayLike<T>} arr1 - The first array to zip.
- * @param {ArrayLike<U>} arr2 - The second array to zip.
- * @param {(item1: T, item2: U) => R} combine - The combiner function that takes corresponding elements from each array and returns a single value.
- * @returns {R[]} A new array where each element is the result of applying the combiner function to the corresponding elements of the input arrays.
- */
-declare function zipWith<T, U, R>(arr1: ArrayLike<T>, arr2: ArrayLike<U>, combine: (item1: T, item2: U) => R): R[];
-/**
- * Combines three arrays into a single array using a custom combiner function.
- *
- * @template T - The type of elements in the first array.
- * @template U - The type of elements in the second array.
- * @template V - The type of elements in the third array.
- * @template R - The type of elements in the resulting array.
- * @param {ArrayLike<T>} arr1 - The first array to zip.
- * @param {ArrayLike<U>} arr2 - The second array to zip.
- * @param {ArrayLike<V>} arr3 - The third array to zip.
- * @param {(item1: T, item2: U, item3: V) => R} combine - The combiner function that takes corresponding elements from each array and returns a single value.
- * @returns {R[]} A new array where each element is the result of applying the combiner function to the corresponding elements of the input arrays.
- */
-declare function zipWith<T, U, V, R>(arr1: ArrayLike<T>, arr2: ArrayLike<U>, arr3: ArrayLike<V>, combine: (item1: T, item2: U, item3: V) => R): R[];
-/**
- * Combines four arrays into a single array using a custom combiner function.
- *
- * @template T - The type of elements in the first array.
- * @template U - The type of elements in the second array.
- * @template V - The type of elements in the third array.
- * @template W - The type of elements in the fourth array.
- * @template R - The type of elements in the resulting array.
- * @param {ArrayLike<T>} arr1 - The first array to zip.
- * @param {ArrayLike<U>} arr2 - The second array to zip.
- * @param {ArrayLike<V>} arr3 - The third array to zip.
- * @param {ArrayLike<W>} arr4 - The fourth array to zip.
- * @param {(item1: T, item2: U, item3: V, item4: W) => R} combine - The combiner function that takes corresponding elements from each array and returns a single value.
- * @returns {R[]} A new array where each element is the result of applying the combiner function to the corresponding elements of the input arrays.
- */
-declare function zipWith<T, U, V, W, R>(arr1: ArrayLike<T>, arr2: ArrayLike<U>, arr3: ArrayLike<V>, arr4: ArrayLike<W>, combine: (item1: T, item2: U, item3: V, item4: W) => R): R[];
-/**
- * Combines five arrays into a single array using a custom combiner function.
- *
- * @template T - The type of elements in the first array.
- * @template U - The type of elements in the second array.
- * @template V - The type of elements in the third array.
- * @template W - The type of elements in the fourth array.
- * @template X - The type of elements in the fifth array.
- * @template R - The type of elements in the resulting array.
- * @param {ArrayLike<T>} arr1 - The first array to zip.
- * @param {ArrayLike<U>} arr2 - The second array to zip.
- * @param {ArrayLike<V>} arr3 - The third array to zip.
- * @param {ArrayLike<W>} arr4 - The fourth array to zip.
- * @param {ArrayLike<X>} arr5 - The fifth array to zip.
- * @param {(item1: T, item2: U, item3: V, item4: W, item5: X) => R} combine - The combiner function that takes corresponding elements from each array and returns a single value.
- * @returns {R[]} A new array where each element is the result of applying the combiner function to the corresponding elements of the input arrays.
- */
-declare function zipWith<T, U, V, W, X, R>(arr1: ArrayLike<T>, arr2: ArrayLike<U>, arr3: ArrayLike<V>, arr4: ArrayLike<W>, arr5: ArrayLike<X>, combine: (item1: T, item2: U, item3: V, item4: W, item5: X) => R): R[];
-/**
- * Combines multiple arrays into a single array using a custom combiner function.
- *
- * This function takes one array and a variable number of additional arrays,
- * applying the provided combiner function to the corresponding elements of each array.
- * If the input arrays are of different lengths, the resulting array will have the length
- * of the longest input array, with undefined values for missing elements.
- *
- * @template T - The type of elements in the input arrays.
- * @template R - The type of elements in the resulting array.
- * @param {Array<((...group: T[]) => R) | ArrayLike<T> | null | undefined>} combine - The combiner function that takes corresponding elements from each array and returns a single value.
- * @returns {R[]} A new array where each element is the result of applying the combiner function to the corresponding elements of the input arrays.
- *
- * @example
- * const arr1 = [1, 2, 3];
- * const arr2 = ['a', 'b', 'c'];
- * const result = zipWith(arr1, arr2, (num, char) => `${num}${char}`);
- * // result will be ['1a', '2b', '3c']
- */
-declare function zipWith<T, R>(...combine: Array<((...group: T[]) => R) | ArrayLike<T> | null | undefined>): R[];
-
-export { zipWith };

package/dist/compat/array/zipWith.mjs

@@ -1,20 +0,0 @@
-import { unzip } from './unzip.mjs';
-import { isFunction } from '../../predicate/isFunction.mjs';
-
-function zipWith(...combine) {
-    let iteratee = combine.pop();
-    if (!isFunction(iteratee)) {
-        combine.push(iteratee);
-        iteratee = undefined;
-    }
-    if (!combine?.length) {
-        return [];
-    }
-    const result = unzip(combine);
-    if (iteratee == null) {
-        return result;
-    }
-    return result.map(group => iteratee(...group));
-}
-
-export { zipWith };

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

@@ -1,19 +0,0 @@
-/**
- * Returns an array of values corresponding to `paths` of `object`.
- *
- * @template T - The type of the object.
- * @param {T} object - The object to iterate over.
- * @param {...(PropertyKey | PropertyKey[] | ArrayLike<PropertyKey>)} [paths] - The property paths to pick.
- * @returns {Array<unknown>} - Returns the picked values.
- *
- * @example
- * ```js
- * const object = { 'a': [{ 'b': { 'c': 3 } }, 4] };
- *
- * at(object, ['a[0].b.c', 'a[1]']);
- * // => [3, 4]
- * ```
- */
-declare function at<T>(object: T, ...paths: Array<PropertyKey | PropertyKey[] | ArrayLike<PropertyKey>>): unknown[];
-
-export { at };

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

@@ -1,19 +0,0 @@
-/**
- * Returns an array of values corresponding to `paths` of `object`.
- *
- * @template T - The type of the object.
- * @param {T} object - The object to iterate over.
- * @param {...(PropertyKey | PropertyKey[] | ArrayLike<PropertyKey>)} [paths] - The property paths to pick.
- * @returns {Array<unknown>} - Returns the picked values.
- *
- * @example
- * ```js
- * const object = { 'a': [{ 'b': { 'c': 3 } }, 4] };
- *
- * at(object, ['a[0].b.c', 'a[1]']);
- * // => [3, 4]
- * ```
- */
-declare function at<T>(object: T, ...paths: Array<PropertyKey | PropertyKey[] | ArrayLike<PropertyKey>>): unknown[];
-
-export { at };

package/dist/compat/object/at.mjs

@@ -1,27 +0,0 @@
-import { get } from './get.mjs';
-import { isArrayLike } from '../predicate/isArrayLike.mjs';
-import { isString } from '../predicate/isString.mjs';
-
-function at(object, ...paths) {
-    if (paths.length === 0) {
-        return [];
-    }
-    const allPaths = [];
-    for (let i = 0; i < paths.length; i++) {
-        const path = paths[i];
-        if (!isArrayLike(path) || isString(path)) {
-            allPaths.push(path);
-            continue;
-        }
-        for (let j = 0; j < path.length; j++) {
-            allPaths.push(path[j]);
-        }
-    }
-    const result = [];
-    for (let i = 0; i < allPaths.length; i++) {
-        result.push(get(object, allPaths[i]));
-    }
-    return result;
-}
-
-export { at };

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

@@ -1,58 +0,0 @@
-/**
- * Iterates over an object and invokes the `iteratee` function for each property.
- *
- * Iterates over string keyed properties including inherited properties.
- *
- * The iteration is terminated early if the `iteratee` function returns `false`.
- *
- * @template T - The type of the object
- * @param {T} object - The object to iterate over
- * @param {(value: T[keyof T], key: string, obj: T) => any} iteratee - The function invoked per iteration
- * @returns {T} Returns the object
- *
- * @example
- * // Iterate over all properties including inherited ones
- * const obj = { a: 1, b: 2 };
- * forIn(obj, (value, key) => {
- *   console.log(key, value);
- * });
- * // Output: 'a' 1, 'b' 2
- *
- * // Early termination
- * forIn(obj, (value, key) => {
- *   console.log(key, value);
- *   return key !== 'a'; // stop after 'a'
- * });
- * // Output: 'a' 1
- */
-declare function forIn<T>(object: T, iteratee?: (value: T[keyof T], key: string, collection: T) => any): T;
-/**
- * Iterates over an object and invokes the `iteratee` function for each property.
- *
- * Iterates over string keyed properties including inherited properties.
- *
- * The iteration is terminated early if the `iteratee` function returns `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, obj: T) => any} iteratee - The function invoked per iteration
- * @returns {T | null | undefined} Returns the object
- *
- * @example
- * // Iterate over all properties including inherited ones
- * const obj = { a: 1, b: 2 };
- * forIn(obj, (value, key) => {
- *   console.log(key, value);
- * });
- * // Output: 'a' 1, 'b' 2
- *
- * // Early termination
- * forIn(obj, (value, key) => {
- *   console.log(key, value);
- *   return key !== 'a'; // stop after 'a'
- * });
- * // Output: 'a' 1
- */
-declare function forIn<T>(object: T | null | undefined, iteratee?: (value: T[keyof T], key: string, collection: T) => any): T | null | undefined;
-
-export { forIn };

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

@@ -1,58 +0,0 @@
-/**
- * Iterates over an object and invokes the `iteratee` function for each property.
- *
- * Iterates over string keyed properties including inherited properties.
- *
- * The iteration is terminated early if the `iteratee` function returns `false`.
- *
- * @template T - The type of the object
- * @param {T} object - The object to iterate over
- * @param {(value: T[keyof T], key: string, obj: T) => any} iteratee - The function invoked per iteration
- * @returns {T} Returns the object
- *
- * @example
- * // Iterate over all properties including inherited ones
- * const obj = { a: 1, b: 2 };
- * forIn(obj, (value, key) => {
- *   console.log(key, value);
- * });
- * // Output: 'a' 1, 'b' 2
- *
- * // Early termination
- * forIn(obj, (value, key) => {
- *   console.log(key, value);
- *   return key !== 'a'; // stop after 'a'
- * });
- * // Output: 'a' 1
- */
-declare function forIn<T>(object: T, iteratee?: (value: T[keyof T], key: string, collection: T) => any): T;
-/**
- * Iterates over an object and invokes the `iteratee` function for each property.
- *
- * Iterates over string keyed properties including inherited properties.
- *
- * The iteration is terminated early if the `iteratee` function returns `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, obj: T) => any} iteratee - The function invoked per iteration
- * @returns {T | null | undefined} Returns the object
- *
- * @example
- * // Iterate over all properties including inherited ones
- * const obj = { a: 1, b: 2 };
- * forIn(obj, (value, key) => {
- *   console.log(key, value);
- * });
- * // Output: 'a' 1, 'b' 2
- *
- * // Early termination
- * forIn(obj, (value, key) => {
- *   console.log(key, value);
- *   return key !== 'a'; // stop after 'a'
- * });
- * // Output: 'a' 1
- */
-declare function forIn<T>(object: T | null | undefined, iteratee?: (value: T[keyof T], key: string, collection: T) => any): T | null | undefined;
-
-export { forIn };

package/dist/compat/object/forIn.mjs

@@ -1,16 +0,0 @@
-import { identity } from '../../function/identity.mjs';
-
-function forIn(object, iteratee = identity) {
-    if (object == null) {
-        return object;
-    }
-    for (const key in object) {
-        const result = iteratee(object[key], key, object);
-        if (result === false) {
-            break;
-        }
-    }
-    return object;
-}
-
-export { forIn };

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

@@ -1,58 +0,0 @@
-/**
- * Iterates over an object in reverse order and invokes the `iteratee` function for each property.
- *
- * Iterates over string keyed properties including inherited properties in reverse order.
- *
- * The iteration is terminated early if the `iteratee` function returns `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 - The function invoked per iteration
- * @returns {T} Returns the object
- *
- * @example
- * // Iterate over all properties including inherited ones
- * const obj = { a: 1, b: 2 };
- * forInRight(obj, (value, key) => {
- *   console.log(key, value);
- * });
- * // Output: 'b' 2, 'a' 1
- *
- * // Early termination
- * forInRight(obj, (value, key) => {
- *   console.log(key, value);
- *   return key !== 'a'; // stop after 'a'
- * });
- * // Output: 'b' 2
- */
-declare function forInRight<T>(object: T, iteratee?: (value: T[keyof T], key: string, collection: T) => any): T;
-/**
- * Iterates over an object in reverse order and invokes the `iteratee` function for each property.
- *
- * Iterates over string keyed properties including inherited properties in reverse order.
- *
- * The iteration is terminated early if the `iteratee` function returns `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, obj: T) => any} iteratee - The function invoked per iteration
- * @returns {T | null | undefined} Returns the object
- *
- * @example
- * // Iterate over all properties including inherited ones
- * const obj = { a: 1, b: 2 };
- * forInRight(obj, (value, key) => {
- *   console.log(key, value);
- * });
- * // Output: 'b' 2, 'a' 1
- *
- * // Early termination
- * forInRight(obj, (value, key) => {
- *   console.log(key, value);
- *   return key !== 'a'; // stop after 'a'
- * });
- * // Output: 'b' 2
- */
-declare function forInRight<T>(object: T | null | undefined, iteratee?: (value: T[keyof T], key: string, collection: T) => any): T | null | undefined;
-
-export { forInRight };

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

@@ -1,58 +0,0 @@
-/**
- * Iterates over an object in reverse order and invokes the `iteratee` function for each property.
- *
- * Iterates over string keyed properties including inherited properties in reverse order.
- *
- * The iteration is terminated early if the `iteratee` function returns `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 - The function invoked per iteration
- * @returns {T} Returns the object
- *
- * @example
- * // Iterate over all properties including inherited ones
- * const obj = { a: 1, b: 2 };
- * forInRight(obj, (value, key) => {
- *   console.log(key, value);
- * });
- * // Output: 'b' 2, 'a' 1
- *
- * // Early termination
- * forInRight(obj, (value, key) => {
- *   console.log(key, value);
- *   return key !== 'a'; // stop after 'a'
- * });
- * // Output: 'b' 2
- */
-declare function forInRight<T>(object: T, iteratee?: (value: T[keyof T], key: string, collection: T) => any): T;
-/**
- * Iterates over an object in reverse order and invokes the `iteratee` function for each property.
- *
- * Iterates over string keyed properties including inherited properties in reverse order.
- *
- * The iteration is terminated early if the `iteratee` function returns `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, obj: T) => any} iteratee - The function invoked per iteration
- * @returns {T | null | undefined} Returns the object
- *
- * @example
- * // Iterate over all properties including inherited ones
- * const obj = { a: 1, b: 2 };
- * forInRight(obj, (value, key) => {
- *   console.log(key, value);
- * });
- * // Output: 'b' 2, 'a' 1
- *
- * // Early termination
- * forInRight(obj, (value, key) => {
- *   console.log(key, value);
- *   return key !== 'a'; // stop after 'a'
- * });
- * // Output: 'b' 2
- */
-declare function forInRight<T>(object: T | null | undefined, iteratee?: (value: T[keyof T], key: string, collection: T) => any): T | null | undefined;
-
-export { forInRight };

package/dist/compat/object/forInRight.mjs

@@ -1,21 +0,0 @@
-import { identity } from '../../function/identity.mjs';
-
-function forInRight(object, iteratee = identity) {
-    if (object == null) {
-        return object;
-    }
-    const keys = [];
-    for (const key in object) {
-        keys.push(key);
-    }
-    for (let i = keys.length - 1; i >= 0; i--) {
-        const key = keys[i];
-        const result = iteratee(object[key], key, object);
-        if (result === false) {
-            break;
-        }
-    }
-    return object;
-}
-
-export { forInRight };