es-toolkit 1.13.1-dev.332 → 1.13.1-dev.333

package/dist/array/index.mjs

@@ -1,211 +1,52 @@
-import "../chunk-DDH7K4QM.mjs";
-import {
-  zipWith
-} from "../chunk-MJ7LNBI6.mjs";
-import {
-  unzip
-} from "../chunk-JCRY7ZYS.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 {
-  zip
-} from "../chunk-OLORW442.mjs";
-import {
-  zipObject
-} from "../chunk-BGWHVWY4.mjs";
-import {
-  takeWhile
-} from "../chunk-2IXFGSUA.mjs";
-import {
-  toFilled
-} from "../chunk-XHSIT5DL.mjs";
-import {
-  union
-} from "../chunk-R6QA7PLZ.mjs";
-import {
-  unionBy
-} from "../chunk-NFS7RWWE.mjs";
-import {
-  unionWith
-} from "../chunk-2ZCITDMK.mjs";
-import {
-  uniq
-} from "../chunk-DVK2N4KC.mjs";
-import {
-  uniqBy
-} from "../chunk-B4COTK4K.mjs";
-import {
-  uniqWith
-} from "../chunk-237HGSZS.mjs";
-import {
-  partition
-} from "../chunk-DN3NOZ3H.mjs";
-import {
-  sample
-} from "../chunk-2KNLZB7V.mjs";
-import {
-  sampleSize
-} from "../chunk-EHSKB6DF.mjs";
-import "../chunk-GIWAOOFY.mjs";
-import "../chunk-SYWMYQYJ.mjs";
-import {
-  shuffle
-} from "../chunk-G7UQ5PUR.mjs";
-import {
-  tail
-} from "../chunk-DLS7UJKJ.mjs";
-import {
-  take
-} from "../chunk-ME352XO7.mjs";
-import {
-  takeRight
-} from "../chunk-N3QYJX4T.mjs";
-import {
-  takeRightWhile
-} from "../chunk-NTLX2MPV.mjs";
-import {
-  intersection
-} from "../chunk-FVVSE2F2.mjs";
-import {
-  intersectionBy
-} from "../chunk-O6UXZR3U.mjs";
-import {
-  intersectionWith
-} from "../chunk-XI7KRD2C.mjs";
-import {
-  keyBy
-} from "../chunk-AJKZMN2V.mjs";
-import {
-  last
-} from "../chunk-DTTKJ3VC.mjs";
-import {
-  maxBy
-} from "../chunk-OOKNBU4V.mjs";
-import {
-  minBy
-} from "../chunk-IJD7FE2Z.mjs";
-import {
-  orderBy
-} from "../chunk-7B7W36UP.mjs";
-import {
-  flatMap
-} from "../chunk-UY76KTPE.mjs";
-import {
-  flattenDeep
-} from "../chunk-ML727RRJ.mjs";
-import {
-  flatten
-} from "../chunk-33MSBDC6.mjs";
-import {
-  forEachRight
-} from "../chunk-IEA53J7P.mjs";
-import {
-  groupBy
-} from "../chunk-E6E4RZLN.mjs";
-import {
-  head
-} from "../chunk-FZZNWXDM.mjs";
-import {
-  initial
-} from "../chunk-XPSOKBRZ.mjs";
-import {
-  difference
-} from "../chunk-JPUKH67K.mjs";
-import {
-  differenceBy
-} from "../chunk-LVWX5B43.mjs";
-import {
-  differenceWith
-} from "../chunk-6NVQAHXP.mjs";
-import {
-  drop
-} from "../chunk-3EZAFZG3.mjs";
-import {
-  dropRight
-} from "../chunk-OXZCMC5I.mjs";
-import {
-  dropRightWhile
-} from "../chunk-M7SBBYV2.mjs";
-import {
-  dropWhile
-} from "../chunk-LJ2C6MVP.mjs";
-import {
-  fill
-} from "../chunk-GTFDDKZ2.mjs";
-import {
-  chunk
-} from "../chunk-E6C5EZQA.mjs";
-import {
-  compact
-} from "../chunk-PJPGJ2O6.mjs";
-import {
-  countBy
-} from "../chunk-Z7HWEOQX.mjs";
-import "../chunk-J5LGTIGS.mjs";
-export {
-  chunk,
-  compact,
-  countBy,
-  difference,
-  differenceBy,
-  differenceWith,
-  drop,
-  dropRight,
-  dropRightWhile,
-  dropWhile,
-  fill,
-  flatMap,
-  flatten,
-  flattenDeep,
-  forEachRight,
-  groupBy,
-  head,
-  initial,
-  intersection,
-  intersectionBy,
-  intersectionWith,
-  keyBy,
-  last,
-  maxBy,
-  minBy,
-  orderBy,
-  partition,
-  sample,
-  sampleSize,
-  shuffle,
-  tail,
-  take,
-  takeRight,
-  takeRightWhile,
-  takeWhile,
-  toFilled,
-  union,
-  unionBy,
-  unionWith,
-  uniq,
-  uniqBy,
-  uniqWith,
-  unzip,
-  unzipWith,
-  without,
-  xor,
-  xorBy,
-  xorWith,
-  zip,
-  zipObject,
-  zipWith
-};
-//# sourceMappingURL=index.mjs.map
+export { chunk } from './chunk.mjs';
+export { compact } from './compact.mjs';
+export { countBy } from './countBy.mjs';
+export { difference } from './difference.mjs';
+export { differenceBy } from './differenceBy.mjs';
+export { differenceWith } from './differenceWith.mjs';
+export { drop } from './drop.mjs';
+export { dropRight } from './dropRight.mjs';
+export { dropRightWhile } from './dropRightWhile.mjs';
+export { dropWhile } from './dropWhile.mjs';
+export { fill } from './fill.mjs';
+export { flatMap } from './flatMap.mjs';
+export { flatten } from './flatten.mjs';
+export { flattenDeep } from './flattenDeep.mjs';
+export { forEachRight } from './forEachRight.mjs';
+export { groupBy } from './groupBy.mjs';
+export { intersection } from './intersection.mjs';
+export { intersectionBy } from './intersectionBy.mjs';
+export { intersectionWith } from './intersectionWith.mjs';
+export { keyBy } from './keyBy.mjs';
+export { maxBy } from './maxBy.mjs';
+export { minBy } from './minBy.mjs';
+export { orderBy } from './orderBy.mjs';
+export { partition } from './partition.mjs';
+export { sample } from './sample.mjs';
+export { sampleSize } from './sampleSize.mjs';
+export { shuffle } from './shuffle.mjs';
+export { take } from './take.mjs';
+export { takeRight } from './takeRight.mjs';
+export { takeRightWhile } from './takeRightWhile.mjs';
+export { takeWhile } from './takeWhile.mjs';
+export { union } from './union.mjs';
+export { unionBy } from './unionBy.mjs';
+export { unionWith } from './unionWith.mjs';
+export { uniq } from './uniq.mjs';
+export { uniqBy } from './uniqBy.mjs';
+export { uniqWith } from './uniqWith.mjs';
+export { unzip } from './unzip.mjs';
+export { unzipWith } from './unzipWith.mjs';
+export { xor } from './xor.mjs';
+export { xorBy } from './xorBy.mjs';
+export { xorWith } from './xorWith.mjs';
+export { zip } from './zip.mjs';
+export { zipObject } from './zipObject.mjs';
+export { zipWith } from './zipWith.mjs';
+export { without } from './without.mjs';
+export { head } from './head.mjs';
+export { tail } from './tail.mjs';
+export { toFilled } from './toFilled.mjs';
+export { last } from './last.mjs';
+export { initial } from './initial.mjs';
+//# sourceMappingURL=index.mjs.map

