es-toolkit 1.25.2-dev.802 → 1.25.2-dev.804

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

@@ -7,6 +7,7 @@
  * @template T - The type of elements in the array.
  * @param {ArrayLike<T> | null | undefined} collection - The array from which to drop elements.
  * @param {number} itemsCount - The number of elements to drop from the beginning of the array.
+ * @param {unknown} [guard] - Enables use as an iteratee for methods like `_.map`.
  * @returns {T[]} A new array with the specified number of elements removed from the start.
  *
  * @example
@@ -14,6 +15,6 @@
  * const result = drop(array, 2);
  * result will be [3, 4, 5] since the first two elements are dropped.
  */
-declare function drop<T>(collection: ArrayLike<T> | null | undefined, itemsCount: number): T[];
+declare function drop<T>(collection: ArrayLike<T> | null | undefined, itemsCount?: number, guard?: unknown): T[];
 
 export { drop };

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

@@ -7,6 +7,7 @@
  * @template T - The type of elements in the array.
  * @param {ArrayLike<T> | null | undefined} collection - The array from which to drop elements.
  * @param {number} itemsCount - The number of elements to drop from the beginning of the array.
+ * @param {unknown} [guard] - Enables use as an iteratee for methods like `_.map`.
  * @returns {T[]} A new array with the specified number of elements removed from the start.
  *
  * @example
@@ -14,6 +15,6 @@
  * const result = drop(array, 2);
  * result will be [3, 4, 5] since the first two elements are dropped.
  */
-declare function drop<T>(collection: ArrayLike<T> | null | undefined, itemsCount: number): T[];
+declare function drop<T>(collection: ArrayLike<T> | null | undefined, itemsCount?: number, guard?: unknown): T[];
 
 export { drop };

package/dist/compat/array/drop.mjs

@@ -1,10 +1,12 @@
 import { drop as drop$1 } from '../../array/drop.mjs';
 import { isArrayLike } from '../predicate/isArrayLike.mjs';
+import { toInteger } from '../util/toInteger.mjs';
 
