es-toolkit 1.5.0 → 1.6.0-dev.113

package/dist/array/keyBy.d.mts

@@ -0,0 +1,28 @@
+/**
+ * Maps each element of an array based on a provided key-generating function.
+ *
+ * This function takes an array and a function that generates a key from each element. It returns
+ * an object where the keys are the generated keys and the values are the corresponding elements.
+ * If there are multiple elements generating the same key, the last element among them is used
+ * as the value.
+ *
+ * @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.
+ *
+ * @example
+ * const array = [
+ *   { category: 'fruit', name: 'apple' },
+ *   { category: 'fruit', name: 'banana' },
+ *   { category: 'vegetable', name: 'carrot' }
+ * ];
+ * const result = keyBy(array, item => item.category);
+ * // result will be:
+ * // {
+ * //   fruit: { category: 'fruit', name: 'banana' },
+ * //   vegetable: { category: 'vegetable', name: 'carrot' }
+ * // }
+ */
+declare function keyBy<T, K extends string>(arr: readonly T[], getKeyFromItem: (item: T) => K): Record<K, T>;
+
+export { keyBy };

package/dist/array/keyBy.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Maps each element of an array based on a provided key-generating function.
+ *
+ * This function takes an array and a function that generates a key from each element. It returns
+ * an object where the keys are the generated keys and the values are the corresponding elements.
+ * If there are multiple elements generating the same key, the last element among them is used
+ * as the value.
+ *
+ * @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.
+ *
+ * @example
+ * const array = [
+ *   { category: 'fruit', name: 'apple' },
+ *   { category: 'fruit', name: 'banana' },
+ *   { category: 'vegetable', name: 'carrot' }
+ * ];
+ * const result = keyBy(array, item => item.category);
+ * // result will be:
+ * // {
+ * //   fruit: { category: 'fruit', name: 'banana' },
+ * //   vegetable: { category: 'vegetable', name: 'carrot' }
+ * // }
+ */
+declare function keyBy<T, K extends string>(arr: readonly T[], getKeyFromItem: (item: T) => K): Record<K, T>;
+
+export { keyBy };

package/dist/array/keyBy.js

@@ -0,0 +1,38 @@
+"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/keyBy.ts
+var keyBy_exports = {};
+__export(keyBy_exports, {
+  keyBy: () => keyBy
+});
+module.exports = __toCommonJS(keyBy_exports);
+function keyBy(arr, getKeyFromItem) {
+  const result = {};
+  for (const item of arr) {
+    const key = getKeyFromItem(item);
+    result[key] = item;
+  }
+  return result;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  keyBy
+});
+//# sourceMappingURL=keyBy.js.map

package/dist/array/keyBy.js.map

@@ -0,0 +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":[]}

package/dist/array/keyBy.mjs

@@ -0,0 +1,8 @@
+import {
+  keyBy
+} from "../chunk-ZOTAORG3.mjs";
+import "../chunk-2MM5EJJX.mjs";
+export {
+  keyBy
+};
+//# sourceMappingURL=keyBy.mjs.map

package/dist/array/maxBy.d.mts

@@ -1,21 +1,14 @@
 /**
- * Returns the element of the specified array that has the maximum value, according to the specified selector.
- *
- * This function takes an array of elements and a selector function, and returns the element with the maximum value according to the selector.
- *
- * @param {T[]} elements - An array of elements to be compared.
- * @param {(element: T) => number} selector - A function that takes an element and returns a number.
- * @returns {T} The element with the maximum value according to the selector.
+ * Finds the element in an array that has the maximum value when applying
+ * the `getValue` function to each element.
  *
+ * @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.
  * @example
- * const people = [
- *  { name: 'Mark', age: 25 },
- *  { name: 'Nunu', age: 30 },
- *  { name: 'Overmars', age: 20 }
- *  ];
- *  const result = maxBy(people, person => person.age);
- *  // result will be { name: 'Nunu', age: 30 }
+ * maxBy([{ a: 1 }, { a: 2 }, { a: 3 }], x => x.a); // Returns: { a: 3 }
+ * maxBy([], x => x.a); // Returns: undefined
  */