package/dist/array/index.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}
+{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/array/initial.mjs

@@ -1,8 +1,9 @@
-import {
-  initial
-} from "../chunk-XPSOKBRZ.mjs";
-import "../chunk-J5LGTIGS.mjs";
-export {
-  initial
-};
-//# sourceMappingURL=initial.mjs.map
+function initial(arr) {
+    if (arr.length <= 1) {
+        return [];
+    }
+    return arr.slice(0, -1);
+}
+
+export { initial };
+//# sourceMappingURL=initial.mjs.map

package/dist/array/initial.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}
+{"version":3,"file":"initial.mjs","sources":["../../src/array/initial.ts"],"sourcesContent":["/**\n * Returns a new array containing all elements except the last one from the input array.\n * If the input array is empty or has only one element, the function returns an empty array.\n *\n * @template T The type of elements in the array.\n * @param {T[]} arr - The input array to query.\n * @returns {T[]} A new array containing all but the last element of the input array.\n *\n * @example\n * const arr = [1, 2, 3, 4];\n * const newArr = initial(arr);\n * // newArr will be [1, 2, 3]\n *\n * @example\n * const emptyArr: number[] = [];\n * const newEmptyArr = initial(emptyArr);\n * // newEmptyArr will be []\n *\n * @example\n * const singleElementArr = ['only one'];\n * const newSingleElementArr = initial(singleElementArr);\n * // newSingleElementArr will be []\n */\nexport function initial<T>(arr: T[]): T[] {\n  if (arr.length <= 1) {\n    return [];\n  }\n  return arr.slice(0, -1);\n}\n"],"names":[],"mappings":"AAuBM,SAAU,OAAO,CAAI,GAAQ,EAAA;AACjC,IAAA,IAAI,GAAG,CAAC,MAAM,IAAI,CAAC,EAAE;AACnB,QAAA,OAAO,EAAE,CAAC;KACX;IACD,OAAO,GAAG,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;AAC1B;;;;"}

