es-toolkit 1.10.1 → 1.11.0-dev.263

package/CHANGELOG.md

@@ -1,5 +1,38 @@
 # es-toolkit Changelog
 
+## Version v1.11.0
+
+Released on July 18th, 2024.
+
+### Introducing `es-toolkit/compat`
+
+We're introducing `es-toolkit/compat`, a new module designed as a drop-in replacement for lodash. It replicates lodash's API, making it easier to switch between the two libraries.
+
+`es-toolkit/compat` is undergoing rigorous testing using real `lodash` test cases. Initial benchmarks suggest it's typically 5% slower and increases bundle size by 10% compared to the original `es-toolkit`.
+
+This module is intended to facilitate a smooth transition and should be replaced with the original `es-toolkit` for optimal performance once migration is complete.
+
+For more information, see our [compatibility documentation](https://es-toolkit.slash.page/compatibility.html).
+
+### Features 
+
+- Added support for [get](https://es-toolkit.slash.page/reference/compat/object/get.html) and [set](https://es-toolkit.slash.page/reference/compat/object/set.html) in our compatibility layer `es-toolkit/compat`. (https://github.com/toss/es-toolkit/pull/232, https://github.com/toss/es-toolkit/pull/223)
+- Added support for [zipObjectDeep](https://es-toolkit.slash.page/reference/compat/array/zipObjectDeep.html) in our compatibility layer `es-toolkit/compat`. (https://github.com/toss/es-toolkit/pull/150)
+- Added support for [flatMap](https://es-toolkit.slash.page/reference/compat/array/flatMap.html). (https://github.com/toss/es-toolkit/pull/209)
+- Added support for [startCase](https://es-toolkit.slash.page/reference/string/startCase.html), [startsWith](https://es-toolkit.slash.page/reference/string/startsWith.html), and [endsWith](https://es-toolkit.slash.page/reference/string/endsWith.html). (https://github.com/toss/es-toolkit/pull/224).
+- Added support for [withTimeout](https://es-toolkit.slash.page/reference/promise/withTimeout.html). (https://github.com/toss/es-toolkit/pull/210)
+
+### Bug fixes
+
+- Fixed `drop` and `dropRight` incorrectly accepting negative integers. (https://github.com/toss/es-toolkit/pull/218)
+- Fixed `invert` not to invert inherited properties. (https://github.com/toss/es-toolkit/pull/221)
+
+### Performance Improvements
+
+- Improved performance for `dropRightWhile`. (https://github.com/toss/es-toolkit/pull/220)
+
+
+
 ## Version v1.10.1
 
 Released on July 15th, 2024.

package/compat.d.ts

@@ -0,0 +1 @@
+export * from './dist/compat';

package/dist/array/chunk.mjs

@@ -1,7 +1,7 @@
 import {
   chunk
 } from "../chunk-E6C5EZQA.mjs";
-import "../chunk-2MM5EJJX.mjs";
+import "../chunk-424M7IR7.mjs";
 export {
   chunk
 };

package/dist/array/compact.mjs

@@ -1,7 +1,7 @@
 import {
   compact
 } from "../chunk-DTJJIMKJ.mjs";
-import "../chunk-2MM5EJJX.mjs";
+import "../chunk-424M7IR7.mjs";
 export {
   compact
 };

package/dist/array/countBy.mjs

@@ -1,7 +1,7 @@
 import {
   countBy
 } from "../chunk-CRSKT4WW.mjs";
-import "../chunk-2MM5EJJX.mjs";
+import "../chunk-424M7IR7.mjs";
 export {
   countBy
 };

package/dist/array/difference.mjs

@@ -1,7 +1,7 @@
 import {
   difference
 } from "../chunk-JPUKH67K.mjs";
-import "../chunk-2MM5EJJX.mjs";
+import "../chunk-424M7IR7.mjs";
 export {
   difference
 };

package/dist/array/differenceBy.mjs

@@ -1,7 +1,7 @@
 import {
   differenceBy
 } from "../chunk-LVWX5B43.mjs";
-import "../chunk-2MM5EJJX.mjs";
+import "../chunk-424M7IR7.mjs";
 export {
   differenceBy
 };

package/dist/array/differenceWith.mjs

@@ -1,7 +1,7 @@
 import {
   differenceWith
 } from "../chunk-6NVQAHXP.mjs";
-import "../chunk-2MM5EJJX.mjs";
+import "../chunk-424M7IR7.mjs";
 export {
   differenceWith
 };

package/dist/array/drop.js

@@ -24,6 +24,7 @@ __export(drop_exports, {
 });
 module.exports = __toCommonJS(drop_exports);
 function drop(arr, itemsCount) {
+  itemsCount = Math.max(itemsCount, 0);
   return arr.slice(itemsCount);
 }
 // Annotate the CommonJS export names for ESM import in node:

package/dist/array/drop.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/array/drop.ts"],"sourcesContent":["/**\n * Removes a specified number of elements from the beginning of an array and returns the rest.\n *\n * This function takes an array and a number, and returns a new array with the specified number\n * of elements removed from the start.\n *\n * @template T - The type of elements in the array.\n * @param {T[]} arr - The array from which to drop elements.\n * @param {number} itemsCount - The number of elements to drop from the beginning of the array.\n * @returns {T[]} A new array with the specified number of elements removed from the start.\n *\n * @example\n * const array = [1, 2, 3, 4, 5];\n * const result = drop(array, 2);\n * // result will be [3, 4, 5] since the first two elements are dropped.\n */\nexport function drop<T>(arr: readonly T[], itemsCount: number): T[] {\n  return arr.slice(itemsCount);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAgBO,SAAS,KAAQ,KAAmB,YAAyB;AAClE,SAAO,IAAI,MAAM,UAAU;AAC7B;","names":[]}
+{"version":3,"sources":["../../src/array/drop.ts"],"sourcesContent":["/**\n * Removes a specified number of elements from the beginning of an array and returns the rest.\n *\n * This function takes an array and a number, and returns a new array with the specified number\n * of elements removed from the start.\n *\n * @template T - The type of elements in the array.\n * @param {T[]} arr - The array from which to drop elements.\n * @param {number} itemsCount - The number of elements to drop from the beginning of the array.\n * @returns {T[]} A new array with the specified number of elements removed from the start.\n *\n * @example\n * const array = [1, 2, 3, 4, 5];\n * const result = drop(array, 2);\n * // result will be [3, 4, 5] since the first two elements are dropped.\n */\nexport function drop<T>(arr: readonly T[], itemsCount: number): T[] {\n  itemsCount = Math.max(itemsCount, 0);\n\n  return arr.slice(itemsCount);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAgBO,SAAS,KAAQ,KAAmB,YAAyB;AAClE,eAAa,KAAK,IAAI,YAAY,CAAC;AAEnC,SAAO,IAAI,MAAM,UAAU;AAC7B;","names":[]}

package/dist/array/drop.mjs

@@ -1,7 +1,7 @@
 import {
   drop
-} from "../chunk-S3CORED5.mjs";
-import "../chunk-2MM5EJJX.mjs";
+} from "../chunk-3EZAFZG3.mjs";
+import "../chunk-424M7IR7.mjs";
 export {
   drop
 };

package/dist/array/dropRight.js

@@ -24,7 +24,11 @@ __export(dropRight_exports, {
 });
 module.exports = __toCommonJS(dropRight_exports);
 function dropRight(arr, itemsCount) {
-  return arr.slice(0, -itemsCount);
+  itemsCount = Math.min(-itemsCount, 0);
+  if (itemsCount === 0) {
+    return arr.slice();
+  }
+  return arr.slice(0, itemsCount);
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/array/dropRight.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/array/dropRight.ts"],"sourcesContent":["/**\n * Removes a specified number of elements from the end of an array and returns the rest.\n *\n * This function takes an array and a number, and returns a new array with the specified number\n * of elements removed from the end.\n *\n * @template T - The type of elements in the array.\n * @param {T[]} arr - The array from which to drop elements.\n * @param {number} itemsCount - The number of elements to drop from the end of the array.\n * @returns {T[]} A new array with the specified number of elements removed from the end.\n *\n * @example\n * const array = [1, 2, 3, 4, 5];\n * const result = dropRight(array, 2);\n * // result will be [1, 2, 3] since the last two elements are dropped.\n */\nexport function dropRight<T>(arr: readonly T[], itemsCount: number): T[] {\n  return arr.slice(0, -itemsCount);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAgBO,SAAS,UAAa,KAAmB,YAAyB;AACvE,SAAO,IAAI,MAAM,GAAG,CAAC,UAAU;AACjC;","names":[]}
+{"version":3,"sources":["../../src/array/dropRight.ts"],"sourcesContent":["/**\n * Removes a specified number of elements from the end of an array and returns the rest.\n *\n * This function takes an array and a number, and returns a new array with the specified number\n * of elements removed from the end.\n *\n * @template T - The type of elements in the array.\n * @param {T[]} arr - The array from which to drop elements.\n * @param {number} itemsCount - The number of elements to drop from the end of the array.\n * @returns {T[]} A new array with the specified number of elements removed from the end.\n *\n * @example\n * const array = [1, 2, 3, 4, 5];\n * const result = dropRight(array, 2);\n * // result will be [1, 2, 3] since the last two elements are dropped.\n */\nexport function dropRight<T>(arr: readonly T[], itemsCount: number): T[] {\n  itemsCount = Math.min(-itemsCount, 0);\n\n  if (itemsCount === 0) {\n    return arr.slice();\n  }\n\n  return arr.slice(0, itemsCount);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAgBO,SAAS,UAAa,KAAmB,YAAyB;AACvE,eAAa,KAAK,IAAI,CAAC,YAAY,CAAC;AAEpC,MAAI,eAAe,GAAG;AACpB,WAAO,IAAI,MAAM;AAAA,EACnB;AAEA,SAAO,IAAI,MAAM,GAAG,UAAU;AAChC;","names":[]}

package/dist/array/dropRight.mjs

@@ -1,7 +1,7 @@
 import {
   dropRight
-} from "../chunk-JEKUA56R.mjs";
-import "../chunk-2MM5EJJX.mjs";
+} from "../chunk-OXZCMC5I.mjs";
+import "../chunk-424M7IR7.mjs";
 export {
   dropRight
 };

package/dist/array/dropRightWhile.js

@@ -23,21 +23,13 @@ __export(dropRightWhile_exports, {
   dropRightWhile: () => dropRightWhile
 });
 module.exports = __toCommonJS(dropRightWhile_exports);
-
-// src/array/dropWhile.ts
-function dropWhile(arr, canContinueDropping) {
-  const dropEndIndex = arr.findIndex((item) => !canContinueDropping(item));
-  if (dropEndIndex === -1) {
-    return [];
-  }
-  return arr.slice(dropEndIndex);
-}
-
-// src/array/dropRightWhile.ts
 function dropRightWhile(arr, canContinueDropping) {
-  const reversed = arr.slice().reverse();
-  const dropped = dropWhile(reversed, canContinueDropping);
-  return dropped.slice().reverse();
+  for (let i = arr.length - 1; i >= 0; i--) {
+    if (!canContinueDropping(arr[i])) {
+      return arr.slice(0, i + 1);
+    }
+  }
+  return [];
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/array/dropRightWhile.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/array/dropRightWhile.ts","../../src/array/dropWhile.ts"],"sourcesContent":["import { dropWhile } from './dropWhile.ts';\n\n/**\n * Removes elements from the end of an array until the predicate returns false.\n *\n * This function iterates over an array from the end and drops elements until the provided\n * predicate function returns false. It then returns a new array with the remaining elements.\n *\n * @template T - The type of elements in the array.\n * @param {T[]} arr - The array from which to drop elements.\n * @param {(item: T) => boolean} canContinueDropping - A predicate function that determines\n * whether to continue dropping elements. The function is called with each element from the end,\n * and dropping continues as long as it returns true.\n * @returns {T[]} A new array with the elements remaining after the predicate returns false.\n *\n * @example\n * const array = [1, 2, 3, 4, 5];\n * const result = dropRightWhile(array, x => x > 3);\n * // result will be [1, 2, 3] since elements greater than 3 are dropped from the end.\n */\nexport function dropRightWhile<T>(arr: readonly T[], canContinueDropping: (item: T) => boolean): T[] {\n  const reversed = arr.slice().reverse();\n  const dropped = dropWhile(reversed, canContinueDropping);\n  return dropped.slice().reverse();\n}\n","/**\n * Removes elements from the beginning of an array until the predicate returns false.\n *\n * This function iterates over an array and drops elements from the start until the provided\n * predicate function returns false. It then returns a new array with the remaining elements.\n *\n * @template T - The type of elements in the array.\n * @param {T[]} arr - The array from which to drop elements.\n * @param {(item: T) => boolean} canContinueDropping - A predicate function that determines\n * whether to continue dropping elements. The function is called with each element, and dropping\n * continues as long as it returns true.\n * @returns {T[]} A new array with the elements remaining after the predicate returns false.\n *\n * @example\n * const array = [1, 2, 3, 4, 5];\n * const result = dropWhile(array, x => x < 3);\n * // result will be [3, 4, 5] since elements less than 3 are dropped.\n */\nexport function dropWhile<T>(arr: readonly T[], canContinueDropping: (item: T) => boolean): T[] {\n  const dropEndIndex = arr.findIndex(item => !canContinueDropping(item));\n  if (dropEndIndex === -1) {\n    return [];\n  }\n\n  return arr.slice(dropEndIndex);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACkBO,SAAS,UAAa,KAAmB,qBAAgD;AAC9F,QAAM,eAAe,IAAI,UAAU,UAAQ,CAAC,oBAAoB,IAAI,CAAC;AACrE,MAAI,iBAAiB,IAAI;AACvB,WAAO,CAAC;AAAA,EACV;AAEA,SAAO,IAAI,MAAM,YAAY;AAC/B;;;ADLO,SAAS,eAAkB,KAAmB,qBAAgD;AACnG,QAAM,WAAW,IAAI,MAAM,EAAE,QAAQ;AACrC,QAAM,UAAU,UAAU,UAAU,mBAAmB;AACvD,SAAO,QAAQ,MAAM,EAAE,QAAQ;AACjC;","names":[]}
+{"version":3,"sources":["../../src/array/dropRightWhile.ts"],"sourcesContent":["/**\n * Removes elements from the end of an array until the predicate returns false.\n *\n * This function iterates over an array from the end and drops elements until the provided\n * predicate function returns false. It then returns a new array with the remaining elements.\n *\n * @template T - The type of elements in the array.\n * @param {T[]} arr - The array from which to drop elements.\n * @param {(item: T) => boolean} canContinueDropping - A predicate function that determines\n * whether to continue dropping elements. The function is called with each element from the end,\n * and dropping continues as long as it returns true.\n * @returns {T[]} A new array with the elements remaining after the predicate returns false.\n *\n * @example\n * const array = [1, 2, 3, 4, 5];\n * const result = dropRightWhile(array, x => x > 3);\n * // result will be [1, 2, 3] since elements greater than 3 are dropped from the end.\n */\nexport function dropRightWhile<T>(arr: readonly T[], canContinueDropping: (item: T) => boolean): T[] {\n  for (let i = arr.length - 1; i >= 0; i--) {\n    if (!canContinueDropping(arr[i])) {\n      return arr.slice(0, i + 1);\n    }\n  }\n\n  return [];\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAkBO,SAAS,eAAkB,KAAmB,qBAAgD;AACnG,WAAS,IAAI,IAAI,SAAS,GAAG,KAAK,GAAG,KAAK;AACxC,QAAI,CAAC,oBAAoB,IAAI,CAAC,CAAC,GAAG;AAChC,aAAO,IAAI,MAAM,GAAG,IAAI,CAAC;AAAA,IAC3B;AAAA,EACF;AAEA,SAAO,CAAC;AACV;","names":[]}

package/dist/array/dropRightWhile.mjs

@@ -1,8 +1,7 @@
 import {
   dropRightWhile
-} from "../chunk-JE6JKZU3.mjs";
-import "../chunk-LJ2C6MVP.mjs";
-import "../chunk-2MM5EJJX.mjs";
+} from "../chunk-M7SBBYV2.mjs";
+import "../chunk-424M7IR7.mjs";
 export {
   dropRightWhile
 };

package/dist/array/dropWhile.mjs

@@ -1,7 +1,7 @@
 import {
   dropWhile
 } from "../chunk-LJ2C6MVP.mjs";
-import "../chunk-2MM5EJJX.mjs";
+import "../chunk-424M7IR7.mjs";
 export {
   dropWhile
 };

package/dist/array/fill.d.mts

@@ -3,13 +3,13 @@
  *
  * This function mutates the original array and replaces its elements with the provided value, starting from the specified
  * start index up to the end index (non-inclusive). If the start or end indices are not provided, it defaults to filling the
- * entire array. Negative indices can be used to specify positions from the end of the array.
+ * entire array.
  *
- * @param {Array<T | P>} arr - The array to fill.
- * @param {P} value - The value to fill the array with.
+ * @param {Array<T | U>} array - The array to fill.
+ * @param {U} value - The value to fill the array with.
  * @param {number} [start=0] - The start position. Defaults to 0.
  * @param {number} [end=arr.length] - The end position. Defaults to the array's length.
- * @returns {Array<T | P>} The array with the filled values.
+ * @returns {Array<T | U>} The array with the filled values.
  *
  * @example
  * const array = [1, 2, 3];
@@ -21,9 +21,12 @@
  *
  * const result = fill([4, 6, 8, 10], '*', 1, 3);
  * // => [4, '*', '*', 10]
+ *
+ * const result = fill(array, '*', -2, -1);
+ * // => [1, '*', 3]
  */
-declare function fill<T>(arr: unknown[], value: T): T[];
-declare function fill<T, P>(arr: Array<T | P>, value: P, start: number): Array<T | P>;
-declare function fill<T, P>(arr: Array<T | P>, value: P, start: number, end: number): Array<T | P>;
+declare function fill<T>(array: unknown[], value: T): T[];
+declare function fill<T, U>(array: Array<T | U>, value: U, start: number): Array<T | U>;
+declare function fill<T, U>(array: Array<T | U>, value: U, start: number, end: number): Array<T | U>;
 
 export { fill };

package/dist/array/fill.d.ts

@@ -3,13 +3,13 @@
  *
  * This function mutates the original array and replaces its elements with the provided value, starting from the specified
  * start index up to the end index (non-inclusive). If the start or end indices are not provided, it defaults to filling the
- * entire array. Negative indices can be used to specify positions from the end of the array.
+ * entire array.
  *
- * @param {Array<T | P>} arr - The array to fill.
- * @param {P} value - The value to fill the array with.
+ * @param {Array<T | U>} array - The array to fill.
+ * @param {U} value - The value to fill the array with.
  * @param {number} [start=0] - The start position. Defaults to 0.
  * @param {number} [end=arr.length] - The end position. Defaults to the array's length.
- * @returns {Array<T | P>} The array with the filled values.
+ * @returns {Array<T | U>} The array with the filled values.
  *
  * @example
  * const array = [1, 2, 3];
@@ -21,9 +21,12 @@
  *
  * const result = fill([4, 6, 8, 10], '*', 1, 3);
  * // => [4, '*', '*', 10]
+ *
+ * const result = fill(array, '*', -2, -1);
+ * // => [1, '*', 3]
  */
-declare function fill<T>(arr: unknown[], value: T): T[];
-declare function fill<T, P>(arr: Array<T | P>, value: P, start: number): Array<T | P>;
-declare function fill<T, P>(arr: Array<T | P>, value: P, start: number, end: number): Array<T | P>;
+declare function fill<T>(array: unknown[], value: T): T[];
+declare function fill<T, U>(array: Array<T | U>, value: U, start: number): Array<T | U>;
+declare function fill<T, U>(array: Array<T | U>, value: U, start: number, end: number): Array<T | U>;
 
 export { fill };

package/dist/array/fill.js

@@ -23,13 +23,14 @@ __export(fill_exports, {
   fill: () => fill
 });
 module.exports = __toCommonJS(fill_exports);
-function fill(arr, value, start = 0, end = arr.length) {
-  start = Math.max(start, 0);
-  end = Math.min(end, arr.length);
-  for (let i = start; i < end; i++) {
-    arr[i] = value;
+function fill(array, value, start = 0, end = array.length) {
+  const length = array.length;
+  const finalStart = Math.max(start >= 0 ? start : length + start, 0);
+  const finalEnd = Math.min(end >= 0 ? end : length + end, length);
+  for (let i = finalStart; i < finalEnd; i++) {
+    array[i] = value;
   }
-  return arr;
+  return array;
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/array/fill.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/array/fill.ts"],"sourcesContent":["/**\n * Fills elements of an array with a specified value from the start position up to, but not including, the end position.\n *\n * This function mutates the original array and replaces its elements with the provided value, starting from the specified\n * start index up to the end index (non-inclusive). If the start or end indices are not provided, it defaults to filling the\n * entire array. Negative indices can be used to specify positions from the end of the array.\n *\n * @param {Array<T | P>} arr - The array to fill.\n * @param {P} value - The value to fill the array with.\n * @param {number} [start=0] - The start position. Defaults to 0.\n * @param {number} [end=arr.length] - The end position. Defaults to the array's length.\n * @returns {Array<T | P>} The array with the filled values.\n *\n * @example\n * const array = [1, 2, 3];\n * const result = fill(array, 'a');\n * // => ['a', 'a', 'a']\n *\n * const result = fill(Array(3), 2);\n * // => [2, 2, 2]\n *\n * const result = fill([4, 6, 8, 10], '*', 1, 3);\n * // => [4, '*', '*', 10]\n */\n\nexport function fill<T>(arr: unknown[], value: T): T[];\nexport function fill<T, P>(arr: Array<T | P>, value: P, start: number): Array<T | P>;\nexport function fill<T, P>(arr: Array<T | P>, value: P, start: number, end: number): Array<T | P>;\nexport function fill<T, P>(arr: Array<T | P>, value: P, start = 0, end = arr.length): Array<T | P> {\n  start = Math.max(start, 0);\n  end = Math.min(end, arr.length);\n\n  for (let i = start; i < end; i++) {\n    arr[i] = value;\n  }\n\n  return arr;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AA4BO,SAAS,KAAW,KAAmB,OAAU,QAAQ,GAAG,MAAM,IAAI,QAAsB;AACjG,UAAQ,KAAK,IAAI,OAAO,CAAC;AACzB,QAAM,KAAK,IAAI,KAAK,IAAI,MAAM;AAE9B,WAAS,IAAI,OAAO,IAAI,KAAK,KAAK;AAChC,QAAI,CAAC,IAAI;AAAA,EACX;AAEA,SAAO;AACT;","names":[]}
+{"version":3,"sources":["../../src/array/fill.ts"],"sourcesContent":["/**\n * Fills elements of an array with a specified value from the start position up to, but not including, the end position.\n *\n * This function mutates the original array and replaces its elements with the provided value, starting from the specified\n * start index up to the end index (non-inclusive). If the start or end indices are not provided, it defaults to filling the\n * entire array.\n *\n * @param {Array<T | U>} array - The array to fill.\n * @param {U} value - The value to fill the array with.\n * @param {number} [start=0] - The start position. Defaults to 0.\n * @param {number} [end=arr.length] - The end position. Defaults to the array's length.\n * @returns {Array<T | U>} The array with the filled values.\n *\n * @example\n * const array = [1, 2, 3];\n * const result = fill(array, 'a');\n * // => ['a', 'a', 'a']\n *\n * const result = fill(Array(3), 2);\n * // => [2, 2, 2]\n *\n * const result = fill([4, 6, 8, 10], '*', 1, 3);\n * // => [4, '*', '*', 10]\n *\n * const result = fill(array, '*', -2, -1);\n * // => [1, '*', 3]\n */\nexport function fill<T>(array: unknown[], value: T): T[];\nexport function fill<T, U>(array: Array<T | U>, value: U, start: number): Array<T | U>;\nexport function fill<T, U>(array: Array<T | U>, value: U, start: number, end: number): Array<T | U>;\nexport function fill<T, U>(array: Array<T | U>, value: U, start = 0, end = array.length): Array<T | U> {\n  const length = array.length;\n  const finalStart = Math.max(start >= 0 ? start : length + start, 0);\n  const finalEnd = Math.min(end >= 0 ? end : length + end, length);\n\n  for (let i = finalStart; i < finalEnd; i++) {\n    array[i] = value;\n  }\n\n  return array;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AA8BO,SAAS,KAAW,OAAqB,OAAU,QAAQ,GAAG,MAAM,MAAM,QAAsB;AACrG,QAAM,SAAS,MAAM;AACrB,QAAM,aAAa,KAAK,IAAI,SAAS,IAAI,QAAQ,SAAS,OAAO,CAAC;AAClE,QAAM,WAAW,KAAK,IAAI,OAAO,IAAI,MAAM,SAAS,KAAK,MAAM;AAE/D,WAAS,IAAI,YAAY,IAAI,UAAU,KAAK;AAC1C,UAAM,CAAC,IAAI;AAAA,EACb;AAEA,SAAO;AACT;","names":[]}

package/dist/array/fill.mjs

@@ -1,7 +1,7 @@
 import {
   fill
-} from "../chunk-C4WE4GLC.mjs";
-import "../chunk-2MM5EJJX.mjs";
+} from "../chunk-YFN6KOC4.mjs";
+import "../chunk-424M7IR7.mjs";
 export {
   fill
 };

package/dist/array/flatMap.d.mts

@@ -0,0 +1,23 @@
+/**
+ * Maps each element in the array using the iteratee function and flattens the result up to the specified depth.
+ *
+ * @template T - The type of elements within the array.
+ * @template U - The type of elements within the returned array from the iteratee function.
+ * @template D - The depth to which the array should be flattened.
+ * @param {T[]} arr - The array to flatten.
+ * @param {(item: T) => U} iteratee - The function that produces the new array elements.
+ * @param {D} depth - The depth level specifying how deep a nested array structure should be flattened. Defaults to 1.
+ * @returns {Array<FlatArray<U[], D>>} The new array with the mapped and flattened elements.
+ *
+ * @example
+ * const arr = [1, 2, 3];
+ *
+ * flatMap(arr, (item: number) => [item, item]);
+ * // [1, 1, 2, 2, 3, 3]
+ *
+ * flatMap(arr, (item: number) => [[item, item]], 2);
+ * // [1, 1, 2, 2, 3, 3]
+ */
+declare function flatMap<T, U, D extends number>(arr: readonly T[], iteratee: (item: T) => U, depth?: D): Array<FlatArray<U[], D>>;
+
+export { flatMap };

package/dist/array/flatMap.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Maps each element in the array using the iteratee function and flattens the result up to the specified depth.
+ *
+ * @template T - The type of elements within the array.
+ * @template U - The type of elements within the returned array from the iteratee function.
+ * @template D - The depth to which the array should be flattened.
+ * @param {T[]} arr - The array to flatten.
+ * @param {(item: T) => U} iteratee - The function that produces the new array elements.
+ * @param {D} depth - The depth level specifying how deep a nested array structure should be flattened. Defaults to 1.
+ * @returns {Array<FlatArray<U[], D>>} The new array with the mapped and flattened elements.
+ *
+ * @example
+ * const arr = [1, 2, 3];
+ *
+ * flatMap(arr, (item: number) => [item, item]);
+ * // [1, 1, 2, 2, 3, 3]
+ *
+ * flatMap(arr, (item: number) => [[item, item]], 2);
+ * // [1, 1, 2, 2, 3, 3]
+ */
+declare function flatMap<T, U, D extends number>(arr: readonly T[], iteratee: (item: T) => U, depth?: D): Array<FlatArray<U[], D>>;
+
+export { flatMap };

package/dist/array/flatMap.js

@@ -0,0 +1,52 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/array/flatMap.ts
+var flatMap_exports = {};
+__export(flatMap_exports, {
+  flatMap: () => flatMap
+});
+module.exports = __toCommonJS(flatMap_exports);
+
+// src/array/flatten.ts
+function flatten(arr, depth = 1) {
+  const result = [];
+  const flooredDepth = Math.floor(depth);
+  const recursive = (arr2, currentDepth) => {
+    for (const item of arr2) {
+      if (Array.isArray(item) && currentDepth < flooredDepth) {
+        recursive(item, currentDepth + 1);
+      } else {
+        result.push(item);
+      }
+    }
+  };
+  recursive(arr, 0);
+  return result;
+}
+
+// src/array/flatMap.ts
+function flatMap(arr, iteratee, depth = 1) {
+  return flatten(arr.map((item) => iteratee(item)), depth);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  flatMap
+});
+//# sourceMappingURL=flatMap.js.map

package/dist/array/flatMap.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/array/flatMap.ts","../../src/array/flatten.ts"],"sourcesContent":["import { flatten } from './flatten.ts';\n\n/**\n * Maps each element in the array using the iteratee function and flattens the result up to the specified depth.\n *\n * @template T - The type of elements within the array.\n * @template U - The type of elements within the returned array from the iteratee function.\n * @template D - The depth to which the array should be flattened.\n * @param {T[]} arr - The array to flatten.\n * @param {(item: T) => U} iteratee - The function that produces the new array elements.\n * @param {D} depth - The depth level specifying how deep a nested array structure should be flattened. Defaults to 1.\n * @returns {Array<FlatArray<U[], D>>} The new array with the mapped and flattened elements.\n *\n * @example\n * const arr = [1, 2, 3];\n *\n * flatMap(arr, (item: number) => [item, item]);\n * // [1, 1, 2, 2, 3, 3]\n *\n * flatMap(arr, (item: number) => [[item, item]], 2);\n * // [1, 1, 2, 2, 3, 3]\n */\nexport function flatMap<T, U, D extends number>(\n  arr: readonly T[],\n  iteratee: (item: T) => U,\n  depth = 1 as D\n): Array<FlatArray<U[], D>> {\n  return flatten(arr.map(item => iteratee(item)), depth);\n}\n","/**\n * Flattens an array up to the specified depth.\n *\n * @template T - The type of elements within the array.\n * @template D - The depth to which the array should be flattened.\n * @param {T[]} arr - The array to flatten.\n * @param {D} depth - The depth level specifying how deep a nested array structure should be flattened. Defaults to 1.\n * @returns {Array<FlatArray<T[], D>>} A new array that has been flattened.\n *\n * @example\n * const arr = flatten([1, [2, 3], [4, [5, 6]]], 1);\n * // Returns: [1, 2, 3, 4, [5, 6]]\n *\n * const arr = flatten([1, [2, 3], [4, [5, 6]]], 2);\n * // Returns: [1, 2, 3, 4, 5, 6]\n */\nexport function flatten<T, D extends number = 1>(arr: readonly T[], depth = 1 as D): Array<FlatArray<T[], D>> {\n  const result: Array<FlatArray<T[], D>> = [];\n  const flooredDepth = Math.floor(depth);\n\n  const recursive = (arr: readonly T[], currentDepth: number) => {\n    for (const item of arr) {\n      if (Array.isArray(item) && currentDepth < flooredDepth) {\n        recursive(item, currentDepth + 1);\n      } else {\n        result.push(item as FlatArray<T[], D>);\n      }\n    }\n  };\n\n  recursive(arr, 0);\n  return result;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACgBO,SAAS,QAAiC,KAAmB,QAAQ,GAAkC;AAC5G,QAAM,SAAmC,CAAC;AAC1C,QAAM,eAAe,KAAK,MAAM,KAAK;AAErC,QAAM,YAAY,CAACA,MAAmB,iBAAyB;AAC7D,eAAW,QAAQA,MAAK;AACtB,UAAI,MAAM,QAAQ,IAAI,KAAK,eAAe,cAAc;AACtD,kBAAU,MAAM,eAAe,CAAC;AAAA,MAClC,OAAO;AACL,eAAO,KAAK,IAAyB;AAAA,MACvC;AAAA,IACF;AAAA,EACF;AAEA,YAAU,KAAK,CAAC;AAChB,SAAO;AACT;;;ADVO,SAAS,QACd,KACA,UACA,QAAQ,GACkB;AAC1B,SAAO,QAAQ,IAAI,IAAI,UAAQ,SAAS,IAAI,CAAC,GAAG,KAAK;AACvD;","names":["arr"]}

package/dist/array/flatMap.mjs

@@ -0,0 +1,9 @@
+import {
+  flatMap
+} from "../chunk-UY76KTPE.mjs";
+import "../chunk-33MSBDC6.mjs";
+import "../chunk-424M7IR7.mjs";
+export {
+  flatMap
+};
+//# sourceMappingURL=flatMap.mjs.map

package/dist/array/flatten.mjs

@@ -1,7 +1,7 @@
 import {
   flatten
 } from "../chunk-33MSBDC6.mjs";
-import "../chunk-2MM5EJJX.mjs";
+import "../chunk-424M7IR7.mjs";
 export {
   flatten
 };

package/dist/array/flattenDeep.mjs

@@ -2,7 +2,7 @@ import {
   flattenDeep
 } from "../chunk-ML727RRJ.mjs";
 import "../chunk-33MSBDC6.mjs";
-import "../chunk-2MM5EJJX.mjs";
+import "../chunk-424M7IR7.mjs";
 export {
   flattenDeep
 };

package/dist/array/forEachRight.mjs

@@ -1,7 +1,7 @@
 import {
   forEachRight
 } from "../chunk-IEA53J7P.mjs";
-import "../chunk-2MM5EJJX.mjs";
+import "../chunk-424M7IR7.mjs";
 export {
   forEachRight
 };

package/dist/array/groupBy.mjs

@@ -1,7 +1,7 @@
 import {
   groupBy
 } from "../chunk-E6E4RZLN.mjs";
-import "../chunk-2MM5EJJX.mjs";
+import "../chunk-424M7IR7.mjs";
 export {
   groupBy
 };

package/dist/array/head.mjs

@@ -1,7 +1,7 @@
 import {
   head
 } from "../chunk-HM2JT2RX.mjs";
-import "../chunk-2MM5EJJX.mjs";
+import "../chunk-424M7IR7.mjs";
 export {
   head
 };

package/dist/array/index.d.mts

@@ -9,6 +9,7 @@ export { dropRight } from './dropRight.mjs';
 export { dropRightWhile } from './dropRightWhile.mjs';
 export { dropWhile } from './dropWhile.mjs';
 export { fill } from './fill.mjs';
+export { flatMap } from './flatMap.mjs';
 export { flatten } from './flatten.mjs';
 export { flattenDeep } from './flattenDeep.mjs';
 export { forEachRight } from './forEachRight.mjs';

package/dist/array/index.d.ts

@@ -9,6 +9,7 @@ export { dropRight } from './dropRight.js';
 export { dropRightWhile } from './dropRightWhile.js';
 export { dropWhile } from './dropWhile.js';
 export { fill } from './fill.js';
+export { flatMap } from './flatMap.js';
 export { flatten } from './flatten.js';
 export { flattenDeep } from './flattenDeep.js';
 export { forEachRight } from './forEachRight.js';

package/dist/array/index.js

@@ -31,6 +31,7 @@ __export(array_exports, {
   dropRightWhile: () => dropRightWhile,
   dropWhile: () => dropWhile,
   fill: () => fill,
+  flatMap: () => flatMap,
   flatten: () => flatten,
   flattenDeep: () => flattenDeep,
   forEachRight: () => forEachRight,
@@ -135,12 +136,27 @@ function differenceWith(firstArr, secondArr, areItemsEqual) {
 
 // src/array/drop.ts
 function drop(arr, itemsCount) {
+  itemsCount = Math.max(itemsCount, 0);
   return arr.slice(itemsCount);
 }
 
 // src/array/dropRight.ts
 function dropRight(arr, itemsCount) {
-  return arr.slice(0, -itemsCount);
+  itemsCount = Math.min(-itemsCount, 0);
+  if (itemsCount === 0) {
+    return arr.slice();
+  }
+  return arr.slice(0, itemsCount);
+}
+
+// src/array/dropRightWhile.ts
+function dropRightWhile(arr, canContinueDropping) {
+  for (let i = arr.length - 1; i >= 0; i--) {
+    if (!canContinueDropping(arr[i])) {
+      return arr.slice(0, i + 1);
+    }
+  }
+  return [];
 }
 
 // src/array/dropWhile.ts
@@ -152,21 +168,15 @@ function dropWhile(arr, canContinueDropping) {
   return arr.slice(dropEndIndex);
 }
 
-// src/array/dropRightWhile.ts
-function dropRightWhile(arr, canContinueDropping) {
-  const reversed = arr.slice().reverse();
-  const dropped = dropWhile(reversed, canContinueDropping);
-  return dropped.slice().reverse();
-}
-
 // src/array/fill.ts
-function fill(arr, value, start = 0, end = arr.length) {
-  start = Math.max(start, 0);
-  end = Math.min(end, arr.length);
-  for (let i = start; i < end; i++) {
-    arr[i] = value;
+function fill(array, value, start = 0, end = array.length) {
+  const length = array.length;
+  const finalStart = Math.max(start >= 0 ? start : length + start, 0);
+  const finalEnd = Math.min(end >= 0 ? end : length + end, length);
+  for (let i = finalStart; i < finalEnd; i++) {
+    array[i] = value;
   }
-  return arr;
+  return array;
 }
 
 // src/array/flatten.ts
@@ -186,6 +196,11 @@ function flatten(arr, depth = 1) {
   return result;
 }
 
+// src/array/flatMap.ts
+function flatMap(arr, iteratee, depth = 1) {
+  return flatten(arr.map((item) => iteratee(item)), depth);
+}
+
 // src/array/flattenDeep.ts
 function flattenDeep(arr) {
   return flatten(arr, Infinity);
@@ -597,6 +612,7 @@ function initial(arr) {
   dropRightWhile,
   dropWhile,
   fill,
+  flatMap,
   flatten,
   flattenDeep,
   forEachRight,