-declare function maxBy<T>(elements: T[], selector: (element: T) => number): T;
+declare function maxBy<T>(items: T[], getValue: (element: T) => number): T;
 
 export { maxBy };

package/dist/array/maxBy.d.ts

@@ -1,21 +1,14 @@
 /**
- * Returns the element of the specified array that has the maximum value, according to the specified selector.
- *
- * This function takes an array of elements and a selector function, and returns the element with the maximum value according to the selector.
- *
- * @param {T[]} elements - An array of elements to be compared.
- * @param {(element: T) => number} selector - A function that takes an element and returns a number.
- * @returns {T} The element with the maximum value according to the selector.
+ * Finds the element in an array that has the maximum value when applying
+ * the `getValue` function to each element.
  *
+ * @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.
  * @example
- * const people = [
- *  { name: 'Mark', age: 25 },
- *  { name: 'Nunu', age: 30 },
- *  { name: 'Overmars', age: 20 }
- *  ];
- *  const result = maxBy(people, person => person.age);
- *  // result will be { name: 'Nunu', age: 30 }
+ * maxBy([{ a: 1 }, { a: 2 }, { a: 3 }], x => x.a); // Returns: { a: 3 }
+ * maxBy([], x => x.a); // Returns: undefined
  */
-declare function maxBy<T>(elements: T[], selector: (element: T) => number): T;
+declare function maxBy<T>(items: T[], getValue: (element: T) => number): T;
 
 export { maxBy };

package/dist/array/maxBy.js

@@ -23,11 +23,11 @@ __export(maxBy_exports, {
   maxBy: () => maxBy
 });
 module.exports = __toCommonJS(maxBy_exports);