package/dist/array/intersection.mjs

@@ -1,8 +1,9 @@
-import {
-  intersection
-} from "../chunk-FVVSE2F2.mjs";
-import "../chunk-J5LGTIGS.mjs";
-export {
-  intersection
-};
-//# sourceMappingURL=intersection.mjs.map
+function intersection(firstArr, secondArr) {
+    const secondSet = new Set(secondArr);
+    return firstArr.filter(item => {
+        return secondSet.has(item);
+    });
+}
+
+export { intersection };
+//# sourceMappingURL=intersection.mjs.map

package/dist/array/intersection.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}
+{"version":3,"file":"intersection.mjs","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"],"names":[],"mappings":"AAkBgB,SAAA,YAAY,CAAI,QAAsB,EAAE,SAAuB,EAAA;AAC7E,IAAA,MAAM,SAAS,GAAG,IAAI,GAAG,CAAC,SAAS,CAAC,CAAC;AAErC,IAAA,OAAO,QAAQ,CAAC,MAAM,CAAC,IAAI,IAAG;AAC5B,QAAA,OAAO,SAAS,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;AAC7B,KAAC,CAAC,CAAC;AACL;;;;"}

package/dist/array/intersectionBy.mjs

@@ -1,8 +1,7 @@
-import {
-  intersectionBy
-} from "../chunk-O6UXZR3U.mjs";
-import "../chunk-J5LGTIGS.mjs";
-export {
-  intersectionBy
-};
-//# sourceMappingURL=intersectionBy.mjs.map
+function intersectionBy(firstArr, secondArr, mapper) {
+    const mappedSecondSet = new Set(secondArr.map(mapper));
+    return firstArr.filter(item => mappedSecondSet.has(mapper(item)));
+}
+
+export { intersectionBy };
+//# sourceMappingURL=intersectionBy.mjs.map

package/dist/array/intersectionBy.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}
+{"version":3,"file":"intersectionBy.mjs","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"],"names":[],"mappings":"SAsBgB,cAAc,CAAO,QAAsB,EAAE,SAAuB,EAAE,MAAsB,EAAA;AAC1G,IAAA,MAAM,eAAe,GAAG,IAAI,GAAG,CAAC,SAAS,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC;AACvD,IAAA,OAAO,QAAQ,CAAC,MAAM,CAAC,IAAI,IAAI,eAAe,CAAC,GAAG,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;AACpE;;;;"}

package/dist/array/intersectionWith.mjs

@@ -1,8 +1,10 @@
-import {
-  intersectionWith
-} from "../chunk-XI7KRD2C.mjs";
-import "../chunk-J5LGTIGS.mjs";
-export {
-  intersectionWith
-};
-//# sourceMappingURL=intersectionWith.mjs.map
+function intersectionWith(firstArr, secondArr, areItemsEqual) {
+    return firstArr.filter(firstItem => {
+        return secondArr.some(secondItem => {
+            return areItemsEqual(firstItem, secondItem);
+        });
+    });
+}
+
+export { intersectionWith };
+//# sourceMappingURL=intersectionWith.mjs.map