-function drop(collection, itemsCount) {
+function drop(collection, itemsCount = 1, guard) {
     if (!isArrayLike(collection)) {
         return [];
     }
+    itemsCount = guard ? 1 : toInteger(itemsCount);
     return drop$1(Array.from(collection), itemsCount);
 }
 

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

@@ -7,6 +7,7 @@
  * @template T - The type of elements in the array.
  * @param {ArrayLike<T> | null | undefined} collection - The array from which to drop elements.
  * @param {number} itemsCount - The number of elements to drop from the end of the array.
+ * @param {unknown} [guard] - Enables use as an iteratee for methods like `_.map`.
  * @returns {T[]} A new array with the specified number of elements removed from the end.
  *
  * @example
@@ -14,6 +15,6 @@
  * const result = dropRight(array, 2);
  * // result will be [1, 2, 3] since the last two elements are dropped.
  */
-declare function dropRight<T>(collection: ArrayLike<T> | null | undefined, itemsCount: number): T[];
+declare function dropRight<T>(collection: ArrayLike<T> | null | undefined, itemsCount?: number, guard?: unknown): T[];
 
 export { dropRight };

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

@@ -7,6 +7,7 @@
  * @template T - The type of elements in the array.
  * @param {ArrayLike<T> | null | undefined} collection - The array from which to drop elements.
  * @param {number} itemsCount - The number of elements to drop from the end of the array.
+ * @param {unknown} [guard] - Enables use as an iteratee for methods like `_.map`.
  * @returns {T[]} A new array with the specified number of elements removed from the end.
  *
  * @example
@@ -14,6 +15,6 @@
  * const result = dropRight(array, 2);
  * // result will be [1, 2, 3] since the last two elements are dropped.
  */
-declare function dropRight<T>(collection: ArrayLike<T> | null | undefined, itemsCount: number): T[];
+declare function dropRight<T>(collection: ArrayLike<T> | null | undefined, itemsCount?: number, guard?: unknown): T[];
 
 export { dropRight };

package/dist/compat/array/dropRight.mjs

@@ -1,10 +1,12 @@
 import { dropRight as dropRight$1 } from '../../array/dropRight.mjs';
 import { isArrayLike } from '../predicate/isArrayLike.mjs';
+import { toInteger } from '../util/toInteger.mjs';
 
-function dropRight(collection, itemsCount) {
+function dropRight(collection, itemsCount = 1, guard) {
     if (!isArrayLike(collection)) {
         return [];
     }
+    itemsCount = guard ? 1 : toInteger(itemsCount);
     return dropRight$1(Array.from(collection), itemsCount);
 }
 

package/dist/compat/array/every.mjs

@@ -1,13 +1,17 @@
 import { identity } from '../_internal/identity.mjs';
+import { isIterateeCall } from '../_internal/isIterateeCall.mjs';
 import { property } from '../object/property.mjs';
 import { matches } from '../predicate/matches.mjs';
 import { matchesProperty } from '../predicate/matchesProperty.mjs';
 
-function every(source, doesMatch) {
+function every(source, doesMatch, guard) {
     if (!source) {
         return true;
     }
     const values = Array.isArray(source) ? source : Object.values(source);
+    if (guard && isIterateeCall(source, doesMatch, guard)) {
+        doesMatch = undefined;
+    }
     if (!doesMatch) {
         doesMatch = identity;
     }

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

@@ -1,30 +1,33 @@
 /**
  * Checks if there is an element in an array that is truthy.
  *
- * @param {T[]} arr The array to iterate over.
+ * @template T
+ * @param {ArrayLike<T> | null | undefined} arr The array to iterate over.
  * @returns {boolean} Returns `true` if any element is truthy, else `false`.
  *
  * @example
  * some([1, 2, 3, 4]);
  * // => true
  */
-declare function some<T>(arr: readonly T[]): boolean;
+declare function some<T>(arr: ArrayLike<T> | null | undefined): boolean;
 /**
  * Checks if there is an element in an array that matches the given predicate function.
  *
- * @param {T[]} arr The array to iterate over.
- * @param {(item: T, index: number, arr: any) => unknown} predicate The function invoked per iteration.
+ * @template T
+ * @param {ArrayLike<T> | null | undefined} arr The array to iterate over.
+ * @param {(item: T, index: number, arr: readonly T[]) => unknown} predicate The function invoked per iteration.
  * @returns {boolean} Returns `true` if any element passes the predicate check, else `false`.
  *
  * @example
  * some([1, 2, 3, 4], n => n % 2 === 0);
  * // => true
  */
-declare function some<T>(arr: readonly T[], predicate: (item: T, index: number, arr: any) => unknown): boolean;
+declare function some<T>(arr: ArrayLike<T> | null | undefined, predicate: (item: T, index: number, arr: readonly T[]) => unknown): boolean;
 /**
  * Checks if there is an element in an array that matches the given key-value pair.
  *
- * @param {T[]} arr The array to iterate over.
+ * @template T
+ * @param {ArrayLike<T> | null | undefined} arr The array to iterate over.
  * @param {[keyof T, unknown]} predicate The key-value pair to match.
  * @returns {boolean} Returns `true` if any element passes the predicate check, else `false`.
  *
@@ -32,11 +35,12 @@ declare function some<T>(arr: readonly T[], predicate: (item: T, index: number,
  * some([{ a: 1 }, { a: 2 }, { a: 3 }], ['a', 2]);
  * // => true
  */
-declare function some<T>(arr: readonly T[], predicate: [keyof T, unknown]): boolean;
+declare function some<T>(arr: ArrayLike<T> | null | undefined, predicate: [keyof T, unknown]): boolean;
 /**
  * Checks if there is an element in an array that has a truthy value for the given property name.
  *
- * @param {T[]} arr The array to iterate over.
+ * @template T
+ * @param {ArrayLike<T> | null | undefined} arr The array to iterate over.
  * @param {string} propertyToCheck The property name to check.
  * @returns {boolean} Returns `true` if any element has a truthy value for the property, else `false`.
  *
@@ -44,11 +48,12 @@ declare function some<T>(arr: readonly T[], predicate: [keyof T, unknown]): bool
  * some([{ a: 1 }, { a: 2 }, { a: 3 }], 'a');
  * // => true
  */
-declare function some<T>(arr: readonly T[], propertyToCheck: string): boolean;
+declare function some<T>(arr: ArrayLike<T> | null | undefined, propertyToCheck: string): boolean;
 /**
  * Checks if there is an element in an array that matches the given partial object.
  *
- * @param {T[]} arr The array to iterate over.
+ * @template T
+ * @param {ArrayLike<T> | null | undefined} arr The array to iterate over.
  * @param {Partial<T>} doesMatch The partial object to match.
  * @returns {boolean} Returns `true` if any element matches the partial object, else `false`.
  *
@@ -56,30 +61,77 @@ declare function some<T>(arr: readonly T[], propertyToCheck: string): boolean;
  * some([{ a: 1 }, { a: 2 }, { a: 3 }], { a: 2 });
  * // => true
  */
-declare function some<T>(arr: readonly T[], doesMatch: Partial<T>): boolean;
+declare function some<T>(arr: ArrayLike<T> | null | undefined, doesMatch: Partial<T>): boolean;
 /**
- * Checks if there is an element in an array that matches the given predicate.
  *
- * Iteration is stopped once there is an element that matches `predicate`.
+ * Checks if there is an element in an object that matches the given predicate function.
  *
- * @param {T[]} arr The array to iterate over.
- * @param {((item: T, index: number, arr: any) => unknown) | Partial<T> | [keyof T, unknown] | string} [predicate=identity] The function invoked per iteration.
- * If a property name or an object is provided it will be used to create a predicate function.
+ * @template T
+ * @param {T | null | undefined} object The object to iterate over.
+ * @returns {boolean} Returns `true` if any element is truthy, else `false`.
+ *
+ * @example
+ * some({ a: 1, b: 2, c: 3 });
+ * // => true
+ */
+declare function some<T extends Record<string, unknown>>(object: T | null | undefined): boolean;
+/**
+ *
+ * Checks if there is an element in an object that matches the given predicate function.
+ *
+ * @template T
+ * @param {T | null | undefined} object The object to iterate over.
+ * @param {(value: T[keyof T], key: keyof T, object: T) => unknown} doesMatch A function that takes an value, its key, and the object, and returns a truthy value if the item matches the criteria.
  * @returns {boolean} Returns `true` if any element passes the predicate check, else `false`.
  *
  * @example
- * some([1, 2, 3, 4], n => n % 2 === 0);
+ * some({ a: 1, b: 2, c: 3 }, n => n % 2 === 0);
  * // => true
+ */
+declare function some<T extends Record<string, unknown>>(object: T | null | undefined, doesMatch: (value: T[keyof T], key: keyof T, object: T) => unknown): boolean;
+/**
  *
- * some([{ a: 1 }, { a: 2 }, { a: 3 }], { a: 2 });
+ * Checks if there is an element in an object that matches the given partial value.
+ *
+ * @template T
+ * @param {T | null | undefined} object The object to iterate over.
+ * @param {Partial<T[keyof T]>} doesMatch A partial value to match against the values of the object.
+ * @returns {boolean} Returns `true` if any element passes the predicate check, else `false`.
+ *
+ * @example
+ * some({ a: { id: 1, name: 'Alice' }, b: { id: 2, name: 'Bob' } }, { name: 'Bob' });
  * // => true
+ */
+declare function some<T extends Record<string, unknown>>(object: T | null | undefined, doesMatch: Partial<T[keyof T]>): boolean;
+/**
  *
- * some([{ a: 1 }, { a: 2 }, { a: 3 }], ['a', 2]);
+ * Checks if there is an element in an object that matches a property with a specific value.
+ *
+ * @template T
+ * @param {T | null | undefined} object The object to iterate over.
+ * @param {[keyof T, unknown]} doesMatchProperty An array where the first element is the property key and the second element is the value to match.
+ * @returns {boolean} Returns `true` if any element passes the predicate check, else `false`.
+ *
+ * @example
+ * const obj = { alice: { id: 1, name: 'Alice' }, bob: { id: 2, name: 'Bob' } };
+ * const result = some(obj, ['name', 'Alice']);
  * // => true
+ */
+declare function some<T extends Record<string, unknown>>(object: T | null | undefined, doesMatchProperty: [keyof T[keyof T], unknown]): boolean;
+/**
  *
- * some([{ a: 1 }, { a: 2 }, { a: 3 }], 'a');
+ * Checks if there is an element in an object that has a specific property, where the property name is provided as a string.
+ *
+ * @template T
+ * @param {T | null | undefined} object The object to iterate over.
+ * @param {string} propertyToCheck The property name to check.
+ * @returns {boolean} Returns `true` if any element passes the predicate check, else `false`.
+ *
+ * @example
+ * const obj = { alice: { id: 1, name: 'Alice' }, bob: { id: 2, name: 'Bob' } };
+ * const result = some(obj, 'name');
  * // => true
  */
-declare function some<T>(arr: readonly T[] | null | undefined, predicate?: ((item: T, index: number, arr: any) => unknown) | Partial<T> | [keyof T, unknown] | string, guard?: unknown): boolean;
+declare function some<T extends Record<string, unknown>>(object: T | null | undefined, propertyToCheck: string): boolean;
 
 export { some };

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

@@ -1,30 +1,33 @@
 /**
  * Checks if there is an element in an array that is truthy.
  *
- * @param {T[]} arr The array to iterate over.
+ * @template T
+ * @param {ArrayLike<T> | null | undefined} arr The array to iterate over.
  * @returns {boolean} Returns `true` if any element is truthy, else `false`.
  *
  * @example
  * some([1, 2, 3, 4]);
  * // => true
  */
-declare function some<T>(arr: readonly T[]): boolean;
+declare function some<T>(arr: ArrayLike<T> | null | undefined): boolean;
 /**
  * Checks if there is an element in an array that matches the given predicate function.
  *
- * @param {T[]} arr The array to iterate over.
- * @param {(item: T, index: number, arr: any) => unknown} predicate The function invoked per iteration.
+ * @template T
+ * @param {ArrayLike<T> | null | undefined} arr The array to iterate over.
+ * @param {(item: T, index: number, arr: readonly T[]) => unknown} predicate The function invoked per iteration.
  * @returns {boolean} Returns `true` if any element passes the predicate check, else `false`.
  *
  * @example
  * some([1, 2, 3, 4], n => n % 2 === 0);
  * // => true
  */
-declare function some<T>(arr: readonly T[], predicate: (item: T, index: number, arr: any) => unknown): boolean;
+declare function some<T>(arr: ArrayLike<T> | null | undefined, predicate: (item: T, index: number, arr: readonly T[]) => unknown): boolean;
 /**
  * Checks if there is an element in an array that matches the given key-value pair.
  *
- * @param {T[]} arr The array to iterate over.
+ * @template T
+ * @param {ArrayLike<T> | null | undefined} arr The array to iterate over.
  * @param {[keyof T, unknown]} predicate The key-value pair to match.
  * @returns {boolean} Returns `true` if any element passes the predicate check, else `false`.
  *
@@ -32,11 +35,12 @@ declare function some<T>(arr: readonly T[], predicate: (item: T, index: number,
  * some([{ a: 1 }, { a: 2 }, { a: 3 }], ['a', 2]);
  * // => true
  */
-declare function some<T>(arr: readonly T[], predicate: [keyof T, unknown]): boolean;
+declare function some<T>(arr: ArrayLike<T> | null | undefined, predicate: [keyof T, unknown]): boolean;
 /**
  * Checks if there is an element in an array that has a truthy value for the given property name.
  *
- * @param {T[]} arr The array to iterate over.
+ * @template T
+ * @param {ArrayLike<T> | null | undefined} arr The array to iterate over.
  * @param {string} propertyToCheck The property name to check.
  * @returns {boolean} Returns `true` if any element has a truthy value for the property, else `false`.
  *
@@ -44,11 +48,12 @@ declare function some<T>(arr: readonly T[], predicate: [keyof T, unknown]): bool
  * some([{ a: 1 }, { a: 2 }, { a: 3 }], 'a');
  * // => true
  */
-declare function some<T>(arr: readonly T[], propertyToCheck: string): boolean;
+declare function some<T>(arr: ArrayLike<T> | null | undefined, propertyToCheck: string): boolean;
 /**
  * Checks if there is an element in an array that matches the given partial object.
  *
- * @param {T[]} arr The array to iterate over.
+ * @template T
+ * @param {ArrayLike<T> | null | undefined} arr The array to iterate over.
  * @param {Partial<T>} doesMatch The partial object to match.
  * @returns {boolean} Returns `true` if any element matches the partial object, else `false`.
  *
@@ -56,30 +61,77 @@ declare function some<T>(arr: readonly T[], propertyToCheck: string): boolean;
  * some([{ a: 1 }, { a: 2 }, { a: 3 }], { a: 2 });
  * // => true
  */
-declare function some<T>(arr: readonly T[], doesMatch: Partial<T>): boolean;
+declare function some<T>(arr: ArrayLike<T> | null | undefined, doesMatch: Partial<T>): boolean;
 /**
- * Checks if there is an element in an array that matches the given predicate.
  *
- * Iteration is stopped once there is an element that matches `predicate`.
+ * Checks if there is an element in an object that matches the given predicate function.
  *
- * @param {T[]} arr The array to iterate over.
- * @param {((item: T, index: number, arr: any) => unknown) | Partial<T> | [keyof T, unknown] | string} [predicate=identity] The function invoked per iteration.
- * If a property name or an object is provided it will be used to create a predicate function.
+ * @template T
+ * @param {T | null | undefined} object The object to iterate over.
+ * @returns {boolean} Returns `true` if any element is truthy, else `false`.
+ *
+ * @example
+ * some({ a: 1, b: 2, c: 3 });
+ * // => true
+ */
+declare function some<T extends Record<string, unknown>>(object: T | null | undefined): boolean;
+/**
+ *
+ * Checks if there is an element in an object that matches the given predicate function.
+ *
+ * @template T
+ * @param {T | null | undefined} object The object to iterate over.
+ * @param {(value: T[keyof T], key: keyof T, object: T) => unknown} doesMatch A function that takes an value, its key, and the object, and returns a truthy value if the item matches the criteria.
  * @returns {boolean} Returns `true` if any element passes the predicate check, else `false`.
  *
  * @example
- * some([1, 2, 3, 4], n => n % 2 === 0);
+ * some({ a: 1, b: 2, c: 3 }, n => n % 2 === 0);
  * // => true
+ */
+declare function some<T extends Record<string, unknown>>(object: T | null | undefined, doesMatch: (value: T[keyof T], key: keyof T, object: T) => unknown): boolean;
+/**
  *
- * some([{ a: 1 }, { a: 2 }, { a: 3 }], { a: 2 });
+ * Checks if there is an element in an object that matches the given partial value.
+ *
+ * @template T
+ * @param {T | null | undefined} object The object to iterate over.
+ * @param {Partial<T[keyof T]>} doesMatch A partial value to match against the values of the object.
+ * @returns {boolean} Returns `true` if any element passes the predicate check, else `false`.
+ *
+ * @example
+ * some({ a: { id: 1, name: 'Alice' }, b: { id: 2, name: 'Bob' } }, { name: 'Bob' });
  * // => true
+ */
+declare function some<T extends Record<string, unknown>>(object: T | null | undefined, doesMatch: Partial<T[keyof T]>): boolean;
+/**
  *
- * some([{ a: 1 }, { a: 2 }, { a: 3 }], ['a', 2]);
+ * Checks if there is an element in an object that matches a property with a specific value.
+ *
+ * @template T
+ * @param {T | null | undefined} object The object to iterate over.
+ * @param {[keyof T, unknown]} doesMatchProperty An array where the first element is the property key and the second element is the value to match.
+ * @returns {boolean} Returns `true` if any element passes the predicate check, else `false`.
+ *
+ * @example
+ * const obj = { alice: { id: 1, name: 'Alice' }, bob: { id: 2, name: 'Bob' } };
+ * const result = some(obj, ['name', 'Alice']);
  * // => true
+ */
+declare function some<T extends Record<string, unknown>>(object: T | null | undefined, doesMatchProperty: [keyof T[keyof T], unknown]): boolean;
+/**
  *
- * some([{ a: 1 }, { a: 2 }, { a: 3 }], 'a');
+ * Checks if there is an element in an object that has a specific property, where the property name is provided as a string.
+ *
+ * @template T
+ * @param {T | null | undefined} object The object to iterate over.
+ * @param {string} propertyToCheck The property name to check.
+ * @returns {boolean} Returns `true` if any element passes the predicate check, else `false`.
+ *
+ * @example
+ * const obj = { alice: { id: 1, name: 'Alice' }, bob: { id: 2, name: 'Bob' } };
+ * const result = some(obj, 'name');
  * // => true
  */
-declare function some<T>(arr: readonly T[] | null | undefined, predicate?: ((item: T, index: number, arr: any) => unknown) | Partial<T> | [keyof T, unknown] | string, guard?: unknown): boolean;
+declare function some<T extends Record<string, unknown>>(object: T | null | undefined, propertyToCheck: string): boolean;
 
 export { some };

package/dist/compat/array/some.mjs

@@ -3,32 +3,44 @@ import { property } from '../object/property.mjs';
 import { matches } from '../predicate/matches.mjs';
 import { matchesProperty } from '../predicate/matchesProperty.mjs';
 
-function some(arr, predicate, guard) {
+function some(source, predicate, guard) {
+    if (!source) {
+        return false;
+    }
     if (guard != null) {
         predicate = undefined;
     }
     if (!predicate) {
         predicate = identity;
     }
-    if (!Array.isArray(arr)) {
-        return false;
-    }
+    const values = Array.isArray(source) ? source : Object.values(source);
     switch (typeof predicate) {
         case 'function': {
-            return arr.some(predicate);
+            if (!Array.isArray(source)) {
+                const keys = Object.keys(source);
+                for (let i = 0; i < keys.length; i++) {
+                    const key = keys[i];
+                    const value = source[key];
+                    if (predicate(value, key, source)) {
+                        return true;
+                    }
+                }
+                return false;
+            }
+            return values.some(predicate);
         }
         case 'object': {
             if (Array.isArray(predicate) && predicate.length === 2) {
                 const key = predicate[0];
                 const value = predicate[1];
-                return arr.some(matchesProperty(key, value));
+                return values.some(matchesProperty(key, value));
             }
             else {
-                return arr.some(matches(predicate));
+                return values.some(matches(predicate));
             }
         }
         case 'string': {
-            return arr.some(property(predicate));
+            return values.some(property(predicate));
         }
     }
 }

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

@@ -6,6 +6,7 @@
  *
  * @param {ArrayLike<T> | null | undefined} arr - The array to take elements from.
  * @param {number} [count=1] - The number of elements to take.
+ * @param {unknown} [guard] - Enables use as an iteratee for methods like `_.map`.
  * @returns {T[]} A new array containing the first `count` elements from `arr`.
  *
  * @example
@@ -20,6 +21,6 @@
  * // Returns [1, 2, 3]
  * take([1, 2, 3], 5);
  */
-declare function take<T>(arr: ArrayLike<T> | null | undefined, count?: number): T[];
+declare function take<T>(arr: ArrayLike<T> | null | undefined, count?: number, guard?: unknown): T[];
 
 export { take };

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

@@ -6,6 +6,7 @@
  *
  * @param {ArrayLike<T> | null | undefined} arr - The array to take elements from.
  * @param {number} [count=1] - The number of elements to take.
+ * @param {unknown} [guard] - Enables use as an iteratee for methods like `_.map`.
  * @returns {T[]} A new array containing the first `count` elements from `arr`.
  *
  * @example
@@ -20,6 +21,6 @@
  * // Returns [1, 2, 3]
  * take([1, 2, 3], 5);
  */
-declare function take<T>(arr: ArrayLike<T> | null | undefined, count?: number): T[];
+declare function take<T>(arr: ArrayLike<T> | null | undefined, count?: number, guard?: unknown): T[];
 
 export { take };

package/dist/compat/array/take.mjs

@@ -1,7 +1,9 @@
 import { take as take$1 } from '../../array/take.mjs';
 import { isArrayLike } from '../predicate/isArrayLike.mjs';
+import { toInteger } from '../util/toInteger.mjs';
 
-function take(arr, count = 1) {
+function take(arr, count = 1, guard) {
+    count = guard ? 1 : toInteger(count);
     if (count < 1 || !isArrayLike(arr)) {
         return [];
     }

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

@@ -5,6 +5,7 @@
  * @template T - The type of elements in the array.
  * @param {ArrayLike<T> | null | undefined} arr - The array to take elements from.
  * @param {number} [count=1] - The number of elements to take.
+ * @param {unknown} [guard] - Enables use as an iteratee for methods like `_.map`.
  * @returns {T[]} A new array containing the last `count` elements from `arr`.
  *
  * @example
@@ -19,6 +20,6 @@
  * // Returns [1, 2, 3]
  * takeRight([1, 2, 3], 5);
  */
-declare function takeRight<T>(arr: ArrayLike<T> | null | undefined, count?: number): T[];
+declare function takeRight<T>(arr: ArrayLike<T> | null | undefined, count?: number, guard?: unknown): T[];
 
 export { takeRight };

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

@@ -5,6 +5,7 @@
  * @template T - The type of elements in the array.
  * @param {ArrayLike<T> | null | undefined} arr - The array to take elements from.
  * @param {number} [count=1] - The number of elements to take.
+ * @param {unknown} [guard] - Enables use as an iteratee for methods like `_.map`.
  * @returns {T[]} A new array containing the last `count` elements from `arr`.
  *
  * @example
@@ -19,6 +20,6 @@
  * // Returns [1, 2, 3]
  * takeRight([1, 2, 3], 5);
  */
-declare function takeRight<T>(arr: ArrayLike<T> | null | undefined, count?: number): T[];
+declare function takeRight<T>(arr: ArrayLike<T> | null | undefined, count?: number, guard?: unknown): T[];
 
 export { takeRight };

package/dist/compat/array/takeRight.mjs

@@ -1,7 +1,9 @@
 import { takeRight as takeRight$1 } from '../../array/takeRight.mjs';
 import { isArrayLike } from '../predicate/isArrayLike.mjs';
+import { toInteger } from '../util/toInteger.mjs';
 
-function takeRight(arr, count = 1) {
+function takeRight(arr, count = 1, guard) {
+    count = guard ? 1 : toInteger(count);
     if (count <= 0 || !isArrayLike(arr)) {
         return [];
     }