es-toolkit 1.35.0 → 1.36.0

package/dist/compat/index.mjs

@@ -1,16 +1,12 @@
 export { countBy } from '../array/countBy.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 { initial } from '../array/initial.mjs';
 export { isSubset } from '../array/isSubset.mjs';
 export { isSubsetWith } from '../array/isSubsetWith.mjs';
 export { keyBy } from '../array/keyBy.mjs';
-export { partition } from '../array/partition.mjs';
-export { pullAt } from '../array/pullAt.mjs';
 export { sampleSize } from '../array/sampleSize.mjs';
 export { shuffle } from '../array/shuffle.mjs';
+export { toInteger } from './util/toInteger.mjs';
 export { toFilled } from '../array/toFilled.mjs';
 export { unzipWith } from '../array/unzipWith.mjs';
 export { windowed } from '../array/windowed.mjs';
@@ -24,8 +20,8 @@ export { identity } from '../function/identity.mjs';
 export { memoize } from '../function/memoize.mjs';
 export { noop } from '../function/noop.mjs';
 export { once } from '../function/once.mjs';
-export { partial } from '../function/partial.mjs';
-export { partialRight } from '../function/partialRight.mjs';
+import '../function/partial.mjs';
+import '../function/partialRight.mjs';
 export { retry } from '../function/retry.mjs';
 export { unary } from '../function/unary.mjs';
 export { median } from '../math/median.mjs';
@@ -83,10 +79,13 @@ export { find } from './array/find.mjs';
 export { findIndex } from './array/findIndex.mjs';
 export { findLast } from './array/findLast.mjs';
 export { findLastIndex } from './array/findLastIndex.mjs';
+export { flatMap } from './array/flatMap.mjs';
 export { flatten } from './array/flatten.mjs';
 export { flattenDeep } from './array/flattenDeep.mjs';
 export { flattenDepth } from './array/flattenDepth.mjs';
 export { forEach as each, forEach } from './array/forEach.mjs';
+export { forEachRight as eachRight, forEachRight } from './array/forEachRight.mjs';
+export { groupBy } from './array/groupBy.mjs';
 export { head as first, head } from './array/head.mjs';
 export { includes } from './array/includes.mjs';
 export { indexOf } from './array/indexOf.mjs';
@@ -99,9 +98,12 @@ export { lastIndexOf } from './array/lastIndexOf.mjs';
 export { map } from './array/map.mjs';
 export { nth } from './array/nth.mjs';
 export { orderBy } from './array/orderBy.mjs';
+export { partition } from './array/partition.mjs';
 export { pull } from './array/pull.mjs';
 export { pullAll } from './array/pullAll.mjs';
 export { pullAllBy } from './array/pullAllBy.mjs';
+export { pullAllWith } from './array/pullAllWith.mjs';
+export { pullAt } from './array/pullAt.mjs';
 export { reduce } from './array/reduce.mjs';
 export { reduceRight } from './array/reduceRight.mjs';
 export { reject } from './array/reject.mjs';
@@ -150,6 +152,8 @@ export { flow } from './function/flow.mjs';
 export { flowRight } from './function/flowRight.mjs';
 export { negate } from './function/negate.mjs';
 export { nthArg } from './function/nthArg.mjs';
+export { partial } from './function/partial.mjs';
+export { partialRight } from './function/partialRight.mjs';
 export { rearg } from './function/rearg.mjs';
 export { rest } from './function/rest.mjs';
 export { spread } from './function/spread.mjs';
@@ -185,11 +189,16 @@ export { cloneDeepWith } from './object/cloneDeepWith.mjs';
 export { create } from './object/create.mjs';
 export { defaults } from './object/defaults.mjs';
 export { findKey } from './object/findKey.mjs';
+export { forIn } from './object/forIn.mjs';
+export { forInRight } from './object/forInRight.mjs';
+export { forOwn } from './object/forOwn.mjs';
+export { forOwnRight } from './object/forOwnRight.mjs';
 export { fromPairs } from './object/fromPairs.mjs';
 export { functions } from './object/functions.mjs';
 export { functionsIn } from './object/functionsIn.mjs';
 export { get } from './object/get.mjs';
 export { has } from './object/has.mjs';
+export { hasIn } from './object/hasIn.mjs';
 export { invertBy } from './object/invertBy.mjs';
 export { keys } from './object/keys.mjs';
 export { keysIn } from './object/keysIn.mjs';
@@ -284,6 +293,8 @@ export { method } from './util/method.mjs';
 export { methodOf } from './util/methodOf.mjs';
 export { now } from './util/now.mjs';
 export { over } from './util/over.mjs';
+export { overEvery } from './util/overEvery.mjs';
+export { overSome } from './util/overSome.mjs';
 export { stubArray } from './util/stubArray.mjs';
 export { stubFalse } from './util/stubFalse.mjs';
 export { stubObject } from './util/stubObject.mjs';
@@ -292,7 +303,6 @@ export { stubTrue } from './util/stubTrue.mjs';
 export { times } from './util/times.mjs';
 export { toArray } from './util/toArray.mjs';
 export { toFinite } from './util/toFinite.mjs';
-export { toInteger } from './util/toInteger.mjs';
 export { toLength } from './util/toLength.mjs';
 export { toNumber } from './util/toNumber.mjs';
 export { toPath } from './util/toPath.mjs';
@@ -300,3 +310,4 @@ export { toPlainObject } from './util/toPlainObject.mjs';
 export { toSafeInteger } from './util/toSafeInteger.mjs';
 export { toString } from './util/toString.mjs';
 export { uniqueId } from './util/uniqueId.mjs';
+export { toolkit as default } from './toolkit.mjs';

package/dist/compat/object/defaults.mjs

@@ -1,9 +1,15 @@
+import { isIterateeCall } from '../_internal/isIterateeCall.mjs';
 import { eq } from '../util/eq.mjs';
 
 function defaults(object, ...sources) {
     object = Object(object);
     const objectProto = Object.prototype;
-    for (let i = 0; i < sources.length; i++) {
+    let length = sources.length;
+    const guard = length > 2 ? sources[2] : undefined;
+    if (guard && isIterateeCall(sources[0], sources[1], guard)) {
+        length = 1;
+    }
+    for (let i = 0; i < length; i++) {
         const source = sources[i];
         const keys = Object.keys(source);
         for (let j = 0; j < keys.length; j++) {

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

@@ -0,0 +1,58 @@
+/**
+ * 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

@@ -0,0 +1,58 @@
+/**
+ * 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

@@ -0,0 +1,16 @@
+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

@@ -0,0 +1,58 @@
+/**
+ * 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

@@ -0,0 +1,58 @@
+/**
+ * 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

@@ -0,0 +1,21 @@
+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 };

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

@@ -0,0 +1,54 @@
+/**
+ * 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

@@ -0,0 +1,54 @@
+/**
+ * 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

@@ -0,0 +1,19 @@
+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

@@ -0,0 +1,54 @@
+/**
+ * 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

@@ -0,0 +1,54 @@
+/**
+ * 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

@@ -0,0 +1,19 @@
+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 };