es-toolkit 1.13.1 → 1.14.0-dev.399

package/dist/chunk-BOOQBJN2.mjs

@@ -1,9 +0,0 @@
-// src/function/negate.ts
-function negate(func) {
-  return (...args) => !func(...args);
-}
-
-export {
-  negate
-};
-//# sourceMappingURL=chunk-BOOQBJN2.mjs.map

package/dist/chunk-BOOQBJN2.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/function/negate.ts"],"sourcesContent":["/**\n * Creates a function that negates the result of the predicate function.\n *\n * @template F - The type of the function to negate.\n * @param {F} func - The function to negate.\n * @returns {F} The new negated function, which negates the boolean result of `func`.\n */\nexport function negate<F extends (...args: unknown[]) => boolean>(func: F): F {\n    return ((...args: any[]) => !func(...args)) as F;\n}\n"],"mappings":";AAOO,SAAS,OAAkD,MAAY;AAC1E,SAAQ,IAAI,SAAgB,CAAC,KAAK,GAAG,IAAI;AAC7C;","names":[]}

package/dist/chunk-CMBC4MXG.mjs

@@ -1,19 +0,0 @@
-// src/function/once.ts
-function once(func) {
-  let called = false;
-  let cache;
-  return function() {
-    if (called) {
-      return cache;
-    }
-    const result = func();
-    called = true;
-    cache = result;
-    return result;
-  };
-}
-
-export {
-  once
-};
-//# sourceMappingURL=chunk-CMBC4MXG.mjs.map

package/dist/chunk-CMBC4MXG.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/function/once.ts"],"sourcesContent":["/**\n * Creates a function that is restricted to invoking the provided function `func` once.\n * Repeated calls to the function will return the value from the first invocation.\n *\n * @template F - The type of function.\n * @param {F} func - The function to restrict.\n * @returns {F} A new function that invokes `func` once and caches the result.\n *\n * @example\n * const initialize = once(() => {\n *   console.log('Initialized!');\n *   return true;\n * });\n *\n * initialize(); // Logs: 'Initialized!' and returns true\n * initialize(); // Returns true without logging\n */\nexport function once<F extends () => any>(func: F): F {\n  let called = false;\n  let cache: ReturnType<F> | undefined;\n\n  return function () {\n    if (called) {\n      return cache;\n    }\n\n    const result = func();\n\n    called = true;\n    cache = result;\n\n    return result;\n  } as F;\n}\n"],"mappings":";AAiBO,SAAS,KAA0B,MAAY;AACpD,MAAI,SAAS;AACb,MAAI;AAEJ,SAAO,WAAY;AACjB,QAAI,QAAQ;AACV,aAAO;AAAA,IACT;AAEA,UAAM,SAAS,KAAK;AAEpB,aAAS;AACT,YAAQ;AAER,WAAO;AAAA,EACT;AACF;","names":[]}

package/dist/chunk-CRSKT4WW.mjs

@@ -1,15 +0,0 @@
-// src/array/countBy.ts
-function countBy(arr, mapper) {
-  var _a;
-  const result = {};
-  for (const item of arr) {
-    const key = mapper(item);
-    result[key] = ((_a = result[key]) != null ? _a : 0) + 1;
-  }
-  return result;
-}
-
-export {
-  countBy
-};
-//# sourceMappingURL=chunk-CRSKT4WW.mjs.map

package/dist/chunk-CRSKT4WW.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/array/countBy.ts"],"sourcesContent":["/**\n * Count the occurrences of each item in an array\n * based on a transformation function.\n *\n * This function takes an array and a transformation function\n * that converts each item in the array to a string. It then\n * counts the occurrences of each transformed item and returns\n * an object with the transformed items as keys and the counts\n * as values.\n *\n * @template T - The type of the items in the input array.\n *\n * @param {T[]} arr - The input array to count occurrences.\n * @param {(item: T) => string} mapper - The transformation function that maps each item to a string key.\n * @returns {Record<string, number>} An object containing the transformed items as keys and the\n * counts as values.\n */\nexport function countBy<T>(arr: T[], mapper: (item: T) => string): Record<string, number> {\n  const result: Record<string, number> = {};\n  \n  for (const item of arr) {\n    const key = mapper(item);\n    \n    result[key] = (result[key] ?? 0) + 1;\n  }\n  \n  return result;\n}\n"],"mappings":";AAiBO,SAAS,QAAW,KAAU,QAAqD;AAjB1F;AAkBE,QAAM,SAAiC,CAAC;AAExC,aAAW,QAAQ,KAAK;AACtB,UAAM,MAAM,OAAO,IAAI;AAEvB,WAAO,GAAG,MAAK,YAAO,GAAG,MAAV,YAAe,KAAK;AAAA,EACrC;AAEA,SAAO;AACT;","names":[]}

package/dist/chunk-CVVZHOJX.mjs