package/dist/array/intersectionWith.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}
+{"version":3,"file":"intersectionWith.mjs","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"],"names":[],"mappings":"SAsBgB,gBAAgB,CAC9B,QAAsB,EACtB,SAAuB,EACvB,aAAsC,EAAA;AAEtC,IAAA,OAAO,QAAQ,CAAC,MAAM,CAAC,SAAS,IAAG;AACjC,QAAA,OAAO,SAAS,CAAC,IAAI,CAAC,UAAU,IAAG;AACjC,YAAA,OAAO,aAAa,CAAC,SAAS,EAAE,UAAU,CAAC,CAAC;AAC9C,SAAC,CAAC,CAAC;AACL,KAAC,CAAC,CAAC;AACL;;;;"}

package/dist/array/keyBy.mjs

@@ -1,8 +1,11 @@
-import {
-  keyBy
-} from "../chunk-AJKZMN2V.mjs";
-import "../chunk-J5LGTIGS.mjs";
-export {
-  keyBy
-};
-//# sourceMappingURL=keyBy.mjs.map
+function keyBy(arr, getKeyFromItem) {
+    const result = {};
+    for (const item of arr) {
+        const key = getKeyFromItem(item);
+        result[key] = item;
+    }
+    return result;
+}
+
+export { keyBy };
+//# sourceMappingURL=keyBy.mjs.map

package/dist/array/keyBy.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}
+{"version":3,"file":"keyBy.mjs","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"],"names":[],"mappings":"AA2BgB,SAAA,KAAK,CAA2B,GAAiB,EAAE,cAA8B,EAAA;IAC/F,MAAM,MAAM,GAAG,EAAkB,CAAC;AAElC,IAAA,KAAK,MAAM,IAAI,IAAI,GAAG,EAAE;AACtB,QAAA,MAAM,GAAG,GAAG,cAAc,CAAC,IAAI,CAAC,CAAC;AACjC,QAAA,MAAM,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC;KACpB;AAED,IAAA,OAAO,MAAM,CAAC;AAChB;;;;"}

package/dist/array/last.mjs

@@ -1,8 +1,6 @@
-import {
-  last
-} from "../chunk-DTTKJ3VC.mjs";
-import "../chunk-J5LGTIGS.mjs";
-export {
-  last
-};
-//# sourceMappingURL=last.mjs.map
+function last(arr) {
+    return arr[arr.length - 1];
+}
+
+export { last };
+//# sourceMappingURL=last.mjs.map

package/dist/array/last.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}
+{"version":3,"file":"last.mjs","sources":["../../src/array/last.ts"],"sourcesContent":["/**\n * Returns the last element of an array.\n *\n * This function takes an array and returns the last element of the array.\n * If the array is empty, the function returns `undefined`.\n *\n * Unlike some implementations, this function is optimized for performance\n * by directly accessing the last index of the array.\n *\n * @template T - The type of elements in the array.\n * @param {T[]} arr - The array from which to get the last element.\n * @returns {T | undefined} The last element of the array, or `undefined` if the array is empty.\n *\n * @example\n * const arr = [1, 2, 3];\n * const lastElement = last(arr);\n * // lastElement will be 3\n *\n * const emptyArr: number[] = [];\n * const noElement = last(emptyArr);\n * // noElement will be undefined\n */\n\nexport function last<T>(arr: readonly [...T[], T]): T;\nexport function last<T>(arr: readonly T[]): T | undefined;\nexport function last<T>(arr: readonly T[]): T | undefined {\n  return arr[arr.length - 1];\n}\n"],"names":[],"mappings":"AAyBM,SAAU,IAAI,CAAI,GAAiB,EAAA;IACvC,OAAO,GAAG,CAAC,GAAG,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;AAC7B;;;;"}

package/dist/array/maxBy.mjs

