es-toolkit 1.6.1-dev.136 → 1.6.1-dev.138

package/dist/array/index.mjs

@@ -1,16 +1,16 @@
 import "../chunk-D735JOLS.mjs";
 import {
   xorBy
-} from "../chunk-E54CCWDL.mjs";
+} from "../chunk-Q47NGNXT.mjs";
 import {
   xorWith
-} from "../chunk-JSS4FXUD.mjs";
+} from "../chunk-QRSJBBFY.mjs";
 import {
   zip
 } from "../chunk-IDCUZVJL.mjs";
 import {
   zipObject
-} from "../chunk-DA7GSKQ5.mjs";
+} from "../chunk-6GWEY5EL.mjs";
 import {
   zipWith
 } from "../chunk-4KYXHZ4R.mjs";
@@ -19,39 +19,39 @@ import {
 } from "../chunk-2IXFGSUA.mjs";
 import {
   unionBy
-} from "../chunk-NRNKP6JF.mjs";
+} from "../chunk-NFS7RWWE.mjs";
 import {
   unionWith
-} from "../chunk-OUTSP4VR.mjs";
+} from "../chunk-2ZCITDMK.mjs";
 import {
   uniqBy
-} from "../chunk-WPDDOUQT.mjs";
+} from "../chunk-OXAZEEGP.mjs";
 import {
   uniqWith
-} from "../chunk-2PFDLYQC.mjs";
+} from "../chunk-237HGSZS.mjs";
 import {
   xor
-} from "../chunk-VKM3R5T5.mjs";
+} from "../chunk-L7FQX5MN.mjs";
 import {
   union
-} from "../chunk-UPJXHWSJ.mjs";
+} from "../chunk-R6QA7PLZ.mjs";
 import {
   uniq
-} from "../chunk-XFCW7XJ4.mjs";
+} from "../chunk-DVK2N4KC.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";
+} from "../chunk-2KNLZB7V.mjs";
 import {
   sampleSize
-} from "../chunk-4MRXVNGG.mjs";
+} from "../chunk-LUIKU43M.mjs";
 import "../chunk-TZE6EDCX.mjs";
-import "../chunk-JGNFYNYU.mjs";
+import "../chunk-CXGIXTSH.mjs";
 import "../chunk-GIWAOOFY.mjs";
 import "../chunk-SYWMYQYJ.mjs";
 import "../chunk-UNLX2F2Y.mjs";
@@ -61,40 +61,40 @@ import "../chunk-LT6E4Y4Z.mjs";
 import "../chunk-NOFHNJ5C.mjs";
 import {
   shuffle
-} from "../chunk-DPLJQQFX.mjs";
+} from "../chunk-G7UQ5PUR.mjs";
 import {
   take
 } from "../chunk-ME352XO7.mjs";
 import {
   takeRight
-} from "../chunk-XDKEPIUV.mjs";
+} from "../chunk-IQLKIDXF.mjs";
 import {
   takeRightWhile
 } from "../chunk-NTLX2MPV.mjs";
 import {
   groupBy
-} from "../chunk-H5YR3ZV4.mjs";
+} from "../chunk-E6E4RZLN.mjs";
 import {
   intersection
-} from "../chunk-PYLGHB3F.mjs";
+} from "../chunk-FVVSE2F2.mjs";
 import {
   intersectionBy
-} from "../chunk-GNSJP2AB.mjs";
+} from "../chunk-O6UXZR3U.mjs";
 import {
   intersectionWith
-} from "../chunk-2EFS3VA3.mjs";
+} from "../chunk-XI7KRD2C.mjs";
 import {
   keyBy
-} from "../chunk-KSXWREB5.mjs";
+} from "../chunk-AJKZMN2V.mjs";
 import {
   maxBy
-} from "../chunk-FXOABQRO.mjs";
+} from "../chunk-OOKNBU4V.mjs";
 import {
   chunk
 } from "../chunk-E6C5EZQA.mjs";
 import {
   compact
-} from "../chunk-NKTBEEIT.mjs";
+} from "../chunk-DTJJIMKJ.mjs";
 import {
   difference
 } from "../chunk-JPUKH67K.mjs";