@@ -1,22 +0,0 @@
-import {
-  delay
-} from "./chunk-O64NE2P4.mjs";
-import {
-  TimeoutError
-} from "./chunk-KIOYQRMQ.mjs";
-import {
-  __async
-} from "./chunk-24FKGR6U.mjs";
-
-// src/promise/timeout.ts
-function timeout(ms) {
-  return __async(this, null, function* () {
-    yield delay(ms);
-    throw new TimeoutError();
-  });
-}
-
-export {
-  timeout
-};
-//# sourceMappingURL=chunk-CVVZHOJX.mjs.map

package/dist/chunk-CVVZHOJX.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/promise/timeout.ts"],"sourcesContent":["import { delay } from './delay.ts';\nimport { TimeoutError } from '../error/TimeoutError.ts';\n\n/**\n * Returns a promise that rejects with a `TimeoutError` after a specified delay.\n *\n * @param {number} ms - The delay duration in milliseconds.\n * @returns {Promise<void>} A promise that rejects with a `TimeoutError` after the specified delay.\n * @throws {TimeoutError} Throws a `TimeoutError` after the specified delay.\n */\nexport async function timeout(ms: number): Promise<never> {\n  await delay(ms);\n  throw new TimeoutError();\n}\n"],"mappings":";;;;;;;;;;;AAUA,SAAsB,QAAQ,IAA4B;AAAA;AACxD,UAAM,MAAM,EAAE;AACd,UAAM,IAAI,aAAa;AAAA,EACzB;AAAA;","names":[]}

package/dist/chunk-DDH7K4QM.mjs

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

package/dist/chunk-DDH7K4QM.mjs.map

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

package/dist/chunk-DN3NOZ3H.mjs

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

package/dist/chunk-DN3NOZ3H.mjs.map