@@ -1,8 +1,15 @@
-import {
-  maxBy
-} from "../chunk-OOKNBU4V.mjs";
-import "../chunk-J5LGTIGS.mjs";
-export {
-  maxBy
-};
-//# sourceMappingURL=maxBy.mjs.map
+function maxBy(items, getValue) {
+    let maxElement = items[0];
+    let max = -Infinity;
+    for (const element of items) {
+        const value = getValue(element);
+        if (value > max) {
+            max = value;
+            maxElement = element;
+        }
+    }
+    return maxElement;
+}
+
+export { maxBy };
+//# sourceMappingURL=maxBy.mjs.map

package/dist/array/maxBy.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}
+{"version":3,"file":"maxBy.mjs","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"],"names":[],"mappings":"AAYgB,SAAA,KAAK,CAAI,KAAU,EAAE,QAAgC,EAAA;AACnE,IAAA,IAAI,UAAU,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;AAC1B,IAAA,IAAI,GAAG,GAAG,CAAC,QAAQ,CAAC;AAEpB,IAAA,KAAK,MAAM,OAAO,IAAI,KAAK,EAAE;AAC3B,QAAA,MAAM,KAAK,GAAG,QAAQ,CAAC,OAAO,CAAC,CAAC;AAChC,QAAA,IAAI,KAAK,GAAG,GAAG,EAAE;YACf,GAAG,GAAG,KAAK,CAAC;YACZ,UAAU,GAAG,OAAO,CAAC;SACtB;KACF;AAED,IAAA,OAAO,UAAU,CAAC;AACpB;;;;"}

package/dist/array/minBy.mjs

@@ -1,8 +1,15 @@
-import {
-  minBy
-} from "../chunk-IJD7FE2Z.mjs";
-import "../chunk-J5LGTIGS.mjs";
-export {
-  minBy
-};
-//# sourceMappingURL=minBy.mjs.map
+function minBy(items, getValue) {
+    let minElement = items[0];
+    let min = Infinity;
+    for (const element of items) {
+        const value = getValue(element);
+        if (value < min) {
+            min = value;
+            minElement = element;
+        }
+    }
+    return minElement;
+}
+
+export { minBy };
+//# sourceMappingURL=minBy.mjs.map

package/dist/array/minBy.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}
+{"version":3,"file":"minBy.mjs","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"],"names":[],"mappings":"AAYgB,SAAA,KAAK,CAAI,KAAU,EAAE,QAAgC,EAAA;AACnE,IAAA,IAAI,UAAU,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;IAC1B,IAAI,GAAG,GAAG,QAAQ,CAAC;AAEnB,IAAA,KAAK,MAAM,OAAO,IAAI,KAAK,EAAE;AAC3B,QAAA,MAAM,KAAK,GAAG,QAAQ,CAAC,OAAO,CAAC,CAAC;AAChC,QAAA,IAAI,KAAK,GAAG,GAAG,EAAE;YACf,GAAG,GAAG,KAAK,CAAC;YACZ,UAAU,GAAG,OAAO,CAAC;SACtB;KACF;AAED,IAAA,OAAO,UAAU,CAAC;AACpB;;;;"}

package/dist/array/orderBy.mjs

@@ -1,8 +1,26 @@
-import {
-  orderBy
-} from "../chunk-7B7W36UP.mjs";
-import "../chunk-J5LGTIGS.mjs";
-export {
-  orderBy
-};
-//# sourceMappingURL=orderBy.mjs.map
+function orderBy(collection, keys, orders) {
+    const compareValues = (a, b, order) => {
+        if (a < b) {
+            return order === 'asc' ? -1 : 1;
+        }
+        if (a > b) {
+            return order === 'asc' ? 1 : -1;
+        }
+        return 0;
+    };
+    const effectiveOrders = keys.map((_, index) => orders[index] || orders[orders.length - 1]);
+    return collection.slice().sort((a, b) => {
+        for (let i = 0; i < keys.length; i++) {
+            const key = keys[i];
+            const order = effectiveOrders[i];
+            const result = compareValues(a[key], b[key], order);
+            if (result !== 0) {
+                return result;
+            }
+        }
+        return 0;
+    });
+}
+
+export { orderBy };
+//# sourceMappingURL=orderBy.mjs.map

package/dist/array/orderBy.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}
+{"version":3,"file":"orderBy.mjs","sources":["../../src/array/orderBy.ts"],"sourcesContent":["type Order = 'asc' | 'desc';\n\n/**\n * Sorts an array of objects based on multiple properties and their corresponding order directions.\n *\n * This function takes an array of objects, an array of keys to sort by, and an array of order directions.\n * It returns the sorted array, ordering by each key according to its corresponding direction\n * ('asc' for ascending or 'desc' for descending). If values for a key are equal,\n * it moves to the next key to determine the order.\n *\n * @template T - The type of elements in the array.\n * @param {T[]} collection - The array of objects to be sorted.\n * @param {Array<keyof T>} keys - An array of keys (properties) by which to sort.\n * @param {Order[]} orders - An array of order directions ('asc' for ascending or 'desc' for descending).\n * @returns {T[]} - The sorted array.\n *\n * @example\n * // Sort an array of objects by 'user' in ascending order and 'age' in descending order.\n * const users = [\n *   { user: 'fred', age: 48 },\n *   { user: 'barney', age: 34 },\n *   { user: 'fred', age: 40 },\n *   { user: 'barney', age: 36 },\n * ];\n * const result = orderBy(users, ['user', 'age'], ['asc', 'desc']);\n * // result will be:\n * // [\n * //   { user: 'barney', age: 36 },\n * //   { user: 'barney', age: 34 },\n * //   { user: 'fred', age: 48 },\n * //   { user: 'fred', age: 40 },\n * // ]\n */\nexport function orderBy<T>(collection: T[], keys: Array<keyof T>, orders: Order[]): T[] {\n  const compareValues = (a: T[keyof T], b: T[keyof T], order: Order) => {\n    if (a < b) {\n      return order === 'asc' ? -1 : 1;\n    }\n    if (a > b) {\n      return order === 'asc' ? 1 : -1;\n    }\n    return 0;\n  };\n\n  const effectiveOrders = keys.map((_, index) => orders[index] || orders[orders.length - 1]);\n\n  return collection.slice().sort((a, b) => {\n    for (let i = 0; i < keys.length; i++) {\n      const key = keys[i];\n      const order = effectiveOrders[i];\n      const result = compareValues(a[key], b[key], order);\n      if (result !== 0) {\n        return result;\n      }\n    }\n    return 0;\n  });\n}\n"],"names":[],"mappings":"SAiCgB,OAAO,CAAI,UAAe,EAAE,IAAoB,EAAE,MAAe,EAAA;IAC/E,MAAM,aAAa,GAAG,CAAC,CAAa,EAAE,CAAa,EAAE,KAAY,KAAI;AACnE,QAAA,IAAI,CAAC,GAAG,CAAC,EAAE;AACT,YAAA,OAAO,KAAK,KAAK,KAAK,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC;SACjC;AACD,QAAA,IAAI,CAAC,GAAG,CAAC,EAAE;AACT,YAAA,OAAO,KAAK,KAAK,KAAK,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC;SACjC;AACD,QAAA,OAAO,CAAC,CAAC;AACX,KAAC,CAAC;IAEF,MAAM,eAAe,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,KAAK,KAAK,MAAM,CAAC,KAAK,CAAC,IAAI,MAAM,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC;AAE3F,IAAA,OAAO,UAAU,CAAC,KAAK,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,KAAI;AACtC,QAAA,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;AACpC,YAAA,MAAM,GAAG,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC;AACpB,YAAA,MAAM,KAAK,GAAG,eAAe,CAAC,CAAC,CAAC,CAAC;AACjC,YAAA,MAAM,MAAM,GAAG,aAAa,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,GAAG,CAAC,EAAE,KAAK,CAAC,CAAC;AACpD,YAAA,IAAI,MAAM,KAAK,CAAC,EAAE;AAChB,gBAAA,OAAO,MAAM,CAAC;aACf;SACF;AACD,QAAA,OAAO,CAAC,CAAC;AACX,KAAC,CAAC,CAAC;AACL;;;;"}

package/dist/array/partition.mjs

@@ -1,8 +1,16 @@
-import {
-  partition
-} from "../chunk-DN3NOZ3H.mjs";
-import "../chunk-J5LGTIGS.mjs";
-export {
-  partition
-};
-//# sourceMappingURL=partition.mjs.map
+function partition(arr, isInTruthy) {
+    const truthy = [];
+    const falsy = [];
+    for (const item of arr) {
+        if (isInTruthy(item)) {
+            truthy.push(item);
+        }
+        else {
+            falsy.push(item);
+        }
+    }
+    return [truthy, falsy];
+}
+
+export { partition };
+//# sourceMappingURL=partition.mjs.map

package/dist/array/partition.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}
+{"version":3,"file":"partition.mjs","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"],"names":[],"mappings":"AAsBgB,SAAA,SAAS,CAAI,GAAiB,EAAE,UAAiC,EAAA;IAC/E,MAAM,MAAM,GAAQ,EAAE,CAAC;IACvB,MAAM,KAAK,GAAQ,EAAE,CAAC;AAEtB,IAAA,KAAK,MAAM,IAAI,IAAI,GAAG,EAAE;AACtB,QAAA,IAAI,UAAU,CAAC,IAAI,CAAC,EAAE;AACpB,YAAA,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;SACnB;aAAM;AACL,YAAA,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;SAClB;KACF;AAED,IAAA,OAAO,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;AACzB;;;;"}

package/dist/array/sample.mjs

@@ -1,8 +1,7 @@
-import {
-  sample
-} from "../chunk-2KNLZB7V.mjs";
-import "../chunk-J5LGTIGS.mjs";
-export {
-  sample
-};
-//# sourceMappingURL=sample.mjs.map
+function sample(arr) {
+    const randomIndex = Math.floor(Math.random() * arr.length);
+    return arr[randomIndex];
+}
+
+export { sample };
+//# sourceMappingURL=sample.mjs.map

package/dist/array/sample.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}
+{"version":3,"file":"sample.mjs","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"],"names":[],"mappings":"AAcM,SAAU,MAAM,CAAI,GAAiB,EAAA;AACzC,IAAA,MAAM,WAAW,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,GAAG,CAAC,MAAM,CAAC,CAAC;AAC3D,IAAA,OAAO,GAAG,CAAC,WAAW,CAAC,CAAC;AAC1B;;;;"}

package/dist/array/sampleSize.mjs

@@ -1,10 +1,21 @@
-import {
-  sampleSize
-} from "../chunk-EHSKB6DF.mjs";
-import "../chunk-GIWAOOFY.mjs";
-import "../chunk-SYWMYQYJ.mjs";
-import "../chunk-J5LGTIGS.mjs";
-export {
-  sampleSize
-};
-//# sourceMappingURL=sampleSize.mjs.map
+import { randomInt } from '../math/randomInt.mjs';
+
+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 = 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;
+}
+
+export { sampleSize };
+//# sourceMappingURL=sampleSize.mjs.map

package/dist/array/sampleSize.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}
+{"version":3,"file":"sampleSize.mjs","sources":["../../src/array/sampleSize.ts"],"sourcesContent":["import { randomInt } from '../math/randomInt.ts';\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"],"names":[],"mappings":";;AAoBgB,SAAA,UAAU,CAAI,KAAmB,EAAE,IAAY,EAAA;AAC7D,IAAA,IAAI,IAAI,GAAG,KAAK,CAAC,MAAM,EAAE;AACvB,QAAA,MAAM,IAAI,KAAK,CAAC,yDAAyD,CAAC,CAAC;KAC5E;AAED,IAAA,MAAM,MAAM,GAAG,IAAI,KAAK,CAAC,IAAI,CAAC,CAAC;AAC/B,IAAA,MAAM,QAAQ,GAAG,IAAI,GAAG,EAAE,CAAC;IAE3B,KAAK,IAAI,IAAI,GAAG,KAAK,CAAC,MAAM,GAAG,IAAI,EAAE,WAAW,GAAG,CAAC,EAAE,IAAI,GAAG,KAAK,CAAC,MAAM,EAAE,IAAI,EAAE,EAAE,WAAW,EAAE,EAAE;QAChG,IAAI,KAAK,GAAG,SAAS,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,CAAC,CAAC;AAEnC,QAAA,IAAI,QAAQ,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE;YACvB,KAAK,GAAG,IAAI,CAAC;SACd;AAED,QAAA,QAAQ,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;QAEpB,MAAM,CAAC,WAAW,CAAC,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC;KACpC;AAED,IAAA,OAAO,MAAM,CAAC;AAChB;;;;"}