@@ -106,16 +106,16 @@ import {
 } from "../chunk-6NVQAHXP.mjs";
 import {
   drop
-} from "../chunk-ACFP3XMB.mjs";
+} from "../chunk-S3CORED5.mjs";
 import {
   dropRight
-} from "../chunk-Q75KEFW5.mjs";
+} 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 "../chunk-2MM5EJJX.mjs";
 export {
   chunk,

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.

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.

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 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;AAyBO,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":[]}
+{"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-KSXWREB5.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

@@ -5,6 +5,7 @@
  *
  * {@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.

package/dist/array/sampleSize.d.ts

@@ -5,6 +5,7 @@
  *
  * {@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.

package/dist/array/sampleSize.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/array/sampleSize.ts","../../src/math/random.ts","../../src/math/randomInt.ts"],"sourcesContent":["import { randomInt } from '../math';\n\n/**\n * Returns a sample element array of a specified `size`.\n *\n * This function takes an array and a number, and returns an array containing the sampled elements using Floyd's algorithm.\n *\n * {@link https://www.nowherenearithaca.com/2013/05/robert-floyds-tiny-and-beautiful.html Floyd's algoritm}\n *\n * @param {T[]} array - The array to sample from.\n * @param {number} size - The size of sample.\n * @returns {T[]} A new array with sample size applied.\n * @throws {Error} Throws an error if `size` is greater than the length of `array`.\n *\n * @example\n * const result = sampleSize([1, 2, 3], 2)\n * // result will be an array containing two of the elements from the array.\n * // [1, 2] or [1, 3] or [2, 3]\n */\nexport function sampleSize<T>(array: readonly T[], size: number): T[] {\n  if (size > array.length) {\n    throw new Error('Size must be less than or equal to the length of array.');\n  }\n\n  const result = new Array(size);\n  const selected = new Set();\n\n  for (let step = array.length - size, resultIndex = 0; step < array.length; step++, resultIndex++) {\n    let index = randomInt(0, step + 1);\n\n    if (selected.has(index)) {\n      index = step;\n    }\n\n    selected.add(index);\n\n    result[resultIndex] = array[index];\n  }\n\n  return result;\n}\n","/**\n * Generate a random number within the given range.\n *\n * If only one argument is provided, a number between `0` and the given number is returned.\n *\n * @param {number} minimum - The lower bound (inclusive).\n * @param {number} maximum - The upper bound (exclusive).\n * @returns {number} A random number between minimum (inclusive) and maximum (exclusive). The number can be an integer or a decimal.\n * @throws {Error} Throws an error if `maximum` is not greater than `minimum`.\n *\n * @example\n * const result1 = random(0, 5); // Returns a random number between 0 and 5.\n * const result2 = random(5, 0); // If the minimum is greater than the maximum, an error is thrown\n * const result3 = random(5, 5); // If the minimum is equal to the maximum, an error is thrown.\n */\nexport function random(maximum: number): number;\nexport function random(minimum: number, maximum: number): number;\nexport function random(minimum: number, maximum?: number): number {\n  if (maximum == null) {\n    maximum = minimum;\n    minimum = 0;\n  }\n\n  if (minimum >= maximum) {\n    throw new Error('Invalid input: The maximum value must be greater than the minimum value.');\n  }\n\n  return Math.random() * (maximum - minimum) + minimum;\n}\n","import { random } from './random.ts';\n\n/**\n * Generates a random integer between minimum (inclusive) and maximum (exclusive).\n *\n * If only one argument is provided, a number between `0` and the given number is returned.\n *\n * @param {number} minimum - The lower bound (inclusive).\n * @param {number} maximum - The upper bound (exclusive).\n * @returns {number} A random integer between minimum (inclusive) and maximum (exclusive).\n * @throws {Error} Throws an error if `maximum` is not greater than `minimum`.\n *\n * @example\n * const result = randomInt(0, 5); // result will be a random integer between 0 (inclusive) and 5 (exclusive)\n * const result2 = randomInt(5, 0); // This will throw an error\n */\nexport function randomInt(maximum: number): number;\nexport function randomInt(minimum: number, maximum: number): number;\nexport function randomInt(minimum: number, maximum?: number): number {\n  return Math.floor(random(minimum, maximum!));\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACiBO,SAAS,OAAO,SAAiB,SAA0B;AAChE,MAAI,WAAW,MAAM;AACnB,cAAU;AACV,cAAU;AAAA,EACZ;AAEA,MAAI,WAAW,SAAS;AACtB,UAAM,IAAI,MAAM,0EAA0E;AAAA,EAC5F;AAEA,SAAO,KAAK,OAAO,KAAK,UAAU,WAAW;AAC/C;;;ACVO,SAAS,UAAU,SAAiB,SAA0B;AACnE,SAAO,KAAK,MAAM,OAAO,SAAS,OAAQ,CAAC;AAC7C;;;AFDO,SAAS,WAAc,OAAqB,MAAmB;AACpE,MAAI,OAAO,MAAM,QAAQ;AACvB,UAAM,IAAI,MAAM,yDAAyD;AAAA,EAC3E;AAEA,QAAM,SAAS,IAAI,MAAM,IAAI;AAC7B,QAAM,WAAW,oBAAI,IAAI;AAEzB,WAAS,OAAO,MAAM,SAAS,MAAM,cAAc,GAAG,OAAO,MAAM,QAAQ,QAAQ,eAAe;AAChG,QAAI,QAAQ,UAAU,GAAG,OAAO,CAAC;AAEjC,QAAI,SAAS,IAAI,KAAK,GAAG;AACvB,cAAQ;AAAA,IACV;AAEA,aAAS,IAAI,KAAK;AAElB,WAAO,WAAW,IAAI,MAAM,KAAK;AAAA,EACnC;AAEA,SAAO;AACT;","names":[]}
+{"version":3,"sources":["../../src/array/sampleSize.ts","../../src/math/random.ts","../../src/math/randomInt.ts"],"sourcesContent":["import { randomInt } from '../math';\n\n/**\n * Returns a sample element array of a specified `size`.\n *\n * This function takes an array and a number, and returns an array containing the sampled elements using Floyd's algorithm.\n *\n * {@link https://www.nowherenearithaca.com/2013/05/robert-floyds-tiny-and-beautiful.html Floyd's algoritm}\n *\n * @template T - The type of elements in the array.\n * @param {T[]} array - The array to sample from.\n * @param {number} size - The size of sample.\n * @returns {T[]} A new array with sample size applied.\n * @throws {Error} Throws an error if `size` is greater than the length of `array`.\n *\n * @example\n * const result = sampleSize([1, 2, 3], 2)\n * // result will be an array containing two of the elements from the array.\n * // [1, 2] or [1, 3] or [2, 3]\n */\nexport function sampleSize<T>(array: readonly T[], size: number): T[] {\n  if (size > array.length) {\n    throw new Error('Size must be less than or equal to the length of array.');\n  }\n\n  const result = new Array(size);\n  const selected = new Set();\n\n  for (let step = array.length - size, resultIndex = 0; step < array.length; step++, resultIndex++) {\n    let index = randomInt(0, step + 1);\n\n    if (selected.has(index)) {\n      index = step;\n    }\n\n    selected.add(index);\n\n    result[resultIndex] = array[index];\n  }\n\n  return result;\n}\n","/**\n * Generate a random number within the given range.\n *\n * If only one argument is provided, a number between `0` and the given number is returned.\n *\n * @param {number} minimum - The lower bound (inclusive).\n * @param {number} maximum - The upper bound (exclusive).\n * @returns {number} A random number between minimum (inclusive) and maximum (exclusive). The number can be an integer or a decimal.\n * @throws {Error} Throws an error if `maximum` is not greater than `minimum`.\n *\n * @example\n * const result1 = random(0, 5); // Returns a random number between 0 and 5.\n * const result2 = random(5, 0); // If the minimum is greater than the maximum, an error is thrown\n * const result3 = random(5, 5); // If the minimum is equal to the maximum, an error is thrown.\n */\nexport function random(maximum: number): number;\nexport function random(minimum: number, maximum: number): number;\nexport function random(minimum: number, maximum?: number): number {\n  if (maximum == null) {\n    maximum = minimum;\n    minimum = 0;\n  }\n\n  if (minimum >= maximum) {\n    throw new Error('Invalid input: The maximum value must be greater than the minimum value.');\n  }\n\n  return Math.random() * (maximum - minimum) + minimum;\n}\n","import { random } from './random.ts';\n\n/**\n * Generates a random integer between minimum (inclusive) and maximum (exclusive).\n *\n * If only one argument is provided, a number between `0` and the given number is returned.\n *\n * @param {number} minimum - The lower bound (inclusive).\n * @param {number} maximum - The upper bound (exclusive).\n * @returns {number} A random integer between minimum (inclusive) and maximum (exclusive).\n * @throws {Error} Throws an error if `maximum` is not greater than `minimum`.\n *\n * @example\n * const result = randomInt(0, 5); // result will be a random integer between 0 (inclusive) and 5 (exclusive)\n * const result2 = randomInt(5, 0); // This will throw an error\n */\nexport function randomInt(maximum: number): number;\nexport function randomInt(minimum: number, maximum: number): number;\nexport function randomInt(minimum: number, maximum?: number): number {\n  return Math.floor(random(minimum, maximum!));\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACiBO,SAAS,OAAO,SAAiB,SAA0B;AAChE,MAAI,WAAW,MAAM;AACnB,cAAU;AACV,cAAU;AAAA,EACZ;AAEA,MAAI,WAAW,SAAS;AACtB,UAAM,IAAI,MAAM,0EAA0E;AAAA,EAC5F;AAEA,SAAO,KAAK,OAAO,KAAK,UAAU,WAAW;AAC/C;;;ACVO,SAAS,UAAU,SAAiB,SAA0B;AACnE,SAAO,KAAK,MAAM,OAAO,SAAS,OAAQ,CAAC;AAC7C;;;AFAO,SAAS,WAAc,OAAqB,MAAmB;AACpE,MAAI,OAAO,MAAM,QAAQ;AACvB,UAAM,IAAI,MAAM,yDAAyD;AAAA,EAC3E;AAEA,QAAM,SAAS,IAAI,MAAM,IAAI;AAC7B,QAAM,WAAW,oBAAI,IAAI;AAEzB,WAAS,OAAO,MAAM,SAAS,MAAM,cAAc,GAAG,OAAO,MAAM,QAAQ,QAAQ,eAAe;AAChG,QAAI,QAAQ,UAAU,GAAG,OAAO,CAAC;AAEjC,QAAI,SAAS,IAAI,KAAK,GAAG;AACvB,cAAQ;AAAA,IACV;AAEA,aAAS,IAAI,KAAK;AAElB,WAAO,WAAW,IAAI,MAAM,KAAK;AAAA,EACnC;AAEA,SAAO;AACT;","names":[]}

package/dist/array/sampleSize.mjs

@@ -1,8 +1,8 @@
 import {
   sampleSize
-} from "../chunk-4MRXVNGG.mjs";
+} from "../chunk-LUIKU43M.mjs";
 import "../chunk-TZE6EDCX.mjs";
-import "../chunk-JGNFYNYU.mjs";
+import "../chunk-CXGIXTSH.mjs";
 import "../chunk-GIWAOOFY.mjs";
 import "../chunk-SYWMYQYJ.mjs";
 import "../chunk-UNLX2F2Y.mjs";

package/dist/array/shuffle.d.mts

@@ -3,6 +3,7 @@
  *
  * This function takes an array and returns a new array with its elements shuffled in a random order.
  *
+ * @template T - The type of elements in the array.
  * @param {T[]} arr - The array to shuffle.
  * @returns {T[]} A new array with its elements shuffled in random order.
  *

package/dist/array/shuffle.d.ts

@@ -3,6 +3,7 @@
  *
  * This function takes an array and returns a new array with its elements shuffled in a random order.
  *
+ * @template T - The type of elements in the array.
  * @param {T[]} arr - The array to shuffle.
  * @returns {T[]} A new array with its elements shuffled in random order.
  *

package/dist/array/shuffle.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/array/shuffle.ts"],"sourcesContent":["/**\n * Randomizes the order of elements in an array using the Fisher-Yates algorithm.\n *\n * This function takes an array and returns a new array with its elements shuffled in a random order.\n *\n * @param {T[]} arr - The array to shuffle.\n * @returns {T[]} A new array with its elements shuffled in random order.\n *\n * @example\n * const array = [1, 2, 3, 4, 5];\n * const shuffledArray = shuffle(array);\n * // shuffledArray will be a new array with elements of array in random order, e.g., [3, 1, 4, 5, 2]\n */\nexport function shuffle<T>(arr: readonly T[]): T[] {\n  const result = arr.slice();\n\n  /**\n   * https://en.wikipedia.org/wiki/Fisher%E2%80%93Yates_shuffle#The_modern_algorithm\n   */\n  for (let i = result.length - 1; i >= 1; i--) {\n    const j = Math.floor(Math.random() * (i + 1));\n    [result[i], result[j]] = [result[j], result[i]];\n  }\n\n  return result;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAaO,SAAS,QAAW,KAAwB;AACjD,QAAM,SAAS,IAAI,MAAM;AAKzB,WAAS,IAAI,OAAO,SAAS,GAAG,KAAK,GAAG,KAAK;AAC3C,UAAM,IAAI,KAAK,MAAM,KAAK,OAAO,KAAK,IAAI,EAAE;AAC5C,KAAC,OAAO,CAAC,GAAG,OAAO,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC,CAAC;AAAA,EAChD;AAEA,SAAO;AACT;","names":[]}
+{"version":3,"sources":["../../src/array/shuffle.ts"],"sourcesContent":["/**\n * Randomizes the order of elements in an array using the Fisher-Yates algorithm.\n *\n * This function takes an array and returns a new array with its elements shuffled in a random order.\n *\n * @template T - The type of elements in the array.\n * @param {T[]} arr - The array to shuffle.\n * @returns {T[]} A new array with its elements shuffled in random order.\n *\n * @example\n * const array = [1, 2, 3, 4, 5];\n * const shuffledArray = shuffle(array);\n * // shuffledArray will be a new array with elements of array in random order, e.g., [3, 1, 4, 5, 2]\n */\nexport function shuffle<T>(arr: readonly T[]): T[] {\n  const result = arr.slice();\n\n  /**\n   * https://en.wikipedia.org/wiki/Fisher%E2%80%93Yates_shuffle#The_modern_algorithm\n   */\n  for (let i = result.length - 1; i >= 1; i--) {\n    const j = Math.floor(Math.random() * (i + 1));\n    [result[i], result[j]] = [result[j], result[i]];\n  }\n\n  return result;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAcO,SAAS,QAAW,KAAwB;AACjD,QAAM,SAAS,IAAI,MAAM;AAKzB,WAAS,IAAI,OAAO,SAAS,GAAG,KAAK,GAAG,KAAK;AAC3C,UAAM,IAAI,KAAK,MAAM,KAAK,OAAO,KAAK,IAAI,EAAE;AAC5C,KAAC,OAAO,CAAC,GAAG,OAAO,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC,CAAC;AAAA,EAChD;AAEA,SAAO;AACT;","names":[]}

package/dist/array/shuffle.mjs

@@ -1,6 +1,6 @@
 import {
   shuffle
-} from "../chunk-DPLJQQFX.mjs";
+} from "../chunk-G7UQ5PUR.mjs";
 import "../chunk-2MM5EJJX.mjs";
 export {
   shuffle

package/dist/array/takeRight.d.mts

@@ -2,6 +2,7 @@
  * Returns a new array containing the last `count` elements from the input array `arr`.
  * If `count` is greater than the length of `arr`, the entire array is returned.
  *
+ * @template T - The type of elements in the array.
  * @param {T[]} arr - The array to take elements from.
  * @param {number} count - The number of elements to take.
  * @returns {T[]} A new array containing the last `count` elements from `arr`.

package/dist/array/takeRight.d.ts

@@ -2,6 +2,7 @@
  * Returns a new array containing the last `count` elements from the input array `arr`.
  * If `count` is greater than the length of `arr`, the entire array is returned.
  *
+ * @template T - The type of elements in the array.
  * @param {T[]} arr - The array to take elements from.
  * @param {number} count - The number of elements to take.
  * @returns {T[]} A new array containing the last `count` elements from `arr`.

package/dist/array/takeRight.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/array/takeRight.ts"],"sourcesContent":["/**\n * Returns a new array containing the last `count` elements from the input array `arr`.\n * If `count` is greater than the length of `arr`, the entire array is returned.\n *\n * @param {T[]} arr - The array to take elements from.\n * @param {number} count - The number of elements to take.\n * @returns {T[]} A new array containing the last `count` elements from `arr`.\n *\n * @example\n * // Returns [4, 5]\n * takeRight([1, 2, 3, 4, 5], 2);\n *\n * @example\n * // Returns ['b', 'c']\n * takeRight(['a', 'b', 'c'], 2);\n *\n * @example\n * // Returns [1, 2, 3]\n * takeRight([1, 2, 3], 5);\n */\nexport function takeRight<T>(arr: readonly T[], count: number): T[] {\n  if (count === 0) {\n    return [];\n  }\n\n  return arr.slice(-count);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAoBO,SAAS,UAAa,KAAmB,OAAoB;AAClE,MAAI,UAAU,GAAG;AACf,WAAO,CAAC;AAAA,EACV;AAEA,SAAO,IAAI,MAAM,CAAC,KAAK;AACzB;","names":[]}
+{"version":3,"sources":["../../src/array/takeRight.ts"],"sourcesContent":["/**\n * Returns a new array containing the last `count` elements from the input array `arr`.\n * If `count` is greater than the length of `arr`, the entire array is returned.\n *\n * @template T - The type of elements in the array.\n * @param {T[]} arr - The array to take elements from.\n * @param {number} count - The number of elements to take.\n * @returns {T[]} A new array containing the last `count` elements from `arr`.\n *\n * @example\n * // Returns [4, 5]\n * takeRight([1, 2, 3, 4, 5], 2);\n *\n * @example\n * // Returns ['b', 'c']\n * takeRight(['a', 'b', 'c'], 2);\n *\n * @example\n * // Returns [1, 2, 3]\n * takeRight([1, 2, 3], 5);\n */\nexport function takeRight<T>(arr: readonly T[], count: number): T[] {\n  if (count === 0) {\n    return [];\n  }\n\n  return arr.slice(-count);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAqBO,SAAS,UAAa,KAAmB,OAAoB;AAClE,MAAI,UAAU,GAAG;AACf,WAAO,CAAC;AAAA,EACV;AAEA,SAAO,IAAI,MAAM,CAAC,KAAK;AACzB;","names":[]}

package/dist/array/takeRight.mjs

@@ -1,6 +1,6 @@
 import {
   takeRight
-} from "../chunk-XDKEPIUV.mjs";
+} from "../chunk-IQLKIDXF.mjs";
 import "../chunk-2MM5EJJX.mjs";
 export {
   takeRight

package/dist/array/union.d.mts

@@ -4,6 +4,7 @@
  * This function takes two arrays, merges them into a single array, and returns a new array
  * containing only the unique values from the merged array.
  *
+ * @template T - The type of elements in the array.
  * @param {T[]} arr1 - The first array to merge and filter for unique values.
  * @param {T[]} arr2 - The second array to merge and filter for unique values.
  * @returns {T[]} A new array of unique values.

package/dist/array/union.d.ts

@@ -4,6 +4,7 @@
  * This function takes two arrays, merges them into a single array, and returns a new array
  * containing only the unique values from the merged array.
  *
+ * @template T - The type of elements in the array.
  * @param {T[]} arr1 - The first array to merge and filter for unique values.
  * @param {T[]} arr2 - The second array to merge and filter for unique values.
  * @returns {T[]} A new array of unique values.

package/dist/array/union.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/array/union.ts","../../src/array/uniq.ts"],"sourcesContent":["import { uniq } from './uniq.ts';\n\n/**\n * Creates an array of unique values from all given arrays.\n *\n * This function takes two arrays, merges them into a single array, and returns a new array\n * containing only the unique values from the merged array.\n *\n * @param {T[]} arr1 - The first array to merge and filter for unique values.\n * @param {T[]} arr2 - The second array to merge and filter for unique values.\n * @returns {T[]} A new array of unique values.\n *\n * @example\n * const array1 = [1, 2, 3];\n * const array2 = [3, 4, 5];\n * const result = union(array1, array2);\n * // result will be [1, 2, 3, 4, 5]\n */\nexport function union<T>(arr1: readonly T[], arr2: readonly T[]): T[] {\n  return uniq(arr1.concat(arr2));\n}\n","/**\n * Creates a duplicate-free version of an array.\n *\n * This function takes an array and returns a new array containing only the unique values\n * from the original array, preserving the order of first occurrence.\n *\n * @param {T[]} arr - The array to process.\n * @returns {T[]} A new array with only unique values from the original array.\n *\n * @example\n * const array = [1, 2, 2, 3, 4, 4, 5];\n * const result = uniq(array);\n * // result will be [1, 2, 3, 4, 5]\n */\nexport function uniq<T>(arr: readonly T[]): T[] {\n  return Array.from(new Set(arr));\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACcO,SAAS,KAAQ,KAAwB;AAC9C,SAAO,MAAM,KAAK,IAAI,IAAI,GAAG,CAAC;AAChC;;;ADEO,SAAS,MAAS,MAAoB,MAAyB;AACpE,SAAO,KAAK,KAAK,OAAO,IAAI,CAAC;AAC/B;","names":[]}
+{"version":3,"sources":["../../src/array/union.ts","../../src/array/uniq.ts"],"sourcesContent":["import { uniq } from './uniq.ts';\n\n/**\n * Creates an array of unique values from all given arrays.\n *\n * This function takes two arrays, merges them into a single array, and returns a new array\n * containing only the unique values from the merged array.\n *\n * @template T - The type of elements in the array.\n * @param {T[]} arr1 - The first array to merge and filter for unique values.\n * @param {T[]} arr2 - The second array to merge and filter for unique values.\n * @returns {T[]} A new array of unique values.\n *\n * @example\n * const array1 = [1, 2, 3];\n * const array2 = [3, 4, 5];\n * const result = union(array1, array2);\n * // result will be [1, 2, 3, 4, 5]\n */\nexport function union<T>(arr1: readonly T[], arr2: readonly T[]): T[] {\n  return uniq(arr1.concat(arr2));\n}\n","/**\n * Creates a duplicate-free version of an array.\n *\n * This function takes an array and returns a new array containing only the unique values\n * from the original array, preserving the order of first occurrence.\n *\n * @template T - The type of elements in the array.\n * @param {T[]} arr - The array to process.\n * @returns {T[]} A new array with only unique values from the original array.\n *\n * @example\n * const array = [1, 2, 2, 3, 4, 4, 5];\n * const result = uniq(array);\n * // result will be [1, 2, 3, 4, 5]\n */\nexport function uniq<T>(arr: readonly T[]): T[] {\n  return Array.from(new Set(arr));\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACeO,SAAS,KAAQ,KAAwB;AAC9C,SAAO,MAAM,KAAK,IAAI,IAAI,GAAG,CAAC;AAChC;;;ADEO,SAAS,MAAS,MAAoB,MAAyB;AACpE,SAAO,KAAK,KAAK,OAAO,IAAI,CAAC;AAC/B;","names":[]}

package/dist/array/union.mjs

@@ -1,7 +1,7 @@
 import {
   union
-} from "../chunk-UPJXHWSJ.mjs";
-import "../chunk-XFCW7XJ4.mjs";
+} from "../chunk-R6QA7PLZ.mjs";
+import "../chunk-DVK2N4KC.mjs";
 import "../chunk-2MM5EJJX.mjs";
 export {
   union