@@ -1 +0,0 @@
-{"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":";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/chunk-DPH2KE6O.mjs

@@ -1,24 +0,0 @@
-// src/math/range.ts
-function range(start, end, step) {
-  if (end == null) {
-    end = start;
-    start = 0;
-  }
-  if (step == null) {
-    step = 1;
-  }
-  if (!Number.isInteger(step) || step === 0) {
-    throw new Error(`The step value must be a non-zero integer.`);
-  }
-  const length = Math.max(Math.ceil((end - start) / step), 0);
-  const result = new Array(length);
-  for (let i = 0; i < length; i++) {
-    result[i] = start + i * step;
-  }
-  return result;
-}
-
-export {
-  range
-};
-//# sourceMappingURL=chunk-DPH2KE6O.mjs.map

package/dist/chunk-DPH2KE6O.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/math/range.ts"],"sourcesContent":["/**\n * Returns an array of numbers from `start` to `end`, incrementing by `step`.\n *\n * If `step` is not provided, it defaults to `1`.\n *\n * @param {number} start - The starting number of the range (inclusive).\n * @param {number} [end] - The end number of the range (exclusive).\n * @param {number} [step] - The step value for the range. (default: 1)\n * @returns {number[]} An array of numbers from `start` to `end` with the specified `step`.\n *\n * @example\n * // Returns [0, 1, 2, 3]\n * range(4);\n *\n * @example\n * // Returns [0, 5, 10, 15]\n * range(0, 20, 5);\n *\n * @example\n * // Returns [0, -1, -2, -3]\n * range(0, -4, -1);\n *\n * @example\n * // Throws an error: The step value must be a non-zero integer.\n * range(1, 4, 0);\n */\nexport function range(end: number): number[];\nexport function range(start: number, end: number): number[];\nexport function range(start: number, end: number, step: number): number[];\nexport function range(start: number, end?: number, step?: number): number[] {\n  if (end == null) {\n    end = start;\n    start = 0;\n  }\n\n  if (step == null) {\n    step = 1;\n  }\n\n  if (!Number.isInteger(step) || step === 0) {\n    throw new Error(`The step value must be a non-zero integer.`);\n  }\n\n  const length = Math.max(Math.ceil((end - start) / step), 0);\n  const result = new Array(length);\n\n  for (let i = 0; i < length; i++) {\n    result[i] = start + i * step;\n  }\n\n  return result;\n}\n"],"mappings":";AA6BO,SAAS,MAAM,OAAe,KAAc,MAAyB;AAC1E,MAAI,OAAO,MAAM;AACf,UAAM;AACN,YAAQ;AAAA,EACV;AAEA,MAAI,QAAQ,MAAM;AAChB,WAAO;AAAA,EACT;AAEA,MAAI,CAAC,OAAO,UAAU,IAAI,KAAK,SAAS,GAAG;AACzC,UAAM,IAAI,MAAM,4CAA4C;AAAA,EAC9D;AAEA,QAAM,SAAS,KAAK,IAAI,KAAK,MAAM,MAAM,SAAS,IAAI,GAAG,CAAC;AAC1D,QAAM,SAAS,IAAI,MAAM,MAAM;AAE/B,WAAS,IAAI,GAAG,IAAI,QAAQ,KAAK;AAC/B,WAAO,CAAC,IAAI,QAAQ,IAAI;AAAA,EAC1B;AAEA,SAAO;AACT;","names":[]}

package/dist/chunk-DTJJIMKJ.mjs

@@ -1,15 +0,0 @@
-// 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-DTJJIMKJ.mjs.map

package/dist/chunk-DTJJIMKJ.mjs.map

@@ -1 +0,0 @@
-{"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 * @template T - The type of elements in the array.\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":";AAaO,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-DVK2N4KC.mjs

@@ -1,9 +0,0 @@
-// src/array/uniq.ts
-function uniq(arr) {
-  return Array.from(new Set(arr));
-}
-
-export {
-  uniq
-};
-//# sourceMappingURL=chunk-DVK2N4KC.mjs.map

package/dist/chunk-DVK2N4KC.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/array/uniq.ts"],"sourcesContent":["/**\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":";AAeO,SAAS,KAAQ,KAAwB;AAC9C,SAAO,MAAM,KAAK,IAAI,IAAI,GAAG,CAAC;AAChC;","names":[]}

package/dist/chunk-DXB7EZUQ.mjs

@@ -1,12 +0,0 @@
-// src/error/AbortError.ts
-var AbortError = class extends Error {
-  constructor(message = "The operation was aborted") {
-    super(message);
-    this.name = "AbortError";
-  }
-};
-
-export {
-  AbortError
-};
-//# sourceMappingURL=chunk-DXB7EZUQ.mjs.map

package/dist/chunk-DXB7EZUQ.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/error/AbortError.ts"],"sourcesContent":["/**\n * An error class representing an aborted operation.\n * @augments Error\n */\nexport class AbortError extends Error {\n  constructor(message = 'The operation was aborted') {\n    super(message);\n    this.name = 'AbortError';\n  }\n}\n"],"mappings":";AAIO,IAAM,aAAN,cAAyB,MAAM;AAAA,EACpC,YAAY,UAAU,6BAA6B;AACjD,UAAM,OAAO;AACb,SAAK,OAAO;AAAA,EACd;AACF;","names":[]}

package/dist/chunk-E6C5EZQA.mjs

@@ -1,19 +0,0 @@
-// src/array/chunk.ts
-function chunk(arr, size) {
-  if (!Number.isInteger(size) || size <= 0) {
-    throw new Error("Size must be an integer greater than zero.");
-  }
-  const chunkLength = Math.ceil(arr.length / size);
-  const result = Array(chunkLength);
-  for (let index = 0; index < chunkLength; index++) {
-    const start = index * size;
-    const end = start + size;
-    result[index] = arr.slice(start, end);
-  }
-  return result;
-}
-
-export {
-  chunk
-};
-//# sourceMappingURL=chunk-E6C5EZQA.mjs.map

package/dist/chunk-E6C5EZQA.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/array/chunk.ts"],"sourcesContent":["/**\n * Splits an array into smaller arrays of a specified length.\n *\n * This function takes an input array and divides it into multiple smaller arrays,\n * each of a specified length. If the input array cannot be evenly divided,\n * the final sub-array will contain the remaining elements.\n *\n * @template T The type of elements in the array.\n * @param {T[]} arr - The array to be chunked into smaller arrays.\n * @param {number} size - The size of each smaller array. Must be a positive integer.\n * @returns {T[][]} A two-dimensional array where each sub-array has a maximum length of `size`.\n * @throws {Error} Throws an error if `size` is not a positive integer.\n *\n * @example\n * // Splits an array of numbers into sub-arrays of length 2\n * chunk([1, 2, 3, 4, 5], 2);\n * // Returns: [[1, 2], [3, 4], [5]]\n *\n * @example\n * // Splits an array of strings into sub-arrays of length 3\n * chunk(['a', 'b', 'c', 'd', 'e', 'f', 'g'], 3);\n * // Returns: [['a', 'b', 'c'], ['d', 'e', 'f'], ['g']]\n */\nexport function chunk<T>(arr: readonly T[], size: number): T[][] {\n  if (!Number.isInteger(size) || size <= 0) {\n    throw new Error('Size must be an integer greater than zero.');\n  }\n\n  const chunkLength = Math.ceil(arr.length / size);\n  const result: T[][] = Array(chunkLength);\n\n  for (let index = 0; index < chunkLength; index++) {\n    const start = index * size;\n    const end = start + size;\n\n    result[index] = arr.slice(start, end);\n  }\n\n  return result;\n}\n"],"mappings":";AAuBO,SAAS,MAAS,KAAmB,MAAqB;AAC/D,MAAI,CAAC,OAAO,UAAU,IAAI,KAAK,QAAQ,GAAG;AACxC,UAAM,IAAI,MAAM,4CAA4C;AAAA,EAC9D;AAEA,QAAM,cAAc,KAAK,KAAK,IAAI,SAAS,IAAI;AAC/C,QAAM,SAAgB,MAAM,WAAW;AAEvC,WAAS,QAAQ,GAAG,QAAQ,aAAa,SAAS;AAChD,UAAM,QAAQ,QAAQ;AACtB,UAAM,MAAM,QAAQ;AAEpB,WAAO,KAAK,IAAI,IAAI,MAAM,OAAO,GAAG;AAAA,EACtC;AAEA,SAAO;AACT;","names":[]}

package/dist/chunk-E6E4RZLN.mjs

@@ -1,17 +0,0 @@
-// src/array/groupBy.ts
-function groupBy(arr, getKeyFromItem) {
-  const result = {};
-  for (const item of arr) {
-    const key = getKeyFromItem(item);
-    if (result[key] == null) {
-      result[key] = [];
-    }
-    result[key].push(item);
-  }
-  return result;
-}
-
-export {
-  groupBy
-};
-//# sourceMappingURL=chunk-E6E4RZLN.mjs.map

package/dist/chunk-E6E4RZLN.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/array/groupBy.ts"],"sourcesContent":["/**\n * Groups the elements 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 arrays of elements that share\n * the same key.\n *\n * @template T - The type of elements in the array.\n * @template K - The type of keys.\n * @param {T[]} arr - The array to group.\n * @param {(item: T) => K} getKeyFromItem - A function that generates a key from an element.\n * @returns {Record<K, T[]>} An object where each key is associated with an array of elements that\n * share that key.\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 = groupBy(array, item => item.category);\n * // result will be:\n * // {\n * //   fruit: [\n * //     { category: 'fruit', name: 'apple' },\n * //     { category: 'fruit', name: 'banana' }\n * //   ],\n * //   vegetable: [\n * //     { category: 'vegetable', name: 'carrot' }\n * //   ]\n * // }\n */\nexport function groupBy<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\n    if (result[key] == null) {\n      result[key] = [];\n    }\n\n    result[key].push(item);\n  }\n\n  return result;\n}\n"],"mappings":";AAgCO,SAAS,QAAkC,KAAmB,gBAAgD;AACnH,QAAM,SAAS,CAAC;AAEhB,aAAW,QAAQ,KAAK;AACtB,UAAM,MAAM,eAAe,IAAI;AAE/B,QAAI,OAAO,GAAG,KAAK,MAAM;AACvB,aAAO,GAAG,IAAI,CAAC;AAAA,IACjB;AAEA,WAAO,GAAG,EAAE,KAAK,IAAI;AAAA,EACvB;AAEA,SAAO;AACT;","names":[]}

