es-toolkit 1.6.1 → 1.7.0-dev.146

package/dist/array/index.mjs

@@ -1,94 +1,115 @@
-import "../chunk-V6MDTRGS.mjs";
-import {
-  xorBy
-} from "../chunk-E54CCWDL.mjs";
-import {
-  xorWith
-} from "../chunk-JSS4FXUD.mjs";
+import "../chunk-XJR5WV2Z.mjs";
 import {
   zip
 } from "../chunk-IDCUZVJL.mjs";
 import {
   zipObject
-} from "../chunk-DA7GSKQ5.mjs";
+} from "../chunk-6GWEY5EL.mjs";
 import {
   zipWith
 } from "../chunk-4KYXHZ4R.mjs";
+import {
+  uniqBy
+} from "../chunk-OXAZEEGP.mjs";
+import {
+  unzipWith
+} from "../chunk-IFNXROZR.mjs";
+import {
+  without
+} from "../chunk-PYEYV7BY.mjs";
+import {
+  xor
+} from "../chunk-L7FQX5MN.mjs";
+import {
+  xorBy
+} from "../chunk-Q47NGNXT.mjs";
+import {
+  xorWith
+} from "../chunk-QRSJBBFY.mjs";
+import {
+  shuffle
+} from "../chunk-G7UQ5PUR.mjs";
+import {
+  take
+} from "../chunk-ME352XO7.mjs";
+import {
+  takeRight
+} from "../chunk-IQLKIDXF.mjs";
+import {
+  takeRightWhile
+} from "../chunk-NTLX2MPV.mjs";
 import {
   takeWhile
 } from "../chunk-2IXFGSUA.mjs";
+import {
+  union
+} from "../chunk-R6QA7PLZ.mjs";
+import {
+  uniq
+} from "../chunk-DVK2N4KC.mjs";
 import {
   unionBy
-} from "../chunk-NRNKP6JF.mjs";
+} from "../chunk-NFS7RWWE.mjs";
 import {
   unionWith
-} from "../chunk-OUTSP4VR.mjs";
-import {
-  uniqBy
-} from "../chunk-WPDDOUQT.mjs";
+} from "../chunk-2ZCITDMK.mjs";
 import {
   uniqWith
-} from "../chunk-2PFDLYQC.mjs";
+} from "../chunk-237HGSZS.mjs";
 import {
-  xor
-} from "../chunk-VKM3R5T5.mjs";
+  intersectionBy
+} from "../chunk-O6UXZR3U.mjs";
 import {
-  union
-} from "../chunk-UPJXHWSJ.mjs";
+  intersectionWith
+} from "../chunk-XI7KRD2C.mjs";
 import {
-  uniq
-} from "../chunk-XFCW7XJ4.mjs";
+  keyBy
+} from "../chunk-AJKZMN2V.mjs";
 import {
   maxBy
-} from "../chunk-FXOABQRO.mjs";
+} from "../chunk-OOKNBU4V.mjs";
 import {
   minBy
-} from "../chunk-OIHARMNM.mjs";
+} from "../chunk-IJD7FE2Z.mjs";
 import {
   partition
-} from "../chunk-5L2V7WD3.mjs";
+} from "../chunk-DN3NOZ3H.mjs";
 import {
   sample
-} from "../chunk-DOOIIHT3.mjs";
-import {
-  shuffle
-} from "../chunk-DPLJQQFX.mjs";
+} from "../chunk-2KNLZB7V.mjs";
 import {
-  take
-} from "../chunk-ME352XO7.mjs";
-import {
-  takeRight
-} from "../chunk-XDKEPIUV.mjs";
+  sampleSize
+} from "../chunk-EHSKB6DF.mjs";
 import {
-  takeRightWhile
-} from "../chunk-NTLX2MPV.mjs";
+  dropRight
+} from "../chunk-JEKUA56R.mjs";
 import {
   dropRightWhile
-} from "../chunk-GTVOVGGZ.mjs";
+} from "../chunk-JE6JKZU3.mjs";
 import {
   dropWhile
-} from "../chunk-K2BAFL2T.mjs";
+} from "../chunk-LJ2C6MVP.mjs";
 import {
-  groupBy
-} from "../chunk-LWXZFXY5.mjs";
+  fill
+} from "../chunk-C4WE4GLC.mjs";
 import {
-  intersection
-} from "../chunk-PYLGHB3F.mjs";
-import {
-  intersectionBy
-} from "../chunk-GNSJP2AB.mjs";
+  forEachRight
+} from "../chunk-IEA53J7P.mjs";
 import {
-  intersectionWith
-} from "../chunk-2EFS3VA3.mjs";
+  groupBy
+} from "../chunk-E6E4RZLN.mjs";
 import {
-  keyBy
-} from "../chunk-ZOTAORG3.mjs";
+  intersection
+} from "../chunk-FVVSE2F2.mjs";
 import {
   chunk
 } from "../chunk-E6C5EZQA.mjs";
 import {
   compact
-} from "../chunk-NKTBEEIT.mjs";
+} from "../chunk-DTJJIMKJ.mjs";
+import {
+  countBy
+} from "../chunk-CRSKT4WW.mjs";
 import {
   difference
 } from "../chunk-JPUKH67K.mjs";
