es-toolkit 1.6.1 → 1.7.0-dev.146

package/dist/{chunk-VKM3R5T5.mjs → chunk-L7FQX5MN.mjs}

@@ -1,9 +1,9 @@
 import {
   union
-} from "./chunk-UPJXHWSJ.mjs";
+} from "./chunk-R6QA7PLZ.mjs";
 import {
   intersection
-} from "./chunk-PYLGHB3F.mjs";
+} from "./chunk-FVVSE2F2.mjs";
 import {
   difference
 } from "./chunk-JPUKH67K.mjs";
@@ -16,4 +16,4 @@ function xor(arr1, arr2) {
 export {
   xor
 };
-//# sourceMappingURL=chunk-VKM3R5T5.mjs.map
+//# sourceMappingURL=chunk-L7FQX5MN.mjs.map

package/dist/chunk-L7FQX5MN.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/array/xor.ts"],"sourcesContent":["import { difference } from './difference.ts';\nimport { intersection } from './intersection.ts';\nimport { union } from './union.ts';\n\n/**\n * Computes the symmetric difference between two arrays. The symmetric difference is the set of elements\n * which are in either of the arrays, but not in their intersection.\n *\n * @template T - The type of elements in the array.\n * @param {T[]} arr1 - The first array.\n * @param {T[]} arr2 - The second array.\n * @returns {T[]} An array containing the elements that are present in either `arr1` or `arr2` but not in both.\n *\n * @example\n * // Returns [1, 2, 5, 6]\n * xor([1, 2, 3, 4], [3, 4, 5, 6]);\n *\n * @example\n * // Returns ['a', 'c']\n * xor(['a', 'b'], ['b', 'c']);\n */\nexport function xor<T>(arr1: readonly T[], arr2: readonly T[]): T[] {\n  return difference(union(arr1, arr2), intersection(arr1, arr2));\n}\n"],"mappings":";;;;;;;;;;;AAqBO,SAAS,IAAO,MAAoB,MAAyB;AAClE,SAAO,WAAW,MAAM,MAAM,IAAI,GAAG,aAAa,MAAM,IAAI,CAAC;AAC/D;","names":[]}

package/dist/{chunk-K2BAFL2T.mjs → chunk-LJ2C6MVP.mjs}

@@ -10,4 +10,4 @@ function dropWhile(arr, canContinueDropping) {
 export {
   dropWhile
 };
-//# sourceMappingURL=chunk-K2BAFL2T.mjs.map
+//# sourceMappingURL=chunk-LJ2C6MVP.mjs.map

package/dist/chunk-LJ2C6MVP.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/array/dropWhile.ts"],"sourcesContent":["/**\n * Removes elements from the beginning of an array until the predicate returns false.\n *\n * This function iterates over an array and drops elements from the start until the provided\n * predicate function returns false. It then returns a new array with the remaining elements.\n *\n * @template T - The type of elements in the array.\n * @param {T[]} arr - The array from which to drop elements.\n * @param {(item: T) => boolean} canContinueDropping - A predicate function that determines\n * whether to continue dropping elements. The function is called with each element, and dropping\n * continues as long as it returns true.\n * @returns {T[]} A new array with the elements remaining after the predicate returns false.\n *\n * @example\n * const array = [1, 2, 3, 4, 5];\n * const result = dropWhile(array, x => x < 3);\n * // result will be [3, 4, 5] since elements less than 3 are dropped.\n */\nexport function dropWhile<T>(arr: readonly T[], canContinueDropping: (item: T) => boolean): T[] {\n  const dropEndIndex = arr.findIndex(item => !canContinueDropping(item));\n  if (dropEndIndex === -1) {\n    return [];\n  }\n\n  return arr.slice(dropEndIndex);\n}\n"],"mappings":";AAkBO,SAAS,UAAa,KAAmB,qBAAgD;AAC9F,QAAM,eAAe,IAAI,UAAU,UAAQ,CAAC,oBAAoB,IAAI,CAAC;AACrE,MAAI,iBAAiB,IAAI;AACvB,WAAO,CAAC;AAAA,EACV;AAEA,SAAO,IAAI,MAAM,YAAY;AAC/B;","names":[]}

package/dist/{chunk-KHK7LKE5.mjs → chunk-LT6E4Y4Z.mjs}

@@ -10,4 +10,4 @@ function mean(nums) {
 export {
   mean
 };
-//# sourceMappingURL=chunk-KHK7LKE5.mjs.map
+//# sourceMappingURL=chunk-LT6E4Y4Z.mjs.map

package/dist/chunk-LT6E4Y4Z.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/math/mean.ts"],"sourcesContent":["import { sum } from './sum.ts';\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 average.\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-NRNKP6JF.mjs → chunk-NFS7RWWE.mjs}

@@ -13,4 +13,4 @@ function unionBy(arr1, arr2, mapper) {
 export {
   unionBy
 };
-//# sourceMappingURL=chunk-NRNKP6JF.mjs.map
+//# sourceMappingURL=chunk-NFS7RWWE.mjs.map

package/dist/chunk-NFS7RWWE.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/array/unionBy.ts"],"sourcesContent":["/**\n * Creates an array of unique values, in order, from all given arrays using a provided mapping function to determine equality.\n *\n * @template T - The type of elements in the array.\n * @template U - The type of mapped elements.\n * @param {T[]} arr1 - The first array.\n * @param {T[]} arr2 - The second array.\n * @param {(item: T) => U} mapper - The function to map array elements to comparison values.\n * @returns {T[]} A new array containing the union of unique elements from `arr1` and `arr2`, based on the values returned by the mapping function.\n *\n * @example\n * // Custom mapping function for numbers (modulo comparison)\n * const moduloMapper = (x) => x % 3;\n * unionBy([1, 2, 3], [4, 5, 6], moduloMapper);\n * // Returns [1, 2, 3]\n *\n * @example\n * // Custom mapping function for objects with an 'id' property\n * const idMapper = (obj) => obj.id;\n * unionBy([{ id: 1 }, { id: 2 }], [{ id: 2 }, { id: 3 }], idMapper);\n * // Returns [{ id: 1 }, { id: 2 }, { id: 3 }]\n */\nexport function unionBy<T, U>(arr1: readonly T[], arr2: readonly T[], mapper: (item: T) => U): T[] {\n  const map = new Map<U, T>();\n\n  for (const item of [...arr1, ...arr2]) {\n    const key = mapper(item);\n\n    if (!map.has(key)) {\n      map.set(key, item);\n    }\n  }\n\n  return Array.from(map.values());\n}\n"],"mappings":";AAsBO,SAAS,QAAc,MAAoB,MAAoB,QAA6B;AACjG,QAAM,MAAM,oBAAI,IAAU;AAE1B,aAAW,QAAQ,CAAC,GAAG,MAAM,GAAG,IAAI,GAAG;AACrC,UAAM,MAAM,OAAO,IAAI;AAEvB,QAAI,CAAC,IAAI,IAAI,GAAG,GAAG;AACjB,UAAI,IAAI,KAAK,IAAI;AAAA,IACnB;AAAA,EACF;AAEA,SAAO,MAAM,KAAK,IAAI,OAAO,CAAC;AAChC;","names":[]}

package/dist/{chunk-CDA4NK7J.mjs → chunk-O64NE2P4.mjs}

@@ -1,6 +1,6 @@
 import {
   AbortError
-} from "./chunk-VP2LXY75.mjs";
+} from "./chunk-DXB7EZUQ.mjs";
 
 // src/promise/delay.ts
 function delay(ms, { signal } = {}) {
@@ -23,4 +23,4 @@ function delay(ms, { signal } = {}) {
 export {
   delay
 };
-//# sourceMappingURL=chunk-CDA4NK7J.mjs.map
+//# sourceMappingURL=chunk-O64NE2P4.mjs.map

package/dist/{chunk-GNSJP2AB.mjs → chunk-O6UXZR3U.mjs}

@@ -7,4 +7,4 @@ function intersectionBy(firstArr, secondArr, mapper) {
 export {
   intersectionBy
 };
-//# sourceMappingURL=chunk-GNSJP2AB.mjs.map
+//# sourceMappingURL=chunk-O6UXZR3U.mjs.map

package/dist/chunk-O6UXZR3U.mjs.map

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

package/dist/{chunk-FXOABQRO.mjs → chunk-OOKNBU4V.mjs}

@@ -15,4 +15,4 @@ function maxBy(items, getValue) {
 export {
   maxBy
 };
-//# sourceMappingURL=chunk-FXOABQRO.mjs.map
+//# sourceMappingURL=chunk-OOKNBU4V.mjs.map

package/dist/chunk-OOKNBU4V.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 * @template T - The type of elements in the array.\n * @param {T[]} items The array of elements to search.\n * @param {(element: T) => number} getValue A function that selects a numeric value from each element.\n * @returns {T} The element with the maximum value as determined by the `getValue` function.\n * @example\n * maxBy([{ a: 1 }, { a: 2 }, { a: 3 }], x => x.a); // Returns: { a: 3 }\n * maxBy([], x => x.a); // Returns: undefined\n */\nexport function maxBy<T>(items: T[], getValue: (element: T) => number): T {\n  let maxElement = items[0];\n  let max = -Infinity;\n\n  for (const element of items) {\n    const value = getValue(element);\n    if (value > max) {\n      max = value;\n      maxElement = element;\n    }\n  }\n\n  return maxElement;\n}\n"],"mappings":";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-WPDDOUQT.mjs → chunk-OXAZEEGP.mjs}

@@ -13,4 +13,4 @@ function uniqBy(arr, mapper) {
 export {
   uniqBy
 };
-//# sourceMappingURL=chunk-WPDDOUQT.mjs.map
+//# sourceMappingURL=chunk-OXAZEEGP.mjs.map

package/dist/chunk-OXAZEEGP.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/array/uniqBy.ts"],"sourcesContent":["/**\n * Returns a new array containing only the unique elements from the original array,\n * based on the values returned by the mapper function.\n *\n * @template T - The type of elements in the array.\n * @template U - The type of mapped elements.\n * @param {T[]} arr - The array to process.\n * @param {(item: T) => U} mapper - The function used to convert the array elements.\n * @returns {T[]} A new array containing only the unique elements from the original array, based on the values returned by the mapper function.\n *\n * @example\n * ```ts\n * uniqBy([1.2, 1.5, 2.1, 3.2, 5.7, 5.3, 7.19], Math.floor);\n * // [1.2, 2.1, 3.3, 5.7, 7.19]\n * ```\n */\nexport function uniqBy<T, U>(arr: readonly T[], mapper: (item: T) => U): T[] {\n  const map = new Map<U, T>();\n\n  for (const item of arr) {\n    const key = mapper(item);\n\n    if (!map.has(key)) {\n      map.set(key, item);\n    }\n  }\n\n  return Array.from(map.values());\n}\n"],"mappings":";AAgBO,SAAS,OAAa,KAAmB,QAA6B;AAC3E,QAAM,MAAM,oBAAI,IAAU;AAE1B,aAAW,QAAQ,KAAK;AACtB,UAAM,MAAM,OAAO,IAAI;AAEvB,QAAI,CAAC,IAAI,IAAI,GAAG,GAAG;AACjB,UAAI,IAAI,KAAK,IAAI;AAAA,IACnB;AAAA,EACF;AAEA,SAAO,MAAM,KAAK,IAAI,OAAO,CAAC;AAChC;","names":[]}

package/dist/chunk-PYEYV7BY.mjs

@@ -0,0 +1,10 @@
+// src/array/without.ts
+function without(array, ...values) {
+  const valuesSet = new Set(values);
+  return array.filter((item) => !valuesSet.has(item));
+}
+
+export {
+  without
+};
+//# sourceMappingURL=chunk-PYEYV7BY.mjs.map

package/dist/chunk-PYEYV7BY.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/array/without.ts"],"sourcesContent":["/**\n * Creates an array that excludes all specified values.\n *\n * It correctly excludes `NaN`, as it compares values using [SameValueZero](https://tc39.es/ecma262/multipage/abstract-operations.html#sec-samevaluezero).\n *\n * @template T The type of elements in the array.\n * @param {T[]} array - The array to filter.\n * @param {...T[]} values - The values to exclude.\n * @returns {T[]} A new array without the specified values.\n *\n * @example\n * // Removes the specified values from the array\n * without([1, 2, 3, 4, 5], 2, 4);\n * // Returns: [1, 3, 5]\n *\n * @example\n * // Removes specified string values from the array\n * without(['a', 'b', 'c', 'a'], 'a');\n * // Returns: ['b', 'c']\n */\nexport function without<T>(array: readonly T[], ...values: T[]): T[] {\n  const valuesSet = new Set(values);\n  return array.filter(item => !valuesSet.has(item));\n}\n"],"mappings":";AAoBO,SAAS,QAAW,UAAwB,QAAkB;AACnE,QAAM,YAAY,IAAI,IAAI,MAAM;AAChC,SAAO,MAAM,OAAO,UAAQ,CAAC,UAAU,IAAI,IAAI,CAAC;AAClD;","names":[]}

package/dist/{chunk-E54CCWDL.mjs → chunk-Q47NGNXT.mjs}

@@ -1,9 +1,9 @@
 import {
   unionBy
-} from "./chunk-NRNKP6JF.mjs";
+} from "./chunk-NFS7RWWE.mjs";
 import {
   intersectionBy
-} from "./chunk-GNSJP2AB.mjs";
+} from "./chunk-O6UXZR3U.mjs";
 import {
   differenceBy
 } from "./chunk-LVWX5B43.mjs";
@@ -18,4 +18,4 @@ function xorBy(arr1, arr2, mapper) {
 export {
   xorBy
 };
-//# sourceMappingURL=chunk-E54CCWDL.mjs.map
+//# sourceMappingURL=chunk-Q47NGNXT.mjs.map

package/dist/{chunk-OEOAJOLQ.mjs → chunk-QOJGMVVR.mjs}

@@ -14,4 +14,4 @@ function throttle(func, throttleMs) {
 export {
   throttle
 };
-//# sourceMappingURL=chunk-OEOAJOLQ.mjs.map
+//# sourceMappingURL=chunk-QOJGMVVR.mjs.map

package/dist/chunk-QOJGMVVR.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/function/throttle.ts"],"sourcesContent":["/**\n * Creates a throttled function that only invokes the provided function at most once\n * per every `throttleMs` milliseconds. Subsequent calls to the throttled function\n * within the wait time will not trigger the execution of the original function.\n *\n * @template F - The type of function.\n * @param {F} func - The function to throttle.\n * @param {number} throttleMs - The number of milliseconds to throttle executions to.\n * @returns {F} A new throttled function that accepts the same parameters as the original function.\n *\n * @example\n * const throttledFunction = throttle(() => {\n *   console.log('Function executed');\n * }, 1000);\n *\n * // Will log 'Function executed' immediately\n * throttledFunction();\n *\n * // Will not log anything as it is within the throttle time\n * throttledFunction();\n *\n * // After 1 second\n * setTimeout(() => {\n *   throttledFunction(); // Will log 'Function executed'\n * }, 1000);\n */\nexport function throttle<F extends (...args: any[]) => void>(func: F, throttleMs: number): F {\n  let lastCallTime: number | null;\n\n  const throttledFunction = function (...args: Parameters<F>) {\n    const now = Date.now();\n\n    if (lastCallTime == null || now - lastCallTime >= throttleMs) {\n      lastCallTime = now;\n      func(...args);\n    }\n  } as F;\n\n  return throttledFunction;\n}\n"],"mappings":";AA0BO,SAAS,SAA6C,MAAS,YAAuB;AAC3F,MAAI;AAEJ,QAAM,oBAAoB,YAAa,MAAqB;AAC1D,UAAM,MAAM,KAAK,IAAI;AAErB,QAAI,gBAAgB,QAAQ,MAAM,gBAAgB,YAAY;AAC5D,qBAAe;AACf,WAAK,GAAG,IAAI;AAAA,IACd;AAAA,EACF;AAEA,SAAO;AACT;","names":[]}

package/dist/{chunk-JSS4FXUD.mjs → chunk-QRSJBBFY.mjs}

@@ -1,9 +1,9 @@
 import {
   unionWith
-} from "./chunk-OUTSP4VR.mjs";
+} from "./chunk-2ZCITDMK.mjs";
 import {
   intersectionWith
-} from "./chunk-2EFS3VA3.mjs";
+} from "./chunk-XI7KRD2C.mjs";
 import {
   differenceWith
 } from "./chunk-6NVQAHXP.mjs";
@@ -18,4 +18,4 @@ function xorWith(arr1, arr2, areElementsEqual) {
 export {
   xorWith
 };
-//# sourceMappingURL=chunk-JSS4FXUD.mjs.map
+//# sourceMappingURL=chunk-QRSJBBFY.mjs.map

package/dist/{chunk-PLTO44KM.mjs → chunk-QZITBKWX.mjs}

@@ -14,4 +14,4 @@ function omit(obj, keys) {
 export {
   omit
 };
-//# sourceMappingURL=chunk-PLTO44KM.mjs.map
+//# sourceMappingURL=chunk-QZITBKWX.mjs.map

package/dist/chunk-QZITBKWX.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/object/omit.ts"],"sourcesContent":["/**\n * Creates a new object with specified keys omitted.\n *\n * This function takes an object and an array of keys, and returns a new object that\n * excludes 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 omit keys from.\n * @param {K[]} keys - An array of keys to be omitted from the object.\n * @returns {Omit<T, K>} A new object with the specified keys omitted.\n *\n * @example\n * const obj = { a: 1, b: 2, c: 3 };\n * const result = omit(obj, ['b', 'c']);\n * // result will be { a: 1 }\n */\nexport function omit<T extends Record<string, any>, K extends keyof T>(obj: T, keys: K[]): Omit<T, K> {\n  const result = { ...obj };\n\n  for (const key of keys) {\n    delete result[key];\n  }\n\n  return result as Omit<T, K>;\n}\n"],"mappings":";;;;;AAiBO,SAAS,KAAuD,KAAQ,MAAuB;AACpG,QAAM,SAAS,mBAAK;AAEpB,aAAW,OAAO,MAAM;AACtB,WAAO,OAAO,GAAG;AAAA,EACnB;AAEA,SAAO;AACT;","names":[]}

package/dist/{chunk-UPJXHWSJ.mjs → chunk-R6QA7PLZ.mjs}

@@ -1,6 +1,6 @@
 import {
   uniq
-} from "./chunk-XFCW7XJ4.mjs";
+} from "./chunk-DVK2N4KC.mjs";
 
 // src/array/union.ts
 function union(arr1, arr2) {
@@ -10,4 +10,4 @@ function union(arr1, arr2) {
 export {
   union
 };
-//# sourceMappingURL=chunk-UPJXHWSJ.mjs.map
+//# sourceMappingURL=chunk-R6QA7PLZ.mjs.map

package/dist/chunk-R6QA7PLZ.mjs.map

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

package/dist/{chunk-ACFP3XMB.mjs → chunk-S3CORED5.mjs}

@@ -6,4 +6,4 @@ function drop(arr, itemsCount) {
 export {
   drop
 };
-//# sourceMappingURL=chunk-ACFP3XMB.mjs.map
+//# sourceMappingURL=chunk-S3CORED5.mjs.map

package/dist/chunk-S3CORED5.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/array/drop.ts"],"sourcesContent":["/**\n * Removes a specified number of elements from the beginning of an array and returns the rest.\n *\n * This function takes an array and a number, and returns a new array with the specified number\n * of elements removed from the start.\n *\n * @template T - The type of elements in the array.\n * @param {T[]} arr - The array from which to drop elements.\n * @param {number} itemsCount - The number of elements to drop from the beginning of the array.\n * @returns {T[]} A new array with the specified number of elements removed from the start.\n *\n * @example\n * const array = [1, 2, 3, 4, 5];\n * const result = drop(array, 2);\n * // result will be [3, 4, 5] since the first two elements are dropped.\n */\nexport function drop<T>(arr: readonly T[], itemsCount: number): T[] {\n  return arr.slice(itemsCount);\n}\n"],"mappings":";AAgBO,SAAS,KAAQ,KAAmB,YAAyB;AAClE,SAAO,IAAI,MAAM,UAAU;AAC7B;","names":[]}

package/dist/chunk-SDIMTYZW.mjs

@@ -0,0 +1,14 @@
+import {
+  mean
+} from "./chunk-LT6E4Y4Z.mjs";
+
+// src/math/meanBy.ts
+function meanBy(items, getValue) {
+  const nums = items.map((x) => getValue(x));
+  return mean(nums);
+}
+
+export {
+  meanBy
+};
+//# sourceMappingURL=chunk-SDIMTYZW.mjs.map

package/dist/chunk-SDIMTYZW.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/math/meanBy.ts"],"sourcesContent":["import { mean } from './mean.ts';\n\n/**\n * Calculates the average of an array of numbers when applying\n * the `getValue` function to each element.\n *\n * If the array is empty, this function returns `NaN`.\n *\n * @template T - The type of elements in the array.\n * @param {T[]} items An array to calculate the average.\n * @param {(element: T) => number} getValue A function that selects a numeric value from each element.\n * @returns {number} The average of all the numbers as determined by the `getValue` function.\n *\n * @example\n * meanBy([{ a: 1 }, { a: 2 }, { a: 3 }], x => x.a); // Returns: 2\n * meanBy([], x => x.a); // Returns: NaN\n */\nexport function meanBy<T>(items: readonly T[], getValue: (element: T) => number): number {\n  const nums = items.map(x => getValue(x));\n\n  return mean(nums);\n}\n"],"mappings":";;;;;AAiBO,SAAS,OAAU,OAAqB,UAA0C;AACvF,QAAM,OAAO,MAAM,IAAI,OAAK,SAAS,CAAC,CAAC;AAEvC,SAAO,KAAK,IAAI;AAClB;","names":[]}

package/dist/chunk-TZE6EDCX.mjs

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

package/dist/chunk-TZE6EDCX.mjs.map

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

package/dist/{chunk-2EFS3VA3.mjs → chunk-XI7KRD2C.mjs}

@@ -10,4 +10,4 @@ function intersectionWith(firstArr, secondArr, areItemsEqual) {
 export {
   intersectionWith
 };
-//# sourceMappingURL=chunk-2EFS3VA3.mjs.map
+//# sourceMappingURL=chunk-XI7KRD2C.mjs.map

package/dist/chunk-XI7KRD2C.mjs.map

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

package/dist/chunk-XJR5WV2Z.mjs

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

package/dist/chunk-XJR5WV2Z.mjs.map

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

package/dist/error/AbortError.d.mts

@@ -1,3 +1,7 @@
+/**
+ * An error class representing an aborted operation.
+ * @augments Error
+ */
 declare class AbortError extends Error {
     constructor(message?: string);
 }

package/dist/error/AbortError.d.ts

@@ -1,3 +1,7 @@
+/**
+ * An error class representing an aborted operation.
+ * @augments Error
+ */
 declare class AbortError extends Error {
     constructor(message?: string);
 }

package/dist/error/AbortError.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/error/AbortError.ts"],"sourcesContent":["export class AbortError extends Error {\n  constructor(message = 'The operation was aborted') {\n    super(message);\n    this.name = 'AbortError';\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAO,IAAM,aAAN,cAAyB,MAAM;AAAA,EACpC,YAAY,UAAU,6BAA6B;AACjD,UAAM,OAAO;AACb,SAAK,OAAO;AAAA,EACd;AACF;","names":[]}
+{"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":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAIO,IAAM,aAAN,cAAyB,MAAM;AAAA,EACpC,YAAY,UAAU,6BAA6B;AACjD,UAAM,OAAO;AACb,SAAK,OAAO;AAAA,EACd;AACF;","names":[]}

package/dist/error/AbortError.mjs

@@ -1,6 +1,6 @@
 import {
   AbortError
-} from "../chunk-VP2LXY75.mjs";
+} from "../chunk-DXB7EZUQ.mjs";
 import "../chunk-2MM5EJJX.mjs";
 export {
   AbortError

package/dist/error/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/error/index.ts","../../src/error/AbortError.ts"],"sourcesContent":["export { AbortError } from './AbortError.ts';\n","export class AbortError extends Error {\n  constructor(message = 'The operation was aborted') {\n    super(message);\n    this.name = 'AbortError';\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAO,IAAM,aAAN,cAAyB,MAAM;AAAA,EACpC,YAAY,UAAU,6BAA6B;AACjD,UAAM,OAAO;AACb,SAAK,OAAO;AAAA,EACd;AACF;","names":[]}
+{"version":3,"sources":["../../src/error/index.ts","../../src/error/AbortError.ts"],"sourcesContent":["export { AbortError } from './AbortError.ts';\n","/**\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":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACIO,IAAM,aAAN,cAAyB,MAAM;AAAA,EACpC,YAAY,UAAU,6BAA6B;AACjD,UAAM,OAAO;AACb,SAAK,OAAO;AAAA,EACd;AACF;","names":[]}

package/dist/error/index.mjs

@@ -1,7 +1,7 @@
 import "../chunk-FZEZH22H.mjs";
 import {
   AbortError
-} from "../chunk-VP2LXY75.mjs";
+} from "../chunk-DXB7EZUQ.mjs";
 import "../chunk-2MM5EJJX.mjs";
 export {
   AbortError

package/dist/function/debounce.d.mts

@@ -6,6 +6,7 @@ interface DebounceOptions {
  * have elapsed since the last time the debounced function was invoked. The debounced function also has a `cancel`
  * method to cancel any pending execution.
  *
+ * @template F - The type of function.
  * @param {F} func - The function to debounce.
  * @param {number} debounceMs - The number of milliseconds to delay.
  * @param {DebounceOptions} options - The options object.

package/dist/function/debounce.d.ts

@@ -6,6 +6,7 @@ interface DebounceOptions {
  * have elapsed since the last time the debounced function was invoked. The debounced function also has a `cancel`
  * method to cancel any pending execution.
  *
+ * @template F - The type of function.
  * @param {F} func - The function to debounce.
  * @param {number} debounceMs - The number of milliseconds to delay.
  * @param {DebounceOptions} options - The options object.

package/dist/function/debounce.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/function/debounce.ts"],"sourcesContent":["interface DebounceOptions {\n  signal?: AbortSignal;\n}\n\n/**\n * Creates a debounced function that delays invoking the provided function until after `debounceMs` milliseconds\n * have elapsed since the last time the debounced function was invoked. The debounced function also has a `cancel`\n * method to cancel any pending execution.\n *\n * @param {F} func - The function to debounce.\n * @param {number} debounceMs - The number of milliseconds to delay.\n * @param {DebounceOptions} options - The options object.\n * @param {AbortSignal} options.signal - An optional AbortSignal to cancel the debounced function.\n * @returns {F & { cancel: () => void }} A new debounced function with a `cancel` method.\n *\n * @example\n * const debouncedFunction = debounce(() => {\n *   console.log('Function executed');\n * }, 1000);\n *\n * // Will log 'Function executed' after 1 second if not called again in that time\n * debouncedFunction();\n *\n * // Will not log anything as the previous call is canceled\n * debouncedFunction.cancel();\n *\n * // With AbortSignal\n * const controller = new AbortController();\n * const signal = controller.signal;\n * const debouncedWithSignal = debounce(() => {\n *  console.log('Function executed');\n * }, 1000, { signal });\n *\n * debouncedWithSignal();\n *\n * // Will cancel the debounced function call\n * controller.abort();\n */\nexport function debounce<F extends (...args: any[]) => void>(\n  func: F,\n  debounceMs: number,\n  { signal }: DebounceOptions = {}\n): F & { cancel: () => void } {\n  let timeoutId: number | null = null;\n\n  const debounced = function (...args: Parameters<F>) {\n    if (timeoutId !== null) {\n      clearTimeout(timeoutId);\n    }\n\n    if (signal?.aborted) {\n      return;\n    }\n\n    timeoutId = setTimeout(() => {\n      func(...args);\n      timeoutId = null;\n    }, debounceMs) as any;\n  } as F & { cancel: () => void };\n\n  const onAbort = function () {\n    debounced.cancel();\n  };\n\n  debounced.cancel = function () {\n    if (timeoutId !== null) {\n      clearTimeout(timeoutId);\n      timeoutId = null;\n    }\n  };\n\n  signal?.addEventListener('abort', onAbort, { once: true });\n\n  return debounced;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAsCO,SAAS,SACd,MACA,YACA,EAAE,OAAO,IAAqB,CAAC,GACH;AAC5B,MAAI,YAA2B;AAE/B,QAAM,YAAY,YAAa,MAAqB;AAClD,QAAI,cAAc,MAAM;AACtB,mBAAa,SAAS;AAAA,IACxB;AAEA,QAAI,iCAAQ,SAAS;AACnB;AAAA,IACF;AAEA,gBAAY,WAAW,MAAM;AAC3B,WAAK,GAAG,IAAI;AACZ,kBAAY;AAAA,IACd,GAAG,UAAU;AAAA,EACf;AAEA,QAAM,UAAU,WAAY;AAC1B,cAAU,OAAO;AAAA,EACnB;AAEA,YAAU,SAAS,WAAY;AAC7B,QAAI,cAAc,MAAM;AACtB,mBAAa,SAAS;AACtB,kBAAY;AAAA,IACd;AAAA,EACF;AAEA,mCAAQ,iBAAiB,SAAS,SAAS,EAAE,MAAM,KAAK;AAExD,SAAO;AACT;","names":[]}
+{"version":3,"sources":["../../src/function/debounce.ts"],"sourcesContent":["interface DebounceOptions {\n  signal?: AbortSignal;\n}\n\n/**\n * Creates a debounced function that delays invoking the provided function until after `debounceMs` milliseconds\n * have elapsed since the last time the debounced function was invoked. The debounced function also has a `cancel`\n * method to cancel any pending execution.\n *\n * @template F - The type of function.\n * @param {F} func - The function to debounce.\n * @param {number} debounceMs - The number of milliseconds to delay.\n * @param {DebounceOptions} options - The options object.\n * @param {AbortSignal} options.signal - An optional AbortSignal to cancel the debounced function.\n * @returns {F & { cancel: () => void }} A new debounced function with a `cancel` method.\n *\n * @example\n * const debouncedFunction = debounce(() => {\n *   console.log('Function executed');\n * }, 1000);\n *\n * // Will log 'Function executed' after 1 second if not called again in that time\n * debouncedFunction();\n *\n * // Will not log anything as the previous call is canceled\n * debouncedFunction.cancel();\n *\n * // With AbortSignal\n * const controller = new AbortController();\n * const signal = controller.signal;\n * const debouncedWithSignal = debounce(() => {\n *  console.log('Function executed');\n * }, 1000, { signal });\n *\n * debouncedWithSignal();\n *\n * // Will cancel the debounced function call\n * controller.abort();\n */\nexport function debounce<F extends (...args: any[]) => void>(\n  func: F,\n  debounceMs: number,\n  { signal }: DebounceOptions = {}\n): F & { cancel: () => void } {\n  let timeoutId: number | null = null;\n\n  const debounced = function (...args: Parameters<F>) {\n    if (timeoutId !== null) {\n      clearTimeout(timeoutId);\n    }\n\n    if (signal?.aborted) {\n      return;\n    }\n\n    timeoutId = setTimeout(() => {\n      func(...args);\n      timeoutId = null;\n    }, debounceMs) as any;\n  } as F & { cancel: () => void };\n\n  const onAbort = function () {\n    debounced.cancel();\n  };\n\n  debounced.cancel = function () {\n    if (timeoutId !== null) {\n      clearTimeout(timeoutId);\n      timeoutId = null;\n    }\n  };\n\n  signal?.addEventListener('abort', onAbort, { once: true });\n\n  return debounced;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAuCO,SAAS,SACd,MACA,YACA,EAAE,OAAO,IAAqB,CAAC,GACH;AAC5B,MAAI,YAA2B;AAE/B,QAAM,YAAY,YAAa,MAAqB;AAClD,QAAI,cAAc,MAAM;AACtB,mBAAa,SAAS;AAAA,IACxB;AAEA,QAAI,iCAAQ,SAAS;AACnB;AAAA,IACF;AAEA,gBAAY,WAAW,MAAM;AAC3B,WAAK,GAAG,IAAI;AACZ,kBAAY;AAAA,IACd,GAAG,UAAU;AAAA,EACf;AAEA,QAAM,UAAU,WAAY;AAC1B,cAAU,OAAO;AAAA,EACnB;AAEA,YAAU,SAAS,WAAY;AAC7B,QAAI,cAAc,MAAM;AACtB,mBAAa,SAAS;AACtB,kBAAY;AAAA,IACd;AAAA,EACF;AAEA,mCAAQ,iBAAiB,SAAS,SAAS,EAAE,MAAM,KAAK;AAExD,SAAO;AACT;","names":[]}

package/dist/function/debounce.mjs

@@ -1,6 +1,6 @@
 import {
   debounce
-} from "../chunk-G42NUGNE.mjs";
+} from "../chunk-3IP4JVLL.mjs";
 import "../chunk-2MM5EJJX.mjs";
 export {
   debounce

package/dist/function/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/function/index.ts","../../src/function/debounce.ts","../../src/function/noop.ts","../../src/function/once.ts","../../src/function/throttle.ts"],"sourcesContent":["export { debounce } from './debounce.ts';\nexport { noop } from './noop.ts';\nexport { once } from './once.ts';\nexport { throttle } from './throttle.ts';\n","interface DebounceOptions {\n  signal?: AbortSignal;\n}\n\n/**\n * Creates a debounced function that delays invoking the provided function until after `debounceMs` milliseconds\n * have elapsed since the last time the debounced function was invoked. The debounced function also has a `cancel`\n * method to cancel any pending execution.\n *\n * @param {F} func - The function to debounce.\n * @param {number} debounceMs - The number of milliseconds to delay.\n * @param {DebounceOptions} options - The options object.\n * @param {AbortSignal} options.signal - An optional AbortSignal to cancel the debounced function.\n * @returns {F & { cancel: () => void }} A new debounced function with a `cancel` method.\n *\n * @example\n * const debouncedFunction = debounce(() => {\n *   console.log('Function executed');\n * }, 1000);\n *\n * // Will log 'Function executed' after 1 second if not called again in that time\n * debouncedFunction();\n *\n * // Will not log anything as the previous call is canceled\n * debouncedFunction.cancel();\n *\n * // With AbortSignal\n * const controller = new AbortController();\n * const signal = controller.signal;\n * const debouncedWithSignal = debounce(() => {\n *  console.log('Function executed');\n * }, 1000, { signal });\n *\n * debouncedWithSignal();\n *\n * // Will cancel the debounced function call\n * controller.abort();\n */\nexport function debounce<F extends (...args: any[]) => void>(\n  func: F,\n  debounceMs: number,\n  { signal }: DebounceOptions = {}\n): F & { cancel: () => void } {\n  let timeoutId: number | null = null;\n\n  const debounced = function (...args: Parameters<F>) {\n    if (timeoutId !== null) {\n      clearTimeout(timeoutId);\n    }\n\n    if (signal?.aborted) {\n      return;\n    }\n\n    timeoutId = setTimeout(() => {\n      func(...args);\n      timeoutId = null;\n    }, debounceMs) as any;\n  } as F & { cancel: () => void };\n\n  const onAbort = function () {\n    debounced.cancel();\n  };\n\n  debounced.cancel = function () {\n    if (timeoutId !== null) {\n      clearTimeout(timeoutId);\n      timeoutId = null;\n    }\n  };\n\n  signal?.addEventListener('abort', onAbort, { once: true });\n\n  return debounced;\n}\n","/**\n * A no-operation function that does nothing.\n * This can be used as a placeholder or default function.\n *\n * @example\n * noop(); // Does nothing\n *\n * @returns {void} This function does not return anything.\n */\nexport function noop(): void {}\n","/**\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 * @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","/**\n * Creates a throttled function that only invokes the provided function at most once\n * per every `throttleMs` milliseconds. Subsequent calls to the throttled function\n * within the wait time will not trigger the execution of the original function.\n *\n * @param {F} func - The function to throttle.\n * @param {number} throttleMs - The number of milliseconds to throttle executions to.\n * @returns {F} A new throttled function that accepts the same parameters as the original function.\n *\n * @example\n * const throttledFunction = throttle(() => {\n *   console.log('Function executed');\n * }, 1000);\n *\n * // Will log 'Function executed' immediately\n * throttledFunction();\n *\n * // Will not log anything as it is within the throttle time\n * throttledFunction();\n *\n * // After 1 second\n * setTimeout(() => {\n *   throttledFunction(); // Will log 'Function executed'\n * }, 1000);\n */\nexport function throttle<F extends (...args: any[]) => void>(func: F, throttleMs: number): F {\n  let lastCallTime: number | null;\n\n  const throttledFunction = function (...args: Parameters<F>) {\n    const now = Date.now();\n\n    if (lastCallTime == null || now - lastCallTime >= throttleMs) {\n      lastCallTime = now;\n      func(...args);\n    }\n  } as F;\n\n  return throttledFunction;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACsCO,SAAS,SACd,MACA,YACA,EAAE,OAAO,IAAqB,CAAC,GACH;AAC5B,MAAI,YAA2B;AAE/B,QAAM,YAAY,YAAa,MAAqB;AAClD,QAAI,cAAc,MAAM;AACtB,mBAAa,SAAS;AAAA,IACxB;AAEA,QAAI,iCAAQ,SAAS;AACnB;AAAA,IACF;AAEA,gBAAY,WAAW,MAAM;AAC3B,WAAK,GAAG,IAAI;AACZ,kBAAY;AAAA,IACd,GAAG,UAAU;AAAA,EACf;AAEA,QAAM,UAAU,WAAY;AAC1B,cAAU,OAAO;AAAA,EACnB;AAEA,YAAU,SAAS,WAAY;AAC7B,QAAI,cAAc,MAAM;AACtB,mBAAa,SAAS;AACtB,kBAAY;AAAA,IACd;AAAA,EACF;AAEA,mCAAQ,iBAAiB,SAAS,SAAS,EAAE,MAAM,KAAK;AAExD,SAAO;AACT;;;ACjEO,SAAS,OAAa;AAAC;;;ACOvB,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;;;ACPO,SAAS,SAA6C,MAAS,YAAuB;AAC3F,MAAI;AAEJ,QAAM,oBAAoB,YAAa,MAAqB;AAC1D,UAAM,MAAM,KAAK,IAAI;AAErB,QAAI,gBAAgB,QAAQ,MAAM,gBAAgB,YAAY;AAC5D,qBAAe;AACf,WAAK,GAAG,IAAI;AAAA,IACd;AAAA,EACF;AAEA,SAAO;AACT;","names":[]}
+{"version":3,"sources":["../../src/function/index.ts","../../src/function/debounce.ts","../../src/function/noop.ts","../../src/function/once.ts","../../src/function/throttle.ts"],"sourcesContent":["export { debounce } from './debounce.ts';\nexport { noop } from './noop.ts';\nexport { once } from './once.ts';\nexport { throttle } from './throttle.ts';\n","interface DebounceOptions {\n  signal?: AbortSignal;\n}\n\n/**\n * Creates a debounced function that delays invoking the provided function until after `debounceMs` milliseconds\n * have elapsed since the last time the debounced function was invoked. The debounced function also has a `cancel`\n * method to cancel any pending execution.\n *\n * @template F - The type of function.\n * @param {F} func - The function to debounce.\n * @param {number} debounceMs - The number of milliseconds to delay.\n * @param {DebounceOptions} options - The options object.\n * @param {AbortSignal} options.signal - An optional AbortSignal to cancel the debounced function.\n * @returns {F & { cancel: () => void }} A new debounced function with a `cancel` method.\n *\n * @example\n * const debouncedFunction = debounce(() => {\n *   console.log('Function executed');\n * }, 1000);\n *\n * // Will log 'Function executed' after 1 second if not called again in that time\n * debouncedFunction();\n *\n * // Will not log anything as the previous call is canceled\n * debouncedFunction.cancel();\n *\n * // With AbortSignal\n * const controller = new AbortController();\n * const signal = controller.signal;\n * const debouncedWithSignal = debounce(() => {\n *  console.log('Function executed');\n * }, 1000, { signal });\n *\n * debouncedWithSignal();\n *\n * // Will cancel the debounced function call\n * controller.abort();\n */\nexport function debounce<F extends (...args: any[]) => void>(\n  func: F,\n  debounceMs: number,\n  { signal }: DebounceOptions = {}\n): F & { cancel: () => void } {\n  let timeoutId: number | null = null;\n\n  const debounced = function (...args: Parameters<F>) {\n    if (timeoutId !== null) {\n      clearTimeout(timeoutId);\n    }\n\n    if (signal?.aborted) {\n      return;\n    }\n\n    timeoutId = setTimeout(() => {\n      func(...args);\n      timeoutId = null;\n    }, debounceMs) as any;\n  } as F & { cancel: () => void };\n\n  const onAbort = function () {\n    debounced.cancel();\n  };\n\n  debounced.cancel = function () {\n    if (timeoutId !== null) {\n      clearTimeout(timeoutId);\n      timeoutId = null;\n    }\n  };\n\n  signal?.addEventListener('abort', onAbort, { once: true });\n\n  return debounced;\n}\n","/**\n * A no-operation function that does nothing.\n * This can be used as a placeholder or default function.\n *\n * @example\n * noop(); // Does nothing\n *\n * @returns {void} This function does not return anything.\n */\nexport function noop(): void {}\n","/**\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","/**\n * Creates a throttled function that only invokes the provided function at most once\n * per every `throttleMs` milliseconds. Subsequent calls to the throttled function\n * within the wait time will not trigger the execution of the original function.\n *\n * @template F - The type of function.\n * @param {F} func - The function to throttle.\n * @param {number} throttleMs - The number of milliseconds to throttle executions to.\n * @returns {F} A new throttled function that accepts the same parameters as the original function.\n *\n * @example\n * const throttledFunction = throttle(() => {\n *   console.log('Function executed');\n * }, 1000);\n *\n * // Will log 'Function executed' immediately\n * throttledFunction();\n *\n * // Will not log anything as it is within the throttle time\n * throttledFunction();\n *\n * // After 1 second\n * setTimeout(() => {\n *   throttledFunction(); // Will log 'Function executed'\n * }, 1000);\n */\nexport function throttle<F extends (...args: any[]) => void>(func: F, throttleMs: number): F {\n  let lastCallTime: number | null;\n\n  const throttledFunction = function (...args: Parameters<F>) {\n    const now = Date.now();\n\n    if (lastCallTime == null || now - lastCallTime >= throttleMs) {\n      lastCallTime = now;\n      func(...args);\n    }\n  } as F;\n\n  return throttledFunction;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACuCO,SAAS,SACd,MACA,YACA,EAAE,OAAO,IAAqB,CAAC,GACH;AAC5B,MAAI,YAA2B;AAE/B,QAAM,YAAY,YAAa,MAAqB;AAClD,QAAI,cAAc,MAAM;AACtB,mBAAa,SAAS;AAAA,IACxB;AAEA,QAAI,iCAAQ,SAAS;AACnB;AAAA,IACF;AAEA,gBAAY,WAAW,MAAM;AAC3B,WAAK,GAAG,IAAI;AACZ,kBAAY;AAAA,IACd,GAAG,UAAU;AAAA,EACf;AAEA,QAAM,UAAU,WAAY;AAC1B,cAAU,OAAO;AAAA,EACnB;AAEA,YAAU,SAAS,WAAY;AAC7B,QAAI,cAAc,MAAM;AACtB,mBAAa,SAAS;AACtB,kBAAY;AAAA,IACd;AAAA,EACF;AAEA,mCAAQ,iBAAiB,SAAS,SAAS,EAAE,MAAM,KAAK;AAExD,SAAO;AACT;;;AClEO,SAAS,OAAa;AAAC;;;ACQvB,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;;;ACPO,SAAS,SAA6C,MAAS,YAAuB;AAC3F,MAAI;AAEJ,QAAM,oBAAoB,YAAa,MAAqB;AAC1D,UAAM,MAAM,KAAK,IAAI;AAErB,QAAI,gBAAgB,QAAQ,MAAM,gBAAgB,YAAY;AAC5D,qBAAe;AACf,WAAK,GAAG,IAAI;AAAA,IACd;AAAA,EACF;AAEA,SAAO;AACT;","names":[]}

package/dist/function/index.mjs

@@ -1,16 +1,16 @@
 import "../chunk-N6EM6ETS.mjs";
-import {
-  once
-} from "../chunk-UFAA5WKR.mjs";
-import {
-  throttle
-} from "../chunk-OEOAJOLQ.mjs";
 import {
   debounce
-} from "../chunk-G42NUGNE.mjs";
+} from "../chunk-3IP4JVLL.mjs";
 import {
   noop
 } from "../chunk-LKXCOLNY.mjs";
+import {
+  once
+} from "../chunk-CMBC4MXG.mjs";
+import {
+  throttle
+} from "../chunk-QOJGMVVR.mjs";
 import "../chunk-2MM5EJJX.mjs";
 export {
   debounce,

package/dist/function/once.d.mts

@@ -2,6 +2,7 @@
  * Creates a function that is restricted to invoking the provided function `func` once.
  * Repeated calls to the function will return the value from the first invocation.
  *
+ * @template F - The type of function.
  * @param {F} func - The function to restrict.
  * @returns {F} A new function that invokes `func` once and caches the result.
  *

package/dist/function/once.d.ts

@@ -2,6 +2,7 @@
  * Creates a function that is restricted to invoking the provided function `func` once.
  * Repeated calls to the function will return the value from the first invocation.
  *
+ * @template F - The type of function.
  * @param {F} func - The function to restrict.
  * @returns {F} A new function that invokes `func` once and caches the result.
  *

package/dist/function/once.js.map

@@ -1 +1 @@
-{"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 * @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":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAgBO,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":[]}
+{"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":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;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/function/once.mjs

@@ -1,6 +1,6 @@
 import {
   once
-} from "../chunk-UFAA5WKR.mjs";
+} from "../chunk-CMBC4MXG.mjs";
 import "../chunk-2MM5EJJX.mjs";
 export {
   once

package/dist/function/throttle.d.mts

@@ -3,6 +3,7 @@
  * per every `throttleMs` milliseconds. Subsequent calls to the throttled function
  * within the wait time will not trigger the execution of the original function.
  *
+ * @template F - The type of function.
  * @param {F} func - The function to throttle.
  * @param {number} throttleMs - The number of milliseconds to throttle executions to.
  * @returns {F} A new throttled function that accepts the same parameters as the original function.

package/dist/function/throttle.d.ts

@@ -3,6 +3,7 @@
  * per every `throttleMs` milliseconds. Subsequent calls to the throttled function
  * within the wait time will not trigger the execution of the original function.
  *
+ * @template F - The type of function.
  * @param {F} func - The function to throttle.
  * @param {number} throttleMs - The number of milliseconds to throttle executions to.
  * @returns {F} A new throttled function that accepts the same parameters as the original function.

package/dist/function/throttle.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/function/throttle.ts"],"sourcesContent":["/**\n * Creates a throttled function that only invokes the provided function at most once\n * per every `throttleMs` milliseconds. Subsequent calls to the throttled function\n * within the wait time will not trigger the execution of the original function.\n *\n * @param {F} func - The function to throttle.\n * @param {number} throttleMs - The number of milliseconds to throttle executions to.\n * @returns {F} A new throttled function that accepts the same parameters as the original function.\n *\n * @example\n * const throttledFunction = throttle(() => {\n *   console.log('Function executed');\n * }, 1000);\n *\n * // Will log 'Function executed' immediately\n * throttledFunction();\n *\n * // Will not log anything as it is within the throttle time\n * throttledFunction();\n *\n * // After 1 second\n * setTimeout(() => {\n *   throttledFunction(); // Will log 'Function executed'\n * }, 1000);\n */\nexport function throttle<F extends (...args: any[]) => void>(func: F, throttleMs: number): F {\n  let lastCallTime: number | null;\n\n  const throttledFunction = function (...args: Parameters<F>) {\n    const now = Date.now();\n\n    if (lastCallTime == null || now - lastCallTime >= throttleMs) {\n      lastCallTime = now;\n      func(...args);\n    }\n  } as F;\n\n  return throttledFunction;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAyBO,SAAS,SAA6C,MAAS,YAAuB;AAC3F,MAAI;AAEJ,QAAM,oBAAoB,YAAa,MAAqB;AAC1D,UAAM,MAAM,KAAK,IAAI;AAErB,QAAI,gBAAgB,QAAQ,MAAM,gBAAgB,YAAY;AAC5D,qBAAe;AACf,WAAK,GAAG,IAAI;AAAA,IACd;AAAA,EACF;AAEA,SAAO;AACT;","names":[]}
+{"version":3,"sources":["../../src/function/throttle.ts"],"sourcesContent":["/**\n * Creates a throttled function that only invokes the provided function at most once\n * per every `throttleMs` milliseconds. Subsequent calls to the throttled function\n * within the wait time will not trigger the execution of the original function.\n *\n * @template F - The type of function.\n * @param {F} func - The function to throttle.\n * @param {number} throttleMs - The number of milliseconds to throttle executions to.\n * @returns {F} A new throttled function that accepts the same parameters as the original function.\n *\n * @example\n * const throttledFunction = throttle(() => {\n *   console.log('Function executed');\n * }, 1000);\n *\n * // Will log 'Function executed' immediately\n * throttledFunction();\n *\n * // Will not log anything as it is within the throttle time\n * throttledFunction();\n *\n * // After 1 second\n * setTimeout(() => {\n *   throttledFunction(); // Will log 'Function executed'\n * }, 1000);\n */\nexport function throttle<F extends (...args: any[]) => void>(func: F, throttleMs: number): F {\n  let lastCallTime: number | null;\n\n  const throttledFunction = function (...args: Parameters<F>) {\n    const now = Date.now();\n\n    if (lastCallTime == null || now - lastCallTime >= throttleMs) {\n      lastCallTime = now;\n      func(...args);\n    }\n  } as F;\n\n  return throttledFunction;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AA0BO,SAAS,SAA6C,MAAS,YAAuB;AAC3F,MAAI;AAEJ,QAAM,oBAAoB,YAAa,MAAqB;AAC1D,UAAM,MAAM,KAAK,IAAI;AAErB,QAAI,gBAAgB,QAAQ,MAAM,gBAAgB,YAAY;AAC5D,qBAAe;AACf,WAAK,GAAG,IAAI;AAAA,IACd;AAAA,EACF;AAEA,SAAO;AACT;","names":[]}

package/dist/function/throttle.mjs

@@ -1,6 +1,6 @@
 import {
   throttle
-} from "../chunk-OEOAJOLQ.mjs";
+} from "../chunk-QOJGMVVR.mjs";
 import "../chunk-2MM5EJJX.mjs";
 export {
   throttle

package/dist/index.d.mts

@@ -1,5 +1,6 @@
 export { chunk } from './array/chunk.mjs';
 export { compact } from './array/compact.mjs';
+export { countBy } from './array/countBy.mjs';
 export { difference } from './array/difference.mjs';
 export { differenceBy } from './array/differenceBy.mjs';
 export { differenceWith } from './array/differenceWith.mjs';
@@ -7,6 +8,8 @@ export { drop } from './array/drop.mjs';
 export { dropRight } from './array/dropRight.mjs';
 export { dropRightWhile } from './array/dropRightWhile.mjs';
 export { dropWhile } from './array/dropWhile.mjs';
+export { fill } from './array/fill.mjs';
+export { forEachRight } from './array/forEachRight.mjs';
 export { groupBy } from './array/groupBy.mjs';
 export { intersection } from './array/intersection.mjs';
 export { intersectionBy } from './array/intersectionBy.mjs';
@@ -16,6 +19,7 @@ export { maxBy } from './array/maxBy.mjs';
 export { minBy } from './array/minBy.mjs';
 export { partition } from './array/partition.mjs';
 export { sample } from './array/sample.mjs';
+export { sampleSize } from './array/sampleSize.mjs';
 export { shuffle } from './array/shuffle.mjs';
 export { take } from './array/take.mjs';
 export { takeRight } from './array/takeRight.mjs';
@@ -27,12 +31,14 @@ export { unionWith } from './array/unionWith.mjs';
 export { uniq } from './array/uniq.mjs';
 export { uniqBy } from './array/uniqBy.mjs';
 export { uniqWith } from './array/uniqWith.mjs';
+export { unzipWith } from './array/unzipWith.mjs';
 export { xor } from './array/xor.mjs';
 export { xorBy } from './array/xorBy.mjs';
 export { xorWith } from './array/xorWith.mjs';
 export { zip } from './array/zip.mjs';
-export { zipWith } from './array/zipWith.mjs';
 export { zipObject } from './array/zipObject.mjs';
+export { zipWith } from './array/zipWith.mjs';
+export { without } from './array/without.mjs';
 export { AbortError } from './error/AbortError.mjs';
 export { debounce } from './function/debounce.mjs';
 export { noop } from './function/noop.mjs';
@@ -40,6 +46,7 @@ export { once } from './function/once.mjs';
 export { throttle } from './function/throttle.mjs';
 export { clamp } from './math/clamp.mjs';
 export { mean } from './math/mean.mjs';
+export { meanBy } from './math/meanBy.mjs';
 export { random } from './math/random.mjs';
 export { randomInt } from './math/randomInt.mjs';
 export { round } from './math/round.mjs';

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 export { chunk } from './array/chunk.js';
 export { compact } from './array/compact.js';
+export { countBy } from './array/countBy.js';
 export { difference } from './array/difference.js';
 export { differenceBy } from './array/differenceBy.js';
 export { differenceWith } from './array/differenceWith.js';
@@ -7,6 +8,8 @@ export { drop } from './array/drop.js';
 export { dropRight } from './array/dropRight.js';
 export { dropRightWhile } from './array/dropRightWhile.js';
 export { dropWhile } from './array/dropWhile.js';
+export { fill } from './array/fill.js';
+export { forEachRight } from './array/forEachRight.js';
 export { groupBy } from './array/groupBy.js';
 export { intersection } from './array/intersection.js';
 export { intersectionBy } from './array/intersectionBy.js';
@@ -16,6 +19,7 @@ export { maxBy } from './array/maxBy.js';
 export { minBy } from './array/minBy.js';
 export { partition } from './array/partition.js';
 export { sample } from './array/sample.js';
+export { sampleSize } from './array/sampleSize.js';
 export { shuffle } from './array/shuffle.js';
 export { take } from './array/take.js';
 export { takeRight } from './array/takeRight.js';
@@ -27,12 +31,14 @@ export { unionWith } from './array/unionWith.js';
 export { uniq } from './array/uniq.js';
 export { uniqBy } from './array/uniqBy.js';
 export { uniqWith } from './array/uniqWith.js';
+export { unzipWith } from './array/unzipWith.js';
 export { xor } from './array/xor.js';
 export { xorBy } from './array/xorBy.js';
 export { xorWith } from './array/xorWith.js';
 export { zip } from './array/zip.js';
-export { zipWith } from './array/zipWith.js';
 export { zipObject } from './array/zipObject.js';
+export { zipWith } from './array/zipWith.js';
+export { without } from './array/without.js';
 export { AbortError } from './error/AbortError.js';
 export { debounce } from './function/debounce.js';
 export { noop } from './function/noop.js';
@@ -40,6 +46,7 @@ export { once } from './function/once.js';
 export { throttle } from './function/throttle.js';
 export { clamp } from './math/clamp.js';
 export { mean } from './math/mean.js';
+export { meanBy } from './math/meanBy.js';
 export { random } from './math/random.js';
 export { randomInt } from './math/randomInt.js';
 export { round } from './math/round.js';