package/dist/chunk-EHSKB6DF.mjs

@@ -1,26 +0,0 @@
-import {
-  randomInt
-} from "./chunk-GIWAOOFY.mjs";
-
-// src/array/sampleSize.ts
-function sampleSize(array, size) {
-  if (size > array.length) {
-    throw new Error("Size must be less than or equal to the length of array.");
-  }
-  const result = new Array(size);
-  const selected = /* @__PURE__ */ new Set();
-  for (let step = array.length - size, resultIndex = 0; step < array.length; step++, resultIndex++) {
-    let index = randomInt(0, step + 1);
-    if (selected.has(index)) {
-      index = step;
-    }
-    selected.add(index);
-    result[resultIndex] = array[index];
-  }
-  return result;
-}
-
-export {
-  sampleSize
-};
-//# sourceMappingURL=chunk-EHSKB6DF.mjs.map

package/dist/chunk-EHSKB6DF.mjs.map

@@ -1 +0,0 @@
-{"version":3,"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"],"mappings":";;;;;AAoBO,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/chunk-EYYZQFOP.mjs

@@ -1,14 +0,0 @@
-import {
-  getWords
-} from "./chunk-WVQ7YVRK.mjs";
-
-// src/string/kebabCase.ts
-var kebabCase = (str) => {
-  const words = getWords(str);
-  return words.map((word) => word.toLowerCase()).join("-");
-};
-
-export {
-  kebabCase
-};
-//# sourceMappingURL=chunk-EYYZQFOP.mjs.map

package/dist/chunk-EYYZQFOP.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/string/kebabCase.ts"],"sourcesContent":["import { getWords } from './_internal/getWords.ts';\n\n/**\n * Converts a string to kebab case.\n *\n * Kebab case is the naming convention in which each word is written in lowercase and separated by a dash (-) character.\n *\n * @param {string} str - The string that is to be changed to kebab case.\n * @returns {string} - The converted string to kebab case.\n *\n * @example\n * const convertedStr1 = kebabCase('camelCase') // returns 'camel-case'\n * const convertedStr2 = kebabCase('some whitespace') // returns 'some-whitespace'\n * const convertedStr3 = kebabCase('hyphen-text') // returns 'hyphen-text'\n * const convertedStr4 = kebabCase('HTTPRequest') // returns 'http-request'\n */\n\nexport const kebabCase = (str: string): string => {\n  const words = getWords(str);\n  return words.map(word => word.toLowerCase()).join('-');\n};\n"],"mappings":";;;;;AAiBO,IAAM,YAAY,CAAC,QAAwB;AAChD,QAAM,QAAQ,SAAS,GAAG;AAC1B,SAAO,MAAM,IAAI,UAAQ,KAAK,YAAY,CAAC,EAAE,KAAK,GAAG;AACvD;","names":[]}