-function maxBy(elements, selector) {
-  let maxElement = elements[0];
+function maxBy(items, getValue) {
+  let maxElement = items[0];
   let max = -Infinity;
-  for (const element of elements) {
-    const value = selector(element);
+  for (const element of items) {
+    const value = getValue(element);
     if (value > max) {
       max = value;
       maxElement = element;

package/dist/array/maxBy.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/array/maxBy.ts"],"sourcesContent":["/**\n * Returns the element of the specified array that has the maximum value, according to the specified selector.\n *\n * This function takes an array of elements and a selector function, and returns the element with the maximum value according to the selector.\n *\n * @param {T[]} elements - An array of elements to be compared.\n * @param {(element: T) => number} selector - A function that takes an element and returns a number.\n * @returns {T} The element with the maximum value according to the selector.\n *\n * @example\n * const people = [\n *  { name: 'Mark', age: 25 },\n *  { name: 'Nunu', age: 30 },\n *  { name: 'Overmars', age: 20 }\n *  ];\n *  const result = maxBy(people, person => person.age);\n *  // result will be { name: 'Nunu', age: 30 }\n */\nexport function maxBy<T>(elements: T[], selector: (element: T) => number): T {\n  let maxElement = elements[0];\n  let max = -Infinity;\n\n  for (const element of elements) {\n    const value = selector(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;AAkBO,SAAS,MAAS,UAAe,UAAqC;AAC3E,MAAI,aAAa,SAAS,CAAC;AAC3B,MAAI,MAAM;AAEV,aAAW,WAAW,UAAU;AAC9B,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 * @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":[]}

package/dist/array/maxBy.mjs

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

package/dist/array/minBy.d.mts

@@ -1,13 +1,14 @@
 /**
- * Returns the minimum value in an array of numbers.
+ * Finds the element in an array that has the minimum value when applying
+ * the `getValue` function to each element.
  *
- * This function takes an array of elements and a selector function, and returns the element with the minimum value according to the selector.
- *
- * If the array is empty, the function returns `undefined`.
- *
- * @param elements An array of elements.
- * @param selector A function that selects a number from an element.
+ * @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.
+ * @example
+ * minBy([{ a: 1 }, { a: 2 }, { a: 3 }], x => x.a); // Returns: { a: 1 }
+ * minBy([], x => x.a); // Returns: undefined
  */
-declare function minBy<T>(elements: T[], selector: (element: T) => number): T;
+declare function minBy<T>(items: T[], getValue: (element: T) => number): T;
 
 export { minBy };

package/dist/array/minBy.d.ts

@@ -1,13 +1,14 @@
 /**
- * Returns the minimum value in an array of numbers.
+ * Finds the element in an array that has the minimum value when applying
+ * the `getValue` function to each element.
  *
- * This function takes an array of elements and a selector function, and returns the element with the minimum value according to the selector.
- *
- * If the array is empty, the function returns `undefined`.
- *
- * @param elements An array of elements.
- * @param selector A function that selects a number from an element.
+ * @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.
+ * @example
+ * minBy([{ a: 1 }, { a: 2 }, { a: 3 }], x => x.a); // Returns: { a: 1 }
+ * minBy([], x => x.a); // Returns: undefined
  */
-declare function minBy<T>(elements: T[], selector: (element: T) => number): T;
+declare function minBy<T>(items: T[], getValue: (element: T) => number): T;
 
 export { minBy };

package/dist/array/minBy.js

@@ -23,11 +23,11 @@ __export(minBy_exports, {
   minBy: () => minBy
 });
 module.exports = __toCommonJS(minBy_exports);
-function minBy(elements, selector) {
-  let minElement = elements[0];
+function minBy(items, getValue) {
+  let minElement = items[0];
   let min = Infinity;
-  for (const element of elements) {
-    const value = selector(element);
+  for (const element of items) {
+    const value = getValue(element);
     if (value < min) {
       min = value;
       minElement = element;

package/dist/array/minBy.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/array/minBy.ts"],"sourcesContent":["/**\n * Returns the minimum value in an array of numbers.\n *\n * This function takes an array of elements and a selector function, and returns the element with the minimum value according to the selector.\n *\n * If the array is empty, the function returns `undefined`.\n *\n * @param elements An array of elements.\n * @param selector A function that selects a number from an element.\n */\nexport function minBy<T>(elements: T[], selector: (element: T) => number): T {\n  let minElement = elements[0];\n  let min = Infinity;\n\n  for (const element of elements) {\n    const value = selector(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;AAUO,SAAS,MAAS,UAAe,UAAqC;AAC3E,MAAI,aAAa,SAAS,CAAC;AAC3B,MAAI,MAAM;AAEV,aAAW,WAAW,UAAU;AAC9B,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 * @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":[]}

package/dist/array/minBy.mjs

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

package/dist/array/zipObject.d.mts

@@ -0,0 +1,33 @@
+/**
+ * Combines two arrays, one of property names and one of corresponding values, into a single object.
+ *
+ * This function takes two arrays: one containing property names and another containing corresponding values.
+ * It returns a new object where the property names from the first array are keys, and the corresponding elements
+ * from the second array are values. If the `keys` array is longer than the `values` array, the remaining keys will
+ * have `undefined` as their values.
+ *
+ * @param {P[]} keys - An array of property names.
+ * @param {V[]} values - An array of values corresponding to the property names.
+ * @returns {{ [K in P]: V }} A new object composed of the given property names and values.
+ *
+ * @example
+ * const keys = ['a', 'b', 'c'];
+ * const values = [1, 2, 3];
+ * const result = zipObject(keys, values);
+ * // result will be { a: 1, b: 2, c: 3 }
+ *
+ * const keys2 = ['a', 'b', 'c'];
+ * const values2 = [1, 2];
+ * const result2 = zipObject(keys2, values2);
+ * // result2 will be { a: 1, b: 2, c: undefined }
+ *
+ * const keys2 = ['a', 'b'];
+ * const values2 = [1, 2, 3];
+ * const result2 = zipObject(keys2, values2);
+ * // result2 will be { a: 1, b: 2 }
+ */
+declare function zipObject<P extends string | number | symbol, V>(keys: P[], values: V[]): {
+    [K in P]: V;
+};
+
+export { zipObject };

package/dist/array/zipObject.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Combines two arrays, one of property names and one of corresponding values, into a single object.
+ *
+ * This function takes two arrays: one containing property names and another containing corresponding values.
+ * It returns a new object where the property names from the first array are keys, and the corresponding elements
+ * from the second array are values. If the `keys` array is longer than the `values` array, the remaining keys will
+ * have `undefined` as their values.
+ *
+ * @param {P[]} keys - An array of property names.
+ * @param {V[]} values - An array of values corresponding to the property names.
+ * @returns {{ [K in P]: V }} A new object composed of the given property names and values.
+ *
+ * @example
+ * const keys = ['a', 'b', 'c'];
+ * const values = [1, 2, 3];
+ * const result = zipObject(keys, values);
+ * // result will be { a: 1, b: 2, c: 3 }
+ *
+ * const keys2 = ['a', 'b', 'c'];
+ * const values2 = [1, 2];
+ * const result2 = zipObject(keys2, values2);
+ * // result2 will be { a: 1, b: 2, c: undefined }
+ *
+ * const keys2 = ['a', 'b'];
+ * const values2 = [1, 2, 3];
+ * const result2 = zipObject(keys2, values2);
+ * // result2 will be { a: 1, b: 2 }
+ */
+declare function zipObject<P extends string | number | symbol, V>(keys: P[], values: V[]): {
+    [K in P]: V;
+};
+
+export { zipObject };

package/dist/array/zipObject.js

@@ -0,0 +1,37 @@
+"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/zipObject.ts
+var zipObject_exports = {};
+__export(zipObject_exports, {
+  zipObject: () => zipObject
+});
+module.exports = __toCommonJS(zipObject_exports);
+function zipObject(keys, values) {
+  const result = {};
+  for (let i = 0; i < keys.length; i++) {
+    result[keys[i]] = values[i];
+  }
+  return result;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  zipObject
+});
+//# sourceMappingURL=zipObject.js.map

package/dist/array/zipObject.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/array/zipObject.ts"],"sourcesContent":["/**\n * Combines two arrays, one of property names and one of corresponding values, into a single object.\n *\n * This function takes two arrays: one containing property names and another containing corresponding values.\n * It returns a new object where the property names from the first array are keys, and the corresponding elements\n * from the second array are values. If the `keys` array is longer than the `values` array, the remaining keys will\n * have `undefined` as their values.\n *\n * @param {P[]} keys - An array of property names.\n * @param {V[]} values - An array of values corresponding to the property names.\n * @returns {{ [K in P]: V }} A new object composed of the given property names and values.\n *\n * @example\n * const keys = ['a', 'b', 'c'];\n * const values = [1, 2, 3];\n * const result = zipObject(keys, values);\n * // result will be { a: 1, b: 2, c: 3 }\n *\n * const keys2 = ['a', 'b', 'c'];\n * const values2 = [1, 2];\n * const result2 = zipObject(keys2, values2);\n * // result2 will be { a: 1, b: 2, c: undefined }\n *\n * const keys2 = ['a', 'b'];\n * const values2 = [1, 2, 3];\n * const result2 = zipObject(keys2, values2);\n * // result2 will be { a: 1, b: 2 }\n */\nexport function zipObject<P extends string | number | symbol, V>(keys: P[], values: V[]): { [K in P]: V } {\n  const result = {} as { [K in P]: V };\n\n  for (let i = 0; i < keys.length; i++) {\n    result[keys[i]] = values[i];\n  }\n\n  return result;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AA4BO,SAAS,UAAiD,MAAW,QAA8B;AACxG,QAAM,SAAS,CAAC;AAEhB,WAAS,IAAI,GAAG,IAAI,KAAK,QAAQ,KAAK;AACpC,WAAO,KAAK,CAAC,CAAC,IAAI,OAAO,CAAC;AAAA,EAC5B;AAEA,SAAO;AACT;","names":[]}

package/dist/array/zipObject.mjs

@@ -0,0 +1,8 @@
+import {
+  zipObject
+} from "../chunk-DA7GSKQ5.mjs";
+import "../chunk-2MM5EJJX.mjs";
+export {
+  zipObject
+};
+//# sourceMappingURL=zipObject.mjs.map

package/dist/array/zipObject.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/chunk-DA7GSKQ5.mjs

@@ -0,0 +1,13 @@
+// src/array/zipObject.ts
+function zipObject(keys, values) {
+  const result = {};
+  for (let i = 0; i < keys.length; i++) {
+    result[keys[i]] = values[i];
+  }
+  return result;
+}
+
+export {
+  zipObject
+};
+//# sourceMappingURL=chunk-DA7GSKQ5.mjs.map

package/dist/chunk-DA7GSKQ5.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/array/zipObject.ts"],"sourcesContent":["/**\n * Combines two arrays, one of property names and one of corresponding values, into a single object.\n *\n * This function takes two arrays: one containing property names and another containing corresponding values.\n * It returns a new object where the property names from the first array are keys, and the corresponding elements\n * from the second array are values. If the `keys` array is longer than the `values` array, the remaining keys will\n * have `undefined` as their values.\n *\n * @param {P[]} keys - An array of property names.\n * @param {V[]} values - An array of values corresponding to the property names.\n * @returns {{ [K in P]: V }} A new object composed of the given property names and values.\n *\n * @example\n * const keys = ['a', 'b', 'c'];\n * const values = [1, 2, 3];\n * const result = zipObject(keys, values);\n * // result will be { a: 1, b: 2, c: 3 }\n *\n * const keys2 = ['a', 'b', 'c'];\n * const values2 = [1, 2];\n * const result2 = zipObject(keys2, values2);\n * // result2 will be { a: 1, b: 2, c: undefined }\n *\n * const keys2 = ['a', 'b'];\n * const values2 = [1, 2, 3];\n * const result2 = zipObject(keys2, values2);\n * // result2 will be { a: 1, b: 2 }\n */\nexport function zipObject<P extends string | number | symbol, V>(keys: P[], values: V[]): { [K in P]: V } {\n  const result = {} as { [K in P]: V };\n\n  for (let i = 0; i < keys.length; i++) {\n    result[keys[i]] = values[i];\n  }\n\n  return result;\n}\n"],"mappings":";AA4BO,SAAS,UAAiD,MAAW,QAA8B;AACxG,QAAM,SAAS,CAAC;AAEhB,WAAS,IAAI,GAAG,IAAI,KAAK,QAAQ,KAAK;AACpC,WAAO,KAAK,CAAC,CAAC,IAAI,OAAO,CAAC;AAAA,EAC5B;AAEA,SAAO;AACT;","names":[]}

package/dist/chunk-FXOABQRO.mjs

@@ -0,0 +1,18 @@
+// src/array/maxBy.ts
+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=chunk-FXOABQRO.mjs.map

package/dist/chunk-FXOABQRO.mjs.map

@@ -0,0 +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":";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":[]}

package/dist/chunk-NKTBEEIT.mjs

@@ -0,0 +1,15 @@
+// src/array/compact.ts
+function compact(arr) {
+  const result = [];
+  for (const item of arr) {
+    if (item) {
+      result.push(item);
+    }
+  }
+  return result;
+}
+
+export {
+  compact
+};
+//# sourceMappingURL=chunk-NKTBEEIT.mjs.map

package/dist/chunk-NKTBEEIT.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/array/compact.ts"],"sourcesContent":["type NotFalsey<T> = Exclude<T, false | null | 0 | '' | undefined>;\n\n/**\n * Removes falsey values (false, null, 0, '', undefined, NaN) from an array.\n *\n * @param {readonly T[]} arr - The input array to remove falsey values.\n * @returns {Array<Exclude<T, false | null | 0 | '' | undefined>>} - A new array with all falsey values removed.\n *\n * @example\n * compact([0, 1, false, 2, '', 3, null, undefined, 4, NaN, 5]);\n * Returns: [1, 2, 3, 4, 5]\n */\nexport function compact<T>(arr: readonly T[]): Array<NotFalsey<T>> {\n  const result: Array<NotFalsey<T>> = [];\n\n  for (const item of arr) {\n    if (item) {\n      result.push(item as NotFalsey<T>);\n    }\n  }\n\n  return result;\n}\n"],"mappings":";AAYO,SAAS,QAAW,KAAwC;AACjE,QAAM,SAA8B,CAAC;AAErC,aAAW,QAAQ,KAAK;AACtB,QAAI,MAAM;AACR,aAAO,KAAK,IAAoB;AAAA,IAClC;AAAA,EACF;AAEA,SAAO;AACT;","names":[]}

package/dist/{chunk-7OU22ENP.mjs → chunk-NOFHNJ5C.mjs}

@@ -10,4 +10,4 @@ function sum(nums) {
 export {
   sum
 };
-//# sourceMappingURL=chunk-7OU22ENP.mjs.map
+//# sourceMappingURL=chunk-NOFHNJ5C.mjs.map

package/dist/{chunk-7OU22ENP.mjs.map → chunk-NOFHNJ5C.mjs.map}

@@ -1 +1 @@
-{"version":3,"sources":["../src/math/sum.ts"],"sourcesContent":["/**\n * Calculates the sum of an array of numbers.\n *\n * This function takes an array of numbers and returns the sum of all the elements in the array.\n *\n * @param {number[]} nums - An array of numbers to be summed.\n * @returns {number} The sum of all the numbers in the array.\n *\n * @example\n * const numbers = [1, 2, 3, 4, 5];\n * const result = sum(numbers);\n * // result will be 15\n */\nexport function sum(nums: number[]): number {\n  let result = 0;\n\n  for (const num of nums) {\n    result += num;\n  }\n\n  return result;\n}\n"],"mappings":";AAaO,SAAS,IAAI,MAAwB;AAC1C,MAAI,SAAS;AAEb,aAAW,OAAO,MAAM;AACtB,cAAU;AAAA,EACZ;AAEA,SAAO;AACT;","names":[]}
+{"version":3,"sources":["../src/math/sum.ts"],"sourcesContent":["/**\n * Calculates the sum of an array of numbers.\n *\n * This function takes an array of numbers and returns the sum of all the elements in the array.\n *\n * @param {number[]} nums - An array of numbers to be summed.\n * @returns {number} The sum of all the numbers in the array.\n *\n * @example\n * const numbers = [1, 2, 3, 4, 5];\n * const result = sum(numbers);\n * // result will be 15\n */\nexport function sum(nums: readonly number[]): number {\n  let result = 0;\n\n  for (const num of nums) {\n    result += num;\n  }\n\n  return result;\n}\n"],"mappings":";AAaO,SAAS,IAAI,MAAiC;AACnD,MAAI,SAAS;AAEb,aAAW,OAAO,MAAM;AACtB,cAAU;AAAA,EACZ;AAEA,SAAO;AACT;","names":[]}

package/dist/chunk-OIHARMNM.mjs

@@ -0,0 +1,18 @@
+// src/array/minBy.ts
+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=chunk-OIHARMNM.mjs.map

package/dist/chunk-OIHARMNM.mjs.map

@@ -0,0 +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":";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":[]}

package/dist/chunk-QVHWSUEH.mjs

@@ -0,0 +1 @@
+//# sourceMappingURL=chunk-QVHWSUEH.mjs.map

package/dist/chunk-QVHWSUEH.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/chunk-S3GNYAM2.mjs

@@ -0,0 +1,13 @@
+import {
+  sum
+} from "./chunk-NOFHNJ5C.mjs";
+
+// src/math/mean.ts
+function mean(nums) {
+  return sum(nums) / nums.length;
+}
+
+export {
+  mean
+};
+//# sourceMappingURL=chunk-S3GNYAM2.mjs.map

package/dist/chunk-S3GNYAM2.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/math/mean.ts"],"sourcesContent":["import { sum } from './sum';\n\n/**\n * Calculates the average of an array of numbers.\n *\n * If the array is empty, this function returns `NaN`.\n *\n * @param {number[]} nums - An array of numbers to calculate the avverage.\n * @returns {number} The average of all the numbers in the array.\n *\n * @example\n * const numbers = [1, 2, 3, 4, 5];\n * const result = average(numbers);\n * // result will be 3\n */\nexport function mean(nums: readonly number[]): number {\n  return sum(nums) / nums.length;\n}\n"],"mappings":";;;;;AAeO,SAAS,KAAK,MAAiC;AACpD,SAAO,IAAI,IAAI,IAAI,KAAK;AAC1B;","names":[]}

package/dist/{chunk-LCP6FOCX.mjs → chunk-SYWMYQYJ.mjs}

@@ -1,5 +1,9 @@
 // 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.");
   }
@@ -9,4 +13,4 @@ function random(minimum, maximum) {
 export {
   random
 };
-//# sourceMappingURL=chunk-LCP6FOCX.mjs.map
+//# sourceMappingURL=chunk-SYWMYQYJ.mjs.map

package/dist/chunk-SYWMYQYJ.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/math/random.ts"],"sourcesContent":["/**\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"],"mappings":";AAiBO,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;","names":[]}

package/dist/chunk-V6MDTRGS.mjs

@@ -0,0 +1 @@
+//# sourceMappingURL=chunk-V6MDTRGS.mjs.map

package/dist/chunk-V6MDTRGS.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/{chunk-5UT77WON.mjs → chunk-WC5HFQXP.mjs}

@@ -1,6 +1,6 @@
 import {
   random
-} from "./chunk-LCP6FOCX.mjs";
+} from "./chunk-SYWMYQYJ.mjs";
 
 // src/math/randomInt.ts
 function randomInt(minimum, maximum) {
@@ -10,4 +10,4 @@ function randomInt(minimum, maximum) {
 export {
   randomInt
 };
-//# sourceMappingURL=chunk-5UT77WON.mjs.map
+//# sourceMappingURL=chunk-WC5HFQXP.mjs.map

package/dist/chunk-WC5HFQXP.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/math/randomInt.ts"],"sourcesContent":["import { random } from './random';\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":";;;;;AAkBO,SAAS,UAAU,SAAiB,SAA0B;AACnE,SAAO,KAAK,MAAM,OAAO,SAAS,OAAQ,CAAC;AAC7C;","names":[]}

package/dist/chunk-ZOTAORG3.mjs

@@ -0,0 +1,14 @@
+// src/array/keyBy.ts
+function keyBy(arr, getKeyFromItem) {
+  const result = {};
+  for (const item of arr) {
+    const key = getKeyFromItem(item);
+    result[key] = item;
+  }
+  return result;
+}
+
+export {
+  keyBy
+};
+//# sourceMappingURL=chunk-ZOTAORG3.mjs.map

package/dist/chunk-ZOTAORG3.mjs.map

@@ -0,0 +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":";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":[]}