@@ -100,14 +121,14 @@ import {
 } from "../chunk-6NVQAHXP.mjs";
 import {
   drop
-} from "../chunk-ACFP3XMB.mjs";
-import {
-  dropRight
-} from "../chunk-Q75KEFW5.mjs";
+} from "../chunk-S3CORED5.mjs";
+import "../chunk-GIWAOOFY.mjs";
+import "../chunk-SYWMYQYJ.mjs";
 import "../chunk-2MM5EJJX.mjs";
 export {
   chunk,
   compact,
+  countBy,
   difference,
   differenceBy,
   differenceWith,
@@ -115,6 +136,8 @@ export {
   dropRight,
   dropRightWhile,
   dropWhile,
+  fill,
+  forEachRight,
   groupBy,
   intersection,
   intersectionBy,
@@ -124,6 +147,7 @@ export {
   minBy,
   partition,
   sample,
+  sampleSize,
   shuffle,
   take,
   takeRight,
@@ -135,6 +159,8 @@ export {
   uniq,
   uniqBy,
   uniqWith,
+  unzipWith,
+  without,
   xor,
   xorBy,
   xorWith,

package/dist/array/intersection.d.mts

@@ -5,6 +5,7 @@
  * present in both arrays. It effectively filters out any elements from the first array that
  * are not found in the second array.
  *
+ * @template T - The type of elements in the array.
  * @param {T[]} firstArr - The first array to compare.
  * @param {T[]} secondArr - The second array to compare.
  * @returns {T[]} A new array containing the elements that are present in both arrays.

package/dist/array/intersection.d.ts

@@ -5,6 +5,7 @@
  * present in both arrays. It effectively filters out any elements from the first array that
  * are not found in the second array.
  *
+ * @template T - The type of elements in the array.
  * @param {T[]} firstArr - The first array to compare.
  * @param {T[]} secondArr - The second array to compare.
  * @returns {T[]} A new array containing the elements that are present in both arrays.

package/dist/array/intersection.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/array/intersection.ts"],"sourcesContent":["/**\n * Returns the intersection of two arrays.\n *\n * This function takes two arrays and returns a new array containing the elements that are\n * present in both arrays. It effectively filters out any elements from the first array that\n * are not found in the second array.\n *\n * @param {T[]} firstArr - The first array to compare.\n * @param {T[]} secondArr - The second array to compare.\n * @returns {T[]} A new array containing the elements that are present in both arrays.\n *\n * @example\n * const array1 = [1, 2, 3, 4, 5];\n * const array2 = [3, 4, 5, 6, 7];\n * const result = intersection(array1, array2);\n * // result will be [3, 4, 5] since these elements are in both arrays.\n */\nexport function intersection<T>(firstArr: readonly T[], secondArr: readonly T[]): T[] {\n  const secondSet = new Set(secondArr);\n\n  return firstArr.filter(item => {\n    return secondSet.has(item);\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAiBO,SAAS,aAAgB,UAAwB,WAA8B;AACpF,QAAM,YAAY,IAAI,IAAI,SAAS;AAEnC,SAAO,SAAS,OAAO,UAAQ;AAC7B,WAAO,UAAU,IAAI,IAAI;AAAA,EAC3B,CAAC;AACH;","names":[]}
+{"version":3,"sources":["../../src/array/intersection.ts"],"sourcesContent":["/**\n * Returns the intersection of two arrays.\n *\n * This function takes two arrays and returns a new array containing the elements that are\n * present in both arrays. It effectively filters out any elements from the first array that\n * are not found in the second array.\n *\n * @template T - The type of elements in the array.\n * @param {T[]} firstArr - The first array to compare.\n * @param {T[]} secondArr - The second array to compare.\n * @returns {T[]} A new array containing the elements that are present in both arrays.\n *\n * @example\n * const array1 = [1, 2, 3, 4, 5];\n * const array2 = [3, 4, 5, 6, 7];\n * const result = intersection(array1, array2);\n * // result will be [3, 4, 5] since these elements are in both arrays.\n */\nexport function intersection<T>(firstArr: readonly T[], secondArr: readonly T[]): T[] {\n  const secondSet = new Set(secondArr);\n\n  return firstArr.filter(item => {\n    return secondSet.has(item);\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAkBO,SAAS,aAAgB,UAAwB,WAA8B;AACpF,QAAM,YAAY,IAAI,IAAI,SAAS;AAEnC,SAAO,SAAS,OAAO,UAAQ;AAC7B,WAAO,UAAU,IAAI,IAAI;AAAA,EAC3B,CAAC;AACH;","names":[]}

package/dist/array/intersection.mjs

@@ -1,6 +1,6 @@
 import {
   intersection
-} from "../chunk-PYLGHB3F.mjs";
+} from "../chunk-FVVSE2F2.mjs";
 import "../chunk-2MM5EJJX.mjs";
 export {
   intersection

package/dist/array/intersectionBy.d.mts

@@ -6,6 +6,8 @@
  * mapped elements in the second array. It effectively filters out any elements from the first array
  * that do not have corresponding mapped values in the second array.
  *
+ * @template T - The type of elements in the array.
+ * @template U - The type of mapped elements.
  * @param {T[]} firstArr - The first array to compare.
  * @param {T[]} secondArr - The second array to compare.
  * @param {(item: T) => U} mapper - A function to map the elements of both arrays for comparison.

package/dist/array/intersectionBy.d.ts

@@ -6,6 +6,8 @@
  * mapped elements in the second array. It effectively filters out any elements from the first array
  * that do not have corresponding mapped values in the second array.
  *
+ * @template T - The type of elements in the array.
+ * @template U - The type of mapped elements.
  * @param {T[]} firstArr - The first array to compare.
  * @param {T[]} secondArr - The second array to compare.
  * @param {(item: T) => U} mapper - A function to map the elements of both arrays for comparison.

package/dist/array/intersectionBy.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/array/intersectionBy.ts"],"sourcesContent":["/**\n * Returns the intersection of two arrays based on a mapping function.\n *\n * This function takes two arrays and a mapping function. It returns a new array containing\n * the elements from the first array that, when mapped using the provided function, have matching\n * mapped elements in the second array. It effectively filters out any elements from the first array\n * that do not have corresponding mapped values in the second array.\n *\n * @param {T[]} firstArr - The first array to compare.\n * @param {T[]} secondArr - The second array to compare.\n * @param {(item: T) => U} mapper - A function to map the elements of both arrays for comparison.\n * @returns {T[]} A new array containing the elements from the first array that have corresponding mapped values in the second array.\n *\n * @example\n * const array1 = [{ id: 1 }, { id: 2 }, { id: 3 }];\n * const array2 = [{ id: 2 }, { id: 4 }];\n * const mapper = item => item.id;\n * const result = intersectionBy(array1, array2, mapper);\n * // result will be [{ id: 2 }] since only this element has a matching id in both arrays.\n */\nexport function intersectionBy<T, U>(firstArr: readonly T[], secondArr: readonly T[], mapper: (item: T) => U): T[] {\n  const mappedSecondSet = new Set(secondArr.map(mapper));\n  return firstArr.filter(item => mappedSecondSet.has(mapper(item)));\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAoBO,SAAS,eAAqB,UAAwB,WAAyB,QAA6B;AACjH,QAAM,kBAAkB,IAAI,IAAI,UAAU,IAAI,MAAM,CAAC;AACrD,SAAO,SAAS,OAAO,UAAQ,gBAAgB,IAAI,OAAO,IAAI,CAAC,CAAC;AAClE;","names":[]}
+{"version":3,"sources":["../../src/array/intersectionBy.ts"],"sourcesContent":["/**\n * Returns the intersection of two arrays based on a mapping function.\n *\n * This function takes two arrays and a mapping function. It returns a new array containing\n * the elements from the first array that, when mapped using the provided function, have matching\n * mapped elements in the second array. It effectively filters out any elements from the first array\n * that do not have corresponding mapped values in the second array.\n *\n * @template T - The type of elements in the array.\n * @template U - The type of mapped elements.\n * @param {T[]} firstArr - The first array to compare.\n * @param {T[]} secondArr - The second array to compare.\n * @param {(item: T) => U} mapper - A function to map the elements of both arrays for comparison.\n * @returns {T[]} A new array containing the elements from the first array that have corresponding mapped values in the second array.\n *\n * @example\n * const array1 = [{ id: 1 }, { id: 2 }, { id: 3 }];\n * const array2 = [{ id: 2 }, { id: 4 }];\n * const mapper = item => item.id;\n * const result = intersectionBy(array1, array2, mapper);\n * // result will be [{ id: 2 }] since only this element has a matching id in both arrays.\n */\nexport function intersectionBy<T, U>(firstArr: readonly T[], secondArr: readonly T[], mapper: (item: T) => U): T[] {\n  const mappedSecondSet = new Set(secondArr.map(mapper));\n  return firstArr.filter(item => mappedSecondSet.has(mapper(item)));\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAsBO,SAAS,eAAqB,UAAwB,WAAyB,QAA6B;AACjH,QAAM,kBAAkB,IAAI,IAAI,UAAU,IAAI,MAAM,CAAC;AACrD,SAAO,SAAS,OAAO,UAAQ,gBAAgB,IAAI,OAAO,IAAI,CAAC,CAAC;AAClE;","names":[]}

package/dist/array/intersectionBy.mjs

@@ -1,6 +1,6 @@
 import {
   intersectionBy
-} from "../chunk-GNSJP2AB.mjs";
+} from "../chunk-O6UXZR3U.mjs";
 import "../chunk-2MM5EJJX.mjs";
 export {
   intersectionBy

package/dist/array/intersectionWith.d.mts

@@ -6,6 +6,7 @@
  * by the custom equality function. It effectively filters out any elements from the first array that
  * do not have corresponding matches in the second array according to the equality function.
  *
+ * @template T - The type of elements in the array.
  * @param {T[]} firstArr - The first array to compare.
  * @param {T[]} secondArr - The second array to compare.
  * @param {(x: T, y: T) => boolean} areItemsEqual - A custom function to determine if two elements are equal.

package/dist/array/intersectionWith.d.ts

@@ -6,6 +6,7 @@
  * by the custom equality function. It effectively filters out any elements from the first array that
  * do not have corresponding matches in the second array according to the equality function.
  *
+ * @template T - The type of elements in the array.
  * @param {T[]} firstArr - The first array to compare.
  * @param {T[]} secondArr - The second array to compare.
  * @param {(x: T, y: T) => boolean} areItemsEqual - A custom function to determine if two elements are equal.

package/dist/array/intersectionWith.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/array/intersectionWith.ts"],"sourcesContent":["/**\n * Returns the intersection of two arrays based on a custom equality function.\n *\n * This function takes two arrays and a custom equality function. It returns a new array containing\n * the elements from the first array that have matching elements in the second array, as determined\n * by the custom equality function. It effectively filters out any elements from the first array that\n * do not have corresponding matches in the second array according to the equality function.\n *\n * @param {T[]} firstArr - The first array to compare.\n * @param {T[]} secondArr - The second array to compare.\n * @param {(x: T, y: T) => boolean} areItemsEqual - A custom function to determine if two elements are equal.\n * This function takes two arguments, one from each array, and returns `true` if the elements are considered equal, and `false` otherwise.\n * @returns {T[]} A new array containing the elements from the first array that have corresponding matches in the second array according to the custom equality function.\n *\n * @example\n * const array1 = [{ id: 1 }, { id: 2 }, { id: 3 }];\n * const array2 = [{ id: 2 }, { id: 4 }];\n * const areItemsEqual = (a, b) => a.id === b.id;\n * const result = intersectionWith(array1, array2, areItemsEqual);\n * // result will be [{ id: 2 }] since this element has a matching id in both arrays.\n */\nexport function intersectionWith<T>(\n  firstArr: readonly T[],\n  secondArr: readonly T[],\n  areItemsEqual: (x: T, y: T) => boolean\n): T[] {\n  return firstArr.filter(firstItem => {\n    return secondArr.some(secondItem => {\n      return areItemsEqual(firstItem, secondItem);\n    });\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAqBO,SAAS,iBACd,UACA,WACA,eACK;AACL,SAAO,SAAS,OAAO,eAAa;AAClC,WAAO,UAAU,KAAK,gBAAc;AAClC,aAAO,cAAc,WAAW,UAAU;AAAA,IAC5C,CAAC;AAAA,EACH,CAAC;AACH;","names":[]}
+{"version":3,"sources":["../../src/array/intersectionWith.ts"],"sourcesContent":["/**\n * Returns the intersection of two arrays based on a custom equality function.\n *\n * This function takes two arrays and a custom equality function. It returns a new array containing\n * the elements from the first array that have matching elements in the second array, as determined\n * by the custom equality function. It effectively filters out any elements from the first array that\n * do not have corresponding matches in the second array according to the equality function.\n *\n * @template T - The type of elements in the array.\n * @param {T[]} firstArr - The first array to compare.\n * @param {T[]} secondArr - The second array to compare.\n * @param {(x: T, y: T) => boolean} areItemsEqual - A custom function to determine if two elements are equal.\n * This function takes two arguments, one from each array, and returns `true` if the elements are considered equal, and `false` otherwise.\n * @returns {T[]} A new array containing the elements from the first array that have corresponding matches in the second array according to the custom equality function.\n *\n * @example\n * const array1 = [{ id: 1 }, { id: 2 }, { id: 3 }];\n * const array2 = [{ id: 2 }, { id: 4 }];\n * const areItemsEqual = (a, b) => a.id === b.id;\n * const result = intersectionWith(array1, array2, areItemsEqual);\n * // result will be [{ id: 2 }] since this element has a matching id in both arrays.\n */\nexport function intersectionWith<T>(\n  firstArr: readonly T[],\n  secondArr: readonly T[],\n  areItemsEqual: (x: T, y: T) => boolean\n): T[] {\n  return firstArr.filter(firstItem => {\n    return secondArr.some(secondItem => {\n      return areItemsEqual(firstItem, secondItem);\n    });\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAsBO,SAAS,iBACd,UACA,WACA,eACK;AACL,SAAO,SAAS,OAAO,eAAa;AAClC,WAAO,UAAU,KAAK,gBAAc;AAClC,aAAO,cAAc,WAAW,UAAU;AAAA,IAC5C,CAAC;AAAA,EACH,CAAC;AACH;","names":[]}

package/dist/array/intersectionWith.mjs

@@ -1,6 +1,6 @@
 import {
   intersectionWith
-} from "../chunk-2EFS3VA3.mjs";
+} from "../chunk-XI7KRD2C.mjs";
 import "../chunk-2MM5EJJX.mjs";
 export {
   intersectionWith

package/dist/array/keyBy.d.mts

@@ -6,6 +6,8 @@
  * If there are multiple elements generating the same key, the last element among them is used
  * as the value.
  *
+ * @template T - The type of elements in the array.
+ * @template K - The type of keys.
  * @param {T[]} arr - The array of elements to be mapped.
  * @param {(item: T) => K} getKeyFromItem - A function that generates a key from an element.
  * @returns {Record<K, T>} An object where keys are mapped to each element of an array.
@@ -23,6 +25,6 @@
  * //   vegetable: { category: 'vegetable', name: 'carrot' }
  * // }
  */
-declare function keyBy<T, K extends string>(arr: readonly T[], getKeyFromItem: (item: T) => K): Record<K, T>;
+declare function keyBy<T, K extends PropertyKey>(arr: readonly T[], getKeyFromItem: (item: T) => K): Record<K, T>;
 
 export { keyBy };

package/dist/array/keyBy.d.ts

@@ -6,6 +6,8 @@
  * If there are multiple elements generating the same key, the last element among them is used
  * as the value.
  *
+ * @template T - The type of elements in the array.
+ * @template K - The type of keys.
  * @param {T[]} arr - The array of elements to be mapped.
  * @param {(item: T) => K} getKeyFromItem - A function that generates a key from an element.
  * @returns {Record<K, T>} An object where keys are mapped to each element of an array.
@@ -23,6 +25,6 @@
  * //   vegetable: { category: 'vegetable', name: 'carrot' }
  * // }
  */
-declare function keyBy<T, K extends string>(arr: readonly T[], getKeyFromItem: (item: T) => K): Record<K, T>;
+declare function keyBy<T, K extends PropertyKey>(arr: readonly T[], getKeyFromItem: (item: T) => K): Record<K, T>;
 
 export { keyBy };

package/dist/array/keyBy.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/array/keyBy.ts"],"sourcesContent":["/**\n * Maps each element of an array based on a provided key-generating function.\n *\n * This function takes an array and a function that generates a key from each element. It returns\n * an object where the keys are the generated keys and the values are the corresponding elements.\n * If there are multiple elements generating the same key, the last element among them is used\n * as the value.\n *\n * @param {T[]} arr - The array of elements to be mapped.\n * @param {(item: T) => K} getKeyFromItem - A function that generates a key from an element.\n * @returns {Record<K, T>} An object where keys are mapped to each element of an array.\n *\n * @example\n * const array = [\n *   { category: 'fruit', name: 'apple' },\n *   { category: 'fruit', name: 'banana' },\n *   { category: 'vegetable', name: 'carrot' }\n * ];\n * const result = keyBy(array, item => item.category);\n * // result will be:\n * // {\n * //   fruit: { category: 'fruit', name: 'banana' },\n * //   vegetable: { category: 'vegetable', name: 'carrot' }\n * // }\n */\nexport function keyBy<T, K extends string>(arr: readonly T[], getKeyFromItem: (item: T) => K): Record<K, T> {\n  const result = {} as Record<K, T>;\n\n  for (const item of arr) {\n    const key = getKeyFromItem(item);\n    result[key] = item;\n  }\n\n  return result;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAyBO,SAAS,MAA2B,KAAmB,gBAA8C;AAC1G,QAAM,SAAS,CAAC;AAEhB,aAAW,QAAQ,KAAK;AACtB,UAAM,MAAM,eAAe,IAAI;AAC/B,WAAO,GAAG,IAAI;AAAA,EAChB;AAEA,SAAO;AACT;","names":[]}
+{"version":3,"sources":["../../src/array/keyBy.ts"],"sourcesContent":["/**\n * Maps each element of an array based on a provided key-generating function.\n *\n * This function takes an array and a function that generates a key from each element. It returns\n * an object where the keys are the generated keys and the values are the corresponding elements.\n * If there are multiple elements generating the same key, the last element among them is used\n * as the value.\n *\n * @template T - The type of elements in the array.\n * @template K - The type of keys.\n * @param {T[]} arr - The array of elements to be mapped.\n * @param {(item: T) => K} getKeyFromItem - A function that generates a key from an element.\n * @returns {Record<K, T>} An object where keys are mapped to each element of an array.\n *\n * @example\n * const array = [\n *   { category: 'fruit', name: 'apple' },\n *   { category: 'fruit', name: 'banana' },\n *   { category: 'vegetable', name: 'carrot' }\n * ];\n * const result = keyBy(array, item => item.category);\n * // result will be:\n * // {\n * //   fruit: { category: 'fruit', name: 'banana' },\n * //   vegetable: { category: 'vegetable', name: 'carrot' }\n * // }\n */\nexport function keyBy<T, K extends PropertyKey>(arr: readonly T[], getKeyFromItem: (item: T) => K): Record<K, T> {\n  const result = {} as Record<K, T>;\n\n  for (const item of arr) {\n    const key = getKeyFromItem(item);\n    result[key] = item;\n  }\n\n  return result;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AA2BO,SAAS,MAAgC,KAAmB,gBAA8C;AAC/G,QAAM,SAAS,CAAC;AAEhB,aAAW,QAAQ,KAAK;AACtB,UAAM,MAAM,eAAe,IAAI;AAC/B,WAAO,GAAG,IAAI;AAAA,EAChB;AAEA,SAAO;AACT;","names":[]}

package/dist/array/keyBy.mjs

@@ -1,6 +1,6 @@
 import {
   keyBy
-} from "../chunk-ZOTAORG3.mjs";
+} from "../chunk-AJKZMN2V.mjs";
 import "../chunk-2MM5EJJX.mjs";
 export {
   keyBy

package/dist/array/maxBy.d.mts

@@ -2,6 +2,7 @@
  * Finds the element in an array that has the maximum value when applying
  * the `getValue` function to each element.
  *
+ * @template T - The type of elements in the array.
  * @param {T[]} items The array of elements to search.
  * @param {(element: T) => number} getValue A function that selects a numeric value from each element.
  * @returns {T} The element with the maximum value as determined by the `getValue` function.

package/dist/array/maxBy.d.ts

@@ -2,6 +2,7 @@
  * Finds the element in an array that has the maximum value when applying
  * the `getValue` function to each element.
  *
+ * @template T - The type of elements in the array.
  * @param {T[]} items The array of elements to search.
  * @param {(element: T) => number} getValue A function that selects a numeric value from each element.
  * @returns {T} The element with the maximum value as determined by the `getValue` function.

package/dist/array/maxBy.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/array/maxBy.ts"],"sourcesContent":["/**\n * Finds the element in an array that has the maximum value when applying\n * the `getValue` function to each element.\n *\n * @param {T[]} items The array of elements to search.\n * @param {(element: T) => number} getValue A function that selects a numeric value from each element.\n * @returns {T} The element with the maximum value as determined by the `getValue` function.\n * @example\n * maxBy([{ a: 1 }, { a: 2 }, { a: 3 }], x => x.a); // Returns: { a: 3 }\n * maxBy([], x => x.a); // Returns: undefined\n */\nexport function maxBy<T>(items: T[], getValue: (element: T) => number): T {\n  let maxElement = items[0];\n  let max = -Infinity;\n\n  for (const element of items) {\n    const value = getValue(element);\n    if (value > max) {\n      max = value;\n      maxElement = element;\n    }\n  }\n\n  return maxElement;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAWO,SAAS,MAAS,OAAY,UAAqC;AACxE,MAAI,aAAa,MAAM,CAAC;AACxB,MAAI,MAAM;AAEV,aAAW,WAAW,OAAO;AAC3B,UAAM,QAAQ,SAAS,OAAO;AAC9B,QAAI,QAAQ,KAAK;AACf,YAAM;AACN,mBAAa;AAAA,IACf;AAAA,EACF;AAEA,SAAO;AACT;","names":[]}
+{"version":3,"sources":["../../src/array/maxBy.ts"],"sourcesContent":["/**\n * Finds the element in an array that has the maximum value when applying\n * the `getValue` function to each element.\n *\n * @template T - The type of elements in the array.\n * @param {T[]} items The array of elements to search.\n * @param {(element: T) => number} getValue A function that selects a numeric value from each element.\n * @returns {T} The element with the maximum value as determined by the `getValue` function.\n * @example\n * maxBy([{ a: 1 }, { a: 2 }, { a: 3 }], x => x.a); // Returns: { a: 3 }\n * maxBy([], x => x.a); // Returns: undefined\n */\nexport function maxBy<T>(items: T[], getValue: (element: T) => number): T {\n  let maxElement = items[0];\n  let max = -Infinity;\n\n  for (const element of items) {\n    const value = getValue(element);\n    if (value > max) {\n      max = value;\n      maxElement = element;\n    }\n  }\n\n  return maxElement;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAYO,SAAS,MAAS,OAAY,UAAqC;AACxE,MAAI,aAAa,MAAM,CAAC;AACxB,MAAI,MAAM;AAEV,aAAW,WAAW,OAAO;AAC3B,UAAM,QAAQ,SAAS,OAAO;AAC9B,QAAI,QAAQ,KAAK;AACf,YAAM;AACN,mBAAa;AAAA,IACf;AAAA,EACF;AAEA,SAAO;AACT;","names":[]}

package/dist/array/maxBy.mjs

@@ -1,6 +1,6 @@
 import {
   maxBy
-} from "../chunk-FXOABQRO.mjs";
+} from "../chunk-OOKNBU4V.mjs";
 import "../chunk-2MM5EJJX.mjs";
 export {
   maxBy

package/dist/array/minBy.d.mts

@@ -2,6 +2,7 @@
  * Finds the element in an array that has the minimum value when applying
  * the `getValue` function to each element.
  *
+ * @template T - The type of elements in the array.
  * @param {T[]} items The array of elements to search.
  * @param {(element: T) => number} getValue A function that selects a numeric value from each element.
  * @returns {T} The element with the minimum value as determined by the `getValue` function.

package/dist/array/minBy.d.ts

@@ -2,6 +2,7 @@
  * Finds the element in an array that has the minimum value when applying
  * the `getValue` function to each element.
  *
+ * @template T - The type of elements in the array.
  * @param {T[]} items The array of elements to search.
  * @param {(element: T) => number} getValue A function that selects a numeric value from each element.
  * @returns {T} The element with the minimum value as determined by the `getValue` function.

package/dist/array/minBy.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/array/minBy.ts"],"sourcesContent":["/**\n * Finds the element in an array that has the minimum value when applying\n * the `getValue` function to each element.\n *\n * @param {T[]} items The array of elements to search.\n * @param {(element: T) => number} getValue A function that selects a numeric value from each element.\n * @returns {T} The element with the minimum value as determined by the `getValue` function.\n * @example\n * minBy([{ a: 1 }, { a: 2 }, { a: 3 }], x => x.a); // Returns: { a: 1 }\n * minBy([], x => x.a); // Returns: undefined\n */\nexport function minBy<T>(items: T[], getValue: (element: T) => number): T {\n  let minElement = items[0];\n  let min = Infinity;\n\n  for (const element of items) {\n    const value = getValue(element);\n    if (value < min) {\n      min = value;\n      minElement = element;\n    }\n  }\n\n  return minElement;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAWO,SAAS,MAAS,OAAY,UAAqC;AACxE,MAAI,aAAa,MAAM,CAAC;AACxB,MAAI,MAAM;AAEV,aAAW,WAAW,OAAO;AAC3B,UAAM,QAAQ,SAAS,OAAO;AAC9B,QAAI,QAAQ,KAAK;AACf,YAAM;AACN,mBAAa;AAAA,IACf;AAAA,EACF;AAEA,SAAO;AACT;","names":[]}
+{"version":3,"sources":["../../src/array/minBy.ts"],"sourcesContent":["/**\n * Finds the element in an array that has the minimum value when applying\n * the `getValue` function to each element.\n *\n * @template T - The type of elements in the array.\n * @param {T[]} items The array of elements to search.\n * @param {(element: T) => number} getValue A function that selects a numeric value from each element.\n * @returns {T} The element with the minimum value as determined by the `getValue` function.\n * @example\n * minBy([{ a: 1 }, { a: 2 }, { a: 3 }], x => x.a); // Returns: { a: 1 }\n * minBy([], x => x.a); // Returns: undefined\n */\nexport function minBy<T>(items: T[], getValue: (element: T) => number): T {\n  let minElement = items[0];\n  let min = Infinity;\n\n  for (const element of items) {\n    const value = getValue(element);\n    if (value < min) {\n      min = value;\n      minElement = element;\n    }\n  }\n\n  return minElement;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAYO,SAAS,MAAS,OAAY,UAAqC;AACxE,MAAI,aAAa,MAAM,CAAC;AACxB,MAAI,MAAM;AAEV,aAAW,WAAW,OAAO;AAC3B,UAAM,QAAQ,SAAS,OAAO;AAC9B,QAAI,QAAQ,KAAK;AACf,YAAM;AACN,mBAAa;AAAA,IACf;AAAA,EACF;AAEA,SAAO;AACT;","names":[]}

package/dist/array/minBy.mjs

@@ -1,6 +1,6 @@
 import {
   minBy
-} from "../chunk-OIHARMNM.mjs";
+} from "../chunk-IJD7FE2Z.mjs";
 import "../chunk-2MM5EJJX.mjs";
 export {
   minBy

package/dist/array/partition.d.mts

@@ -5,6 +5,7 @@
  * the first array contains elements for which the predicate function returns true, and
  * the second array contains elements for which the predicate function returns false.
  *
+ * @template T - The type of elements in the array.
  * @param {T[]} arr - The array to partition.
  * @param {(value: T) => boolean} isInTruthy - A predicate function that determines
  * whether an element should be placed in the truthy array. The function is called with each

package/dist/array/partition.d.ts

@@ -5,6 +5,7 @@
  * the first array contains elements for which the predicate function returns true, and
  * the second array contains elements for which the predicate function returns false.
  *
+ * @template T - The type of elements in the array.
  * @param {T[]} arr - The array to partition.
  * @param {(value: T) => boolean} isInTruthy - A predicate function that determines
  * whether an element should be placed in the truthy array. The function is called with each

package/dist/array/partition.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/array/partition.ts"],"sourcesContent":["/**\n * Splits an array into two groups based on a predicate function.\n *\n * This function takes an array and a predicate function. It returns a tuple of two arrays:\n * the first array contains elements for which the predicate function returns true, and\n * the second array contains elements for which the predicate function returns false.\n *\n * @param {T[]} arr - The array to partition.\n * @param {(value: T) => boolean} isInTruthy - A predicate function that determines\n * whether an element should be placed in the truthy array. The function is called with each\n * element of the array.\n * @returns {[T[], T[]]} A tuple containing two arrays: the first array contains elements for\n * which the predicate returned true, and the second array contains elements for which the\n * predicate returned false.\n *\n * @example\n * const array = [1, 2, 3, 4, 5];\n * const isEven = x => x % 2 === 0;\n * const [even, odd] = partition(array, isEven);\n * // even will be [2, 4], and odd will be [1, 3, 5]\n */\nexport function partition<T>(arr: readonly T[], isInTruthy: (value: T) => boolean): [truthy: T[], falsy: T[]] {\n  const truthy: T[] = [];\n  const falsy: T[] = [];\n\n  for (const item of arr) {\n    if (isInTruthy(item)) {\n      truthy.push(item);\n    } else {\n      falsy.push(item);\n    }\n  }\n\n  return [truthy, falsy];\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAqBO,SAAS,UAAa,KAAmB,YAA8D;AAC5G,QAAM,SAAc,CAAC;AACrB,QAAM,QAAa,CAAC;AAEpB,aAAW,QAAQ,KAAK;AACtB,QAAI,WAAW,IAAI,GAAG;AACpB,aAAO,KAAK,IAAI;AAAA,IAClB,OAAO;AACL,YAAM,KAAK,IAAI;AAAA,IACjB;AAAA,EACF;AAEA,SAAO,CAAC,QAAQ,KAAK;AACvB;","names":[]}
+{"version":3,"sources":["../../src/array/partition.ts"],"sourcesContent":["/**\n * Splits an array into two groups based on a predicate function.\n *\n * This function takes an array and a predicate function. It returns a tuple of two arrays:\n * the first array contains elements for which the predicate function returns true, and\n * the second array contains elements for which the predicate function returns false.\n *\n * @template T - The type of elements in the array.\n * @param {T[]} arr - The array to partition.\n * @param {(value: T) => boolean} isInTruthy - A predicate function that determines\n * whether an element should be placed in the truthy array. The function is called with each\n * element of the array.\n * @returns {[T[], T[]]} A tuple containing two arrays: the first array contains elements for\n * which the predicate returned true, and the second array contains elements for which the\n * predicate returned false.\n *\n * @example\n * const array = [1, 2, 3, 4, 5];\n * const isEven = x => x % 2 === 0;\n * const [even, odd] = partition(array, isEven);\n * // even will be [2, 4], and odd will be [1, 3, 5]\n */\nexport function partition<T>(arr: readonly T[], isInTruthy: (value: T) => boolean): [truthy: T[], falsy: T[]] {\n  const truthy: T[] = [];\n  const falsy: T[] = [];\n\n  for (const item of arr) {\n    if (isInTruthy(item)) {\n      truthy.push(item);\n    } else {\n      falsy.push(item);\n    }\n  }\n\n  return [truthy, falsy];\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAsBO,SAAS,UAAa,KAAmB,YAA8D;AAC5G,QAAM,SAAc,CAAC;AACrB,QAAM,QAAa,CAAC;AAEpB,aAAW,QAAQ,KAAK;AACtB,QAAI,WAAW,IAAI,GAAG;AACpB,aAAO,KAAK,IAAI;AAAA,IAClB,OAAO;AACL,YAAM,KAAK,IAAI;AAAA,IACjB;AAAA,EACF;AAEA,SAAO,CAAC,QAAQ,KAAK;AACvB;","names":[]}

package/dist/array/partition.mjs

@@ -1,6 +1,6 @@
 import {
   partition
-} from "../chunk-5L2V7WD3.mjs";
+} from "../chunk-DN3NOZ3H.mjs";
 import "../chunk-2MM5EJJX.mjs";
 export {
   partition

package/dist/array/sample.d.mts

@@ -3,6 +3,7 @@
  *
  * This function takes an array and returns a single element selected randomly from the array.
  *
+ * @template T - The type of elements in the array.
  * @param {T[]} arr - The array to sample from.
  * @returns {T} A random element from the array.
  *

package/dist/array/sample.d.ts

@@ -3,6 +3,7 @@
  *
  * This function takes an array and returns a single element selected randomly from the array.
  *
+ * @template T - The type of elements in the array.
  * @param {T[]} arr - The array to sample from.
  * @returns {T} A random element from the array.
  *

package/dist/array/sample.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/array/sample.ts"],"sourcesContent":["/**\n * Returns a random element from an array.\n *\n * This function takes an array and returns a single element selected randomly from the array.\n *\n * @param {T[]} arr - The array to sample from.\n * @returns {T} A random element from the array.\n *\n * @example\n * const array = [1, 2, 3, 4, 5];\n * const randomElement = sample(array);\n * // randomElement will be one of the elements from the array, selected randomly.\n */\nexport function sample<T>(arr: readonly T[]): T {\n  const randomIndex = Math.floor(Math.random() * arr.length);\n  return arr[randomIndex];\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAaO,SAAS,OAAU,KAAsB;AAC9C,QAAM,cAAc,KAAK,MAAM,KAAK,OAAO,IAAI,IAAI,MAAM;AACzD,SAAO,IAAI,WAAW;AACxB;","names":[]}
+{"version":3,"sources":["../../src/array/sample.ts"],"sourcesContent":["/**\n * Returns a random element from an array.\n *\n * This function takes an array and returns a single element selected randomly from the array.\n *\n * @template T - The type of elements in the array.\n * @param {T[]} arr - The array to sample from.\n * @returns {T} A random element from the array.\n *\n * @example\n * const array = [1, 2, 3, 4, 5];\n * const randomElement = sample(array);\n * // randomElement will be one of the elements from the array, selected randomly.\n */\nexport function sample<T>(arr: readonly T[]): T {\n  const randomIndex = Math.floor(Math.random() * arr.length);\n  return arr[randomIndex];\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAcO,SAAS,OAAU,KAAsB;AAC9C,QAAM,cAAc,KAAK,MAAM,KAAK,OAAO,IAAI,IAAI,MAAM;AACzD,SAAO,IAAI,WAAW;AACxB;","names":[]}

package/dist/array/sample.mjs

@@ -1,6 +1,6 @@
 import {
   sample
-} from "../chunk-DOOIIHT3.mjs";
+} from "../chunk-2KNLZB7V.mjs";
 import "../chunk-2MM5EJJX.mjs";
 export {
   sample

package/dist/array/sampleSize.d.mts

@@ -0,0 +1,21 @@
+/**
+ * Returns a sample element array of a specified `size`.
+ *
+ * This function takes an array and a number, and returns an array containing the sampled elements using Floyd's algorithm.
+ *
+ * {@link https://www.nowherenearithaca.com/2013/05/robert-floyds-tiny-and-beautiful.html Floyd's algoritm}
+ *
+ * @template T - The type of elements in the array.
+ * @param {T[]} array - The array to sample from.
+ * @param {number} size - The size of sample.
+ * @returns {T[]} A new array with sample size applied.
+ * @throws {Error} Throws an error if `size` is greater than the length of `array`.
+ *
+ * @example
+ * const result = sampleSize([1, 2, 3], 2)
+ * // result will be an array containing two of the elements from the array.
+ * // [1, 2] or [1, 3] or [2, 3]
+ */
+declare function sampleSize<T>(array: readonly T[], size: number): T[];
+
+export { sampleSize };

package/dist/array/sampleSize.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Returns a sample element array of a specified `size`.
+ *
+ * This function takes an array and a number, and returns an array containing the sampled elements using Floyd's algorithm.
+ *
+ * {@link https://www.nowherenearithaca.com/2013/05/robert-floyds-tiny-and-beautiful.html Floyd's algoritm}
+ *
+ * @template T - The type of elements in the array.
+ * @param {T[]} array - The array to sample from.
+ * @param {number} size - The size of sample.
+ * @returns {T[]} A new array with sample size applied.
+ * @throws {Error} Throws an error if `size` is greater than the length of `array`.
+ *
+ * @example
+ * const result = sampleSize([1, 2, 3], 2)
+ * // result will be an array containing two of the elements from the array.
+ * // [1, 2] or [1, 3] or [2, 3]
+ */
+declare function sampleSize<T>(array: readonly T[], size: number): T[];
+
+export { sampleSize };

package/dist/array/sampleSize.js

@@ -0,0 +1,65 @@
+"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/sampleSize.ts
+var sampleSize_exports = {};
+__export(sampleSize_exports, {
+  sampleSize: () => sampleSize
+});
+module.exports = __toCommonJS(sampleSize_exports);
+
+// src/math/random.ts
+function random(minimum, maximum) {
+  if (maximum == null) {
+    maximum = minimum;
+    minimum = 0;
+  }
+  if (minimum >= maximum) {
+    throw new Error("Invalid input: The maximum value must be greater than the minimum value.");
+  }
+  return Math.random() * (maximum - minimum) + minimum;
+}
+
+// src/math/randomInt.ts
+function randomInt(minimum, maximum) {
+  return Math.floor(random(minimum, maximum));
+}
+
+// src/array/sampleSize.ts
+function sampleSize(array, size) {
+  if (size > array.length) {
+    throw new Error("Size must be less than or equal to the length of array.");
+  }
+  const result = new Array(size);
+  const selected = /* @__PURE__ */ new Set();
+  for (let step = array.length - size, resultIndex = 0; step < array.length; step++, resultIndex++) {
+    let index = randomInt(0, step + 1);
+    if (selected.has(index)) {
+      index = step;
+    }
+    selected.add(index);
+    result[resultIndex] = array[index];
+  }
+  return result;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  sampleSize
+});
+//# sourceMappingURL=sampleSize.js.map