package/dist/chunk-F3WCQQET.mjs

@@ -1,14 +0,0 @@
-import {
-  getWords
-} from "./chunk-WVQ7YVRK.mjs";
-
-// src/string/snakeCase.ts
-var snakeCase = (str) => {
-  const words = getWords(str);
-  return words.map((word) => word.toLowerCase()).join("_");
-};
-
-export {
-  snakeCase
-};
-//# sourceMappingURL=chunk-F3WCQQET.mjs.map

package/dist/chunk-F3WCQQET.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/string/snakeCase.ts"],"sourcesContent":["import { getWords } from './_internal/getWords.ts';\n\n/**\n * Converts a string to snake case.\n *\n * Snake case is the naming convention in which each word is written in lowercase and separated by an underscore (_) character.\n *\n * @param {string} str - The string that is to be changed to snake case.\n * @returns {string} - The converted string to snake case.\n *\n * @example\n * const convertedStr1 = snakeCase('camelCase') // returns 'camel_case'\n * const convertedStr2 = snakeCase('some whitespace') // returns 'some_whitespace'\n * const convertedStr3 = snakeCase('hyphen-text') // returns 'hyphen_text'\n * const convertedStr4 = snakeCase('HTTPRequest') // returns 'http_request'\n */\n\nexport const snakeCase = (str: string): string => {\n  const words = getWords(str);\n  return words.map(word => word.toLowerCase()).join('_');\n};\n"],"mappings":";;;;;AAiBO,IAAM,YAAY,CAAC,QAAwB;AAChD,QAAM,QAAQ,SAAS,GAAG;AAC1B,SAAO,MAAM,IAAI,UAAQ,KAAK,YAAY,CAAC,EAAE,KAAK,GAAG;AACvD;","names":[]}

package/dist/chunk-F47GLYUU.mjs

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

package/dist/chunk-F47GLYUU.mjs.map

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

package/dist/chunk-FUS75PJ7.mjs

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

package/dist/chunk-FUS75PJ7.mjs.map

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

package/dist/chunk-FVVSE2F2.mjs

@@ -1,12 +0,0 @@
-// src/array/intersection.ts
-function intersection(firstArr, secondArr) {
-  const secondSet = new Set(secondArr);
-  return firstArr.filter((item) => {
-    return secondSet.has(item);
-  });
-}
-
-export {
-  intersection
-};
-//# sourceMappingURL=chunk-FVVSE2F2.mjs.map

package/dist/chunk-FVVSE2F2.mjs.map

@@ -1 +0,0 @@
-{"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":";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/chunk-G7UQ5PUR.mjs

@@ -1,14 +0,0 @@
-// src/array/shuffle.ts
-function shuffle(arr) {
-  const result = arr.slice();
-  for (let i = result.length - 1; i >= 1; i--) {
-    const j = Math.floor(Math.random() * (i + 1));
-    [result[i], result[j]] = [result[j], result[i]];
-  }
-  return result;
-}
-
-export {
-  shuffle
-};
-//# sourceMappingURL=chunk-G7UQ5PUR.mjs.map

package/dist/chunk-G7UQ5PUR.mjs.map

@@ -1 +0,0 @@
-{"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":";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/chunk-GIWAOOFY.mjs

@@ -1,13 +0,0 @@
-import {
-  random
-} from "./chunk-SYWMYQYJ.mjs";
-
-// src/math/randomInt.ts
-function randomInt(minimum, maximum) {
-  return Math.floor(random(minimum, maximum));
-}
-
-export {
-  randomInt
-};
-//# sourceMappingURL=chunk-GIWAOOFY.mjs.map

package/dist/chunk-GIWAOOFY.mjs.map

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

package/dist/chunk-HM2JT2RX.mjs

@@ -1,9 +0,0 @@
-// src/array/head.ts
-function head(arr) {
-  return arr[0];
-}
-
-export {
-  head
-};
-//# sourceMappingURL=chunk-HM2JT2RX.mjs.map

package/dist/chunk-HM2JT2RX.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/array/head.ts"],"sourcesContent":["/**\n * Returns the first element of an array.\n *\n * This function takes an array and returns the first element of the array.\n * If the array is empty, the function returns `undefined`.\n *\n * @param {T[]} arr - The array from which to get the first element.\n * @returns {T | undefined} The first element of the array, or `undefined` if the array is empty.\n *\n * @example\n * const arr = [1, 2, 3];\n * const firstElement = head(arr);\n * // firstElement will be 1\n *\n * const emptyArr: number[] = [];\n * const noElement = head(emptyArr);\n * // noElement will be undefined\n */\nexport function head<T>(arr: readonly [T, ...T[]]): T;\nexport function head<T>(arr: readonly T[]): T | undefined;\nexport function head<T>(arr: readonly T[]): T | undefined {\n  return arr[0];\n}\n"],"mappings":";AAoBO,SAAS,KAAQ,KAAkC;AACxD,SAAO,IAAI,CAAC;AACd;","names":[]}

package/dist/chunk-HPFDYUGP.mjs

@@ -1,13 +0,0 @@
-// src/object/pick.ts
-function pick(obj, keys) {
-  const result = {};
-  for (const key of keys) {
-    result[key] = obj[key];
-  }
-  return result;
-}
-
-export {
-  pick
-};
-//# sourceMappingURL=chunk-HPFDYUGP.mjs.map

package/dist/chunk-HPFDYUGP.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/object/pick.ts"],"sourcesContent":["/**\n * Creates a new object composed of the picked object properties.\n *\n * This function takes an object and an array of keys, and returns a new object that\n * includes only the properties corresponding to the specified keys.\n *\n * @template T - The type of object.\n * @template K - The type of keys in object.\n * @param {T} obj - The object to pick keys from.\n * @param {K[]} keys - An array of keys to be picked from the object.\n * @returns {Pick<T, K>} A new object with the specified keys picked.\n *\n * @example\n * const obj = { a: 1, b: 2, c: 3 };\n * const result = pick(obj, ['a', 'c']);\n * // result will be { a: 1, c: 3 }\n */\nexport function pick<T extends Record<string, any>, K extends keyof T>(obj: T, keys: K[]): Pick<T, K> {\n  const result = {} as Pick<T, K>;\n\n  for (const key of keys) {\n    result[key] = obj[key];\n  }\n\n  return result;\n}\n"],"mappings":";AAiBO,SAAS,KAAuD,KAAQ,MAAuB;AACpG,QAAM,SAAS,CAAC;AAEhB,aAAW,OAAO,MAAM;AACtB,WAAO,GAAG,IAAI,IAAI,GAAG;AAAA,EACvB;AAEA,SAAO;AACT;","names":[]}

package/dist/chunk-IDCUZVJL.mjs

@@ -1,18 +0,0 @@
-// src/array/zip.ts
-function zip(...arrs) {
-  const result = [];
-  const maxIndex = Math.max(...arrs.map((x) => x.length));
-  for (let i = 0; i < maxIndex; i++) {
-    const element = [];
-    for (const arr of arrs) {
-      element.push(arr[i]);
-    }
-    result.push(element);
-  }
-  return result;
-}
-
-export {
-  zip
-};
-//# sourceMappingURL=chunk-IDCUZVJL.mjs.map

package/dist/chunk-IDCUZVJL.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/array/zip.ts"],"sourcesContent":["/**\n * Combines multiple arrays into a single array of tuples.\n *\n * This function takes multiple arrays and returns a new array where each element is a tuple\n * containing the corresponding elements from the input arrays. If the input arrays are of\n * different lengths, the resulting array will have the length of the longest input array,\n * with undefined values for missing elements.\n *\n * @param {...T[][]} arrs - The arrays to zip together.\n * @returns {T[][]} A new array of tuples containing the corresponding elements from the input arrays.\n *\n * @example\n * const arr1 = [1, 2, 3];\n * const arr2 = ['a', 'b', 'c'];\n * const result = zip(arr1, arr2);\n * // result will be [[1, 'a'], [2, 'b'], [3, 'c']]\n *\n * const arr3 = [true, false];\n * const result2 = zip(arr1, arr2, arr3);\n * // result2 will be [[1, 'a', true], [2, 'b', false], [3, 'c', undefined]]\n */\nexport function zip<T>(arr1: readonly T[]): Array<[T]>;\nexport function zip<T, U>(arr1: readonly T[], arr2: readonly U[]): Array<[T, U]>;\nexport function zip<T, U, V>(arr1: readonly T[], arr2: readonly U[], arr3: readonly V[]): Array<[T, U, V]>;\nexport function zip<T, U, V, W>(\n  arr1: readonly T[],\n  arr2: readonly U[],\n  arr3: readonly V[],\n  arr4: readonly W[]\n): Array<[T, U, V, W]>;\nexport function zip<T>(...arrs: Array<readonly T[]>): T[][] {\n  const result: T[][] = [];\n\n  const maxIndex = Math.max(...arrs.map(x => x.length));\n\n  for (let i = 0; i < maxIndex; i++) {\n    const element: T[] = [];\n\n    for (const arr of arrs) {\n      element.push(arr[i]);\n    }\n\n    result.push(element);\n  }\n\n  return result;\n}\n"],"mappings":";AA8BO,SAAS,OAAU,MAAkC;AAC1D,QAAM,SAAgB,CAAC;AAEvB,QAAM,WAAW,KAAK,IAAI,GAAG,KAAK,IAAI,OAAK,EAAE,MAAM,CAAC;AAEpD,WAAS,IAAI,GAAG,IAAI,UAAU,KAAK;AACjC,UAAM,UAAe,CAAC;AAEtB,eAAW,OAAO,MAAM;AACtB,cAAQ,KAAK,IAAI,CAAC,CAAC;AAAA,IACrB;AAEA,WAAO,KAAK,OAAO;AAAA,EACrB;AAEA,SAAO;AACT;","names":[]}

package/dist/chunk-IEA53J7P.mjs

@@ -1,12 +0,0 @@
-// src/array/forEachRight.ts
-function forEachRight(arr, callback) {
-  for (let i = arr.length - 1; i >= 0; i--) {
-    const element = arr[i];
-    callback(element, i, arr);
-  }
-}
-
-export {
-  forEachRight
-};
-//# sourceMappingURL=chunk-IEA53J7P.mjs.map

package/dist/chunk-IEA53J7P.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/array/forEachRight.ts"],"sourcesContent":["/**\n * Iterates over elements of 'arr' from right to left and invokes 'callback' for each element.\n * \n * @template T - The type of elements in the array.\n * @param {T[]} arr - The array to iterate over.\n * @param {(value: T, index: number, arr: T[]) => void} callback - The function invoked per iteration.\n * The callback function receives three arguments:\n *  - 'value': The current element being processed in the array.\n *  - 'index': The index of the current element being processed in the array.\n *  - 'arr': The array 'forEachRight' was called upon.\n * \n * @example\n * const array = [1, 2, 3];\n * const result: number[] = [];\n * \n * // Use the forEachRight function to iterate through the array and add each element to the result array.\n * forEachRight(array, (value) => {\n *  result.push(value);\n * })\n * \n * console.log(result) // Output: [3, 2, 1]\n */\n\nexport function forEachRight<T>(arr: T[], callback: (value: T, index: number, arr: T[]) => void): void {\n  for (let i = arr.length - 1; i >= 0; i--) {\n    const element = arr[i];\n    callback(element, i, arr);\n  }\n}\n"],"mappings":";AAuBO,SAAS,aAAgB,KAAU,UAA6D;AACrG,WAAS,IAAI,IAAI,SAAS,GAAG,KAAK,GAAG,KAAK;AACxC,UAAM,UAAU,IAAI,CAAC;AACrB,aAAS,SAAS,GAAG,GAAG;AAAA,EAC1B;AACF;","names":[]}

package/dist/chunk-IFNXROZR.mjs

@@ -1,18 +0,0 @@
-// src/array/unzipWith.ts
-function unzipWith(target, iteratee) {
-  const maxLength = Math.max(...target.map((innerArray) => innerArray.length));
-  const result = new Array(maxLength);
-  for (let i = 0; i < maxLength; i++) {
-    const group = new Array(target.length);
-    for (let j = 0; j < target.length; j++) {
-      group[j] = target[j][i];
-    }
-    result[i] = iteratee(...group);
-  }
-  return result;
-}
-
-export {
-  unzipWith
-};
-//# sourceMappingURL=chunk-IFNXROZR.mjs.map

package/dist/chunk-IFNXROZR.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/array/unzipWith.ts"],"sourcesContent":["/**\n * Unzips an array of arrays, applying an `iteratee` function to regrouped elements.\n *\n * @template T, R\n * @param {T[][]} target - The nested array to unzip. This is an array of arrays,\n * where each inner array contains elements to be unzipped.\n * @param {(...args: T[]) => R} iteratee - A function to transform the unzipped elements.\n * @returns {R[]} A new array of unzipped and transformed elements. \n *\n * @example\n * const nestedArray = [[1, 2], [3, 4], [5, 6]];\n * const result = unzipWith(nestedArray, (item, item2, item3) => item + item2 + item3);\n * // result will be [9, 12]\n */\nexport function unzipWith<T, R>(target: readonly T[][], iteratee: (...args: T[]) => R): R[] {\n  const maxLength = Math.max(...target.map(innerArray => innerArray.length));\n  const result: R[] = new Array(maxLength);\n\n  for (let i = 0; i < maxLength; i++) {\n    const group = new Array(target.length);\n\n    for (let j = 0; j < target.length; j++) {\n      group[j] = target[j][i];\n    }\n\n    result[i] = iteratee(...group);\n  }\n\n  return result;\n}\n"],"mappings":";AAcO,SAAS,UAAgB,QAAwB,UAAoC;AAC1F,QAAM,YAAY,KAAK,IAAI,GAAG,OAAO,IAAI,gBAAc,WAAW,MAAM,CAAC;AACzE,QAAM,SAAc,IAAI,MAAM,SAAS;AAEvC,WAAS,IAAI,GAAG,IAAI,WAAW,KAAK;AAClC,UAAM,QAAQ,IAAI,MAAM,OAAO,MAAM;AAErC,aAAS,IAAI,GAAG,IAAI,OAAO,QAAQ,KAAK;AACtC,YAAM,CAAC,IAAI,OAAO,CAAC,EAAE,CAAC;AAAA,IACxB;AAEA,WAAO,CAAC,IAAI,SAAS,GAAG,KAAK;AAAA,EAC/B;AAEA,SAAO;AACT;","names":[]}

package/dist/chunk-IIDZ3KAJ.mjs

@@ -1,18 +0,0 @@
-import {
-  timeout
-} from "./chunk-CVVZHOJX.mjs";
-import {
-  __async
-} from "./chunk-24FKGR6U.mjs";
-
-// src/promise/withTimeout.ts
-function withTimeout(run, ms) {
-  return __async(this, null, function* () {
-    return Promise.race([run(), timeout(ms)]);
-  });
-}
-
-export {
-  withTimeout
-};
-//# sourceMappingURL=chunk-IIDZ3KAJ.mjs.map

package/dist/chunk-IIDZ3KAJ.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/promise/withTimeout.ts"],"sourcesContent":["import { timeout } from './timeout.ts';\n\n/**\n * Executes an async function and enforces a timeout. \n * \n * If the promise does not resolve within the specified time,\n * the timeout will trigger and the returned promise will be rejected.\n *\n *\n * @template T \n * @param {() => Promise<T>} run - A function that returns a promise to be executed.\n * @param {number} ms - The timeout duration in milliseconds.\n * @returns {Promise<T>} A promise that resolves with the result of the `run` function or rejects if the timeout is reached.\n *\n * @example\n * try {\n *   await withTimeout(() => {}, 1000); // Timeout exception after 1 second\n * } catch (error) {\n *   console.error(error); // Will log 'TimeoutError'\n * }\n */\nexport async function withTimeout<T>(run: () => Promise<T>, ms: number): Promise<T> {\n  return Promise.race([run(), timeout(ms) as T]);\n}\n"],"mappings":";;;;;;;;AAqBA,SAAsB,YAAe,KAAuB,IAAwB;AAAA;AAClF,WAAO,QAAQ,KAAK,CAAC,IAAI,GAAG,QAAQ,EAAE,CAAM,CAAC;AAAA,EAC/C;AAAA;","names":[]}

package/dist/chunk-IJD7FE2Z.mjs

@@ -1,18 +0,0 @@
-// 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-IJD7FE2Z.mjs.map

package/dist/chunk-IJD7FE2Z.mjs.map

@@ -1 +0,0 @@
-{"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":";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/chunk-IQLKIDXF.mjs

@@ -1,12 +0,0 @@
-// src/array/takeRight.ts
-function takeRight(arr, count) {
-  if (count === 0) {
-    return [];
-  }
-  return arr.slice(-count);
-}
-
-export {
-  takeRight
-};
-//# sourceMappingURL=chunk-IQLKIDXF.mjs.map

package/dist/chunk-IQLKIDXF.mjs.map

@@ -1 +0,0 @@
-{"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":";AAqBO,SAAS,UAAa,KAAmB,OAAoB;AAClE,MAAI,UAAU,GAAG;AACf,WAAO,CAAC;AAAA,EACV;AAEA,SAAO,IAAI,MAAM,CAAC,KAAK;AACzB;","names":[]}

package/dist/chunk-JPUKH67K.mjs

@@ -1,10 +0,0 @@
-// src/array/difference.ts
-function difference(firstArr, secondArr) {
-  const secondSet = new Set(secondArr);
-  return firstArr.filter((item) => !secondSet.has(item));
-}
-
-export {
-  difference
-};
-//# sourceMappingURL=chunk-JPUKH67K.mjs.map

package/dist/chunk-JPUKH67K.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/array/difference.ts"],"sourcesContent":["/**\n * Computes the difference between two arrays.\n *\n * This function takes two arrays and returns a new array containing the elements\n * that are present in the first array but not in the second array. It effectively\n * filters out any elements from the first array that also appear in the second array.\n *\n * @template T\n * @param {T[]} firstArr - The array from which to derive the difference. This is the primary array\n * from which elements will be compared and filtered.\n * @param {T[]} secondArr - The array containing elements to be excluded from the first array.\n * Each element in this array will be checked against the first array, and if a match is found,\n * that element will be excluded from the result.\n * @returns {T[]} A new array containing the elements that are present in the first array but not\n * in the second array.\n *\n * @example\n * const array1 = [1, 2, 3, 4, 5];\n * const array2 = [2, 4];\n * const result = difference(array1, array2);\n * // result will be [1, 3, 5] since 2 and 4 are in both arrays and are excluded from the result.\n */\nexport function difference<T>(firstArr: readonly T[], secondArr: readonly T[]): T[] {\n  const secondSet = new Set(secondArr);\n\n  return firstArr.filter(item => !secondSet.has(item));\n}\n"],"mappings":";AAsBO,SAAS,WAAc,UAAwB,WAA8B;AAClF,QAAM,YAAY,IAAI,IAAI,SAAS;AAEnC,SAAO,SAAS,OAAO,UAAQ,CAAC,UAAU,IAAI,IAAI,CAAC;AACrD;","names":[]}