es-toolkit 1.0.3-dev.37 → 1.0.3

package/dist/chunk-O3DWW7O5.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: T[]): [T][];\nexport function zip<T, U>(arr1: T[], arr2: U[]): [T, U][];\nexport function zip<T, U, V>(arr1: T[], arr2: U[], arr3: V[]): [T, U, V][];\nexport function zip<T, U, V, W>(arr1: T[], arr2: U[], arr3: V[], arr4: W[]): [T, U, V, W][];\nexport function zip<T>(...arrs: 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":";AAyBO,SAAS,OAAU,MAAoB;AAC5C,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-O5YJUO7P.mjs

@@ -1,13 +0,0 @@
-import {
-  uniqWith
-} from "./chunk-XAJYDHCM.mjs";
-
-// src/array/unionWith.ts
-function unionWith(arr1, arr2, areItemsEqual) {
-  return uniqWith(arr1.concat(arr2), areItemsEqual);
-}
-
-export {
-  unionWith
-};
-//# sourceMappingURL=chunk-O5YJUO7P.mjs.map

package/dist/chunk-O5YJUO7P.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/array/unionWith.ts"],"sourcesContent":["import { uniqWith } from \"./uniqWith\";\n\n/**\n * Creates an array of unique values from two given arrays based on a custom equality function.\n * \n * This function takes two arrays and a custom equality function, merges the arrays, and returns \n * a new array containing only the unique values as determined by the custom equality function.\n *\n * @param {T[]} arr1 - The first array to merge and filter for unique values.\n * @param {T[]} arr2 - The second array to merge and filter for unique values.\n * @param {(item1: T, item2: T) => boolean} areItemsEqual - A custom function to determine if two elements are equal. \n * It takes two arguments and returns `true` if the elements are considered equal, and `false` otherwise.\n * @returns {T[]} A new array of unique values based on the custom equality function.\n *\n * @example\n * const array1 = [{ id: 1 }, { id: 2 }];\n * const array2 = [{ id: 2 }, { id: 3 }];\n * const areItemsEqual = (a, b) => a.id === b.id;\n * const result = unionWith(array1, array2, areItemsEqual);\n * // result will be [{ id: 1 }, { id: 2 }, { id: 3 }] since { id: 2 } is considered equal in both arrays\n */\nexport function unionWith<T>(arr1: T[], arr2: T[], areItemsEqual: (item1: T, item2: T) => boolean): T[] {\n  return uniqWith(arr1.concat(arr2), areItemsEqual);\n}\n"],"mappings":";;;;;AAqBO,SAAS,UAAa,MAAW,MAAW,eAAqD;AACtG,SAAO,SAAS,KAAK,OAAO,IAAI,GAAG,aAAa;AAClD;","names":[]}

package/dist/chunk-OBMK7JO2.mjs

@@ -1,13 +0,0 @@
-// src/math/sum.ts
-function sum(nums) {
-  let result = 0;
-  for (const num of nums) {
-    result += num;
-  }
-  return result;
-}
-
-export {
-  sum
-};
-//# sourceMappingURL=chunk-OBMK7JO2.mjs.map

package/dist/chunk-OBMK7JO2.mjs.map

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

package/dist/chunk-OF7HQYH4.mjs

@@ -1,9 +0,0 @@
-// src/predicate/isNotNil.ts
-function isNotNil(x) {
-  return x != null && x != void 0;
-}
-
-export {
-  isNotNil
-};
-//# sourceMappingURL=chunk-OF7HQYH4.mjs.map

package/dist/chunk-OF7HQYH4.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/predicate/isNotNil.ts"],"sourcesContent":["/**\n * Checks if the given value is not null nor undefined.\n * \n * The main use of this function is to be used with TypeScript as a type predicate.\n *\n * @param {T | null | undefined} x - The value to test if it is not null nor undefined.\n * @returns {x is T} True if the value is not null nor undefined, false otherwise.\n *\n * @example\n * // Here the type of `arr` is (number | undefined)[]\n * const arr = [1, undefined, 3];\n * // Here the type of `result` is number[]\n * const result = arr.filter(isNotNil);\n * // result will be [1, 3]\n */\nexport function isNotNil<T>(x: T | null | undefined): x is T {\n  return x != null && x != undefined;\n}\n"],"mappings":";AAeO,SAAS,SAAY,GAAiC;AAC3D,SAAO,KAAK,QAAQ,KAAK;AAC3B;","names":[]}

package/dist/chunk-PTQLD7TG.mjs

@@ -1,11 +0,0 @@
-// src/array/difference.ts
-function difference(firstArr, secondArr) {
-  return firstArr.filter((item) => {
-    return !secondArr.includes(item);
-  });
-}
-
-export {
-  difference
-};
-//# sourceMappingURL=chunk-PTQLD7TG.mjs.map

package/dist/chunk-PTQLD7TG.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: T[], secondArr: T[]): T[] {\n  return firstArr.filter(item => {\n    return !secondArr.includes(item)\n  });\n}"],"mappings":";AAsBO,SAAS,WAAc,UAAe,WAAqB;AAChE,SAAO,SAAS,OAAO,UAAQ;AAC7B,WAAO,CAAC,UAAU,SAAS,IAAI;AAAA,EACjC,CAAC;AACH;","names":[]}

package/dist/chunk-PWMHSN27.mjs

@@ -1,14 +0,0 @@
-// src/array/takeRightWhile.ts
-function takeRightWhile(arr, shouldContinueTaking) {
-  for (let i = arr.length - 1; i >= 0; i--) {
-    if (!shouldContinueTaking(arr[i])) {
-      return arr.slice(i + 1);
-    }
-  }
-  return arr.slice();
-}
-
-export {
-  takeRightWhile
-};
-//# sourceMappingURL=chunk-PWMHSN27.mjs.map

package/dist/chunk-PWMHSN27.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/array/takeRightWhile.ts"],"sourcesContent":["/**\n * Takes elements from the end of the array while the predicate function returns `true`.\n * \n * @template T - Type of elements in the input array.\n * \n * @param {T[]} arr - The array to take elements from.\n * @param {function(T): boolean} shouldContinueTaking - The function invoked per element.\n * @returns {T[]} A new array containing the elements taken from the end while the predicate returns `true`.\n * \n * @example\n * // Returns [3, 2, 1]\n * takeRightWhile([5, 4, 3, 2, 1], n => n < 4);\n * \n * @example\n * // Returns []\n * takeRightWhile([1, 2, 3], n => n > 3);\n */\nexport function takeRightWhile<T>(arr: T[], shouldContinueTaking: (item: T) => boolean): T[] {\n  for (let i = arr.length - 1; i >= 0; i--) {\n    if (!shouldContinueTaking(arr[i])) {\n      return arr.slice(i + 1);\n    }\n  }\n\n  return arr.slice();\n}\n"],"mappings":";AAiBO,SAAS,eAAkB,KAAU,sBAAiD;AAC3F,WAAS,IAAI,IAAI,SAAS,GAAG,KAAK,GAAG,KAAK;AACxC,QAAI,CAAC,qBAAqB,IAAI,CAAC,CAAC,GAAG;AACjC,aAAO,IAAI,MAAM,IAAI,CAAC;AAAA,IACxB;AAAA,EACF;AAEA,SAAO,IAAI,MAAM;AACnB;","names":[]}

package/dist/chunk-QRQPLMV4.mjs

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

package/dist/chunk-QRQPLMV4.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 * @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: T[]): T[] {\n  const result: T[] = [];\n\n  for (const item of arr) {\n    if (result.includes(item)) {\n      continue;\n    }\n\n    result.push(item);\n  }\n\n  return result;\n}\n"],"mappings":";AAcO,SAAS,KAAQ,KAAe;AACrC,QAAM,SAAc,CAAC;AAErB,aAAW,QAAQ,KAAK;AACtB,QAAI,OAAO,SAAS,IAAI,GAAG;AACzB;AAAA,IACF;AAEA,WAAO,KAAK,IAAI;AAAA,EAClB;AAEA,SAAO;AACT;","names":[]}

package/dist/chunk-R5DNKXDI.mjs

@@ -1,21 +0,0 @@
-import {
-  unionBy
-} from "./chunk-7PPND7QY.mjs";
-import {
-  intersectionBy
-} from "./chunk-2VB6XU3I.mjs";
-import {
-  differenceBy
-} from "./chunk-EAI6NLXI.mjs";
-
-// src/array/xorBy.ts
-function xorBy(arr1, arr2, mapper) {
-  const union = unionBy(arr1, arr2, mapper);
-  const intersection = intersectionBy(arr1, arr2, mapper);
-  return differenceBy(union, intersection, mapper);
-}
-
-export {
-  xorBy
-};
-//# sourceMappingURL=chunk-R5DNKXDI.mjs.map

package/dist/chunk-R5DNKXDI.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/array/xorBy.ts"],"sourcesContent":["import { differenceBy } from \"./differenceBy\";\nimport { intersectionBy } from \"./intersectionBy\";\nimport { unionBy } from \"./unionBy\";\n\n/**\n * Computes the symmetric difference between two arrays using a custom mapping function. \n * The symmetric difference is the set of elements which are in either of the arrays, \n * but not in their intersection, determined by the result of the mapping function.\n *\n * @template T - Type of elements in the input arrays.\n * @template U - Type of the values returned by the mapping function.\n * \n * @param {T[]} arr1 - The first array.\n * @param {T[]} arr2 - The second array.\n * @param {function(item: T): U} mapper - The function to map array elements to comparison values.\n * @returns {T[]} An array containing the elements that are present in either `arr1` or `arr2` but not in both, based on the values returned by the mapping function.\n * \n * @example\n * // Custom mapping function for objects with an 'id' property\n * const idMapper = obj => obj.id;\n * xorBy([{ id: 1 }, { id: 2 }], [{ id: 2 }, { id: 3 }], idMapper);\n * // Returns [{ id: 1 }, { id: 3 }]\n */\nexport function xorBy<T, U>(arr1: T[], arr2: T[], mapper: (item: T) => U): T[] {\n  const union = unionBy(arr1, arr2, mapper);\n  const intersection = intersectionBy(arr1, arr2, mapper);\n  \n  return differenceBy(union, intersection, mapper);\n}\n"],"mappings":";;;;;;;;;;;AAuBO,SAAS,MAAY,MAAW,MAAW,QAA6B;AAC7E,QAAM,QAAQ,QAAQ,MAAM,MAAM,MAAM;AACxC,QAAM,eAAe,eAAe,MAAM,MAAM,MAAM;AAEtD,SAAO,aAAa,OAAO,cAAc,MAAM;AACjD;","names":[]}

package/dist/chunk-RK6PRCEJ.mjs

@@ -1,12 +0,0 @@
-// src/math/clamp.ts
-function clamp(value, bound1, bound2) {
-  if (bound2 == null) {
-    return Math.min(value, bound1);
-  }
-  return Math.min(Math.max(value, bound1), bound2);
-}
-
-export {
-  clamp
-};
-//# sourceMappingURL=chunk-RK6PRCEJ.mjs.map

package/dist/chunk-RK6PRCEJ.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/math/clamp.ts"],"sourcesContent":["/**\n * Clamps a number within the inclusive lower and upper bounds.\n *\n * This function takes a number and two bounds, and returns the number clamped within the specified bounds.\n * If only one bound is provided, it returns the minimum of the value and the bound.\n *\n * @param {number} value - The number to clamp.\n * @param {number} minimum - The minimum bound to clamp the number.\n * @param {number} maximum - The maximum bound to clamp the number.\n * @returns {number} The clamped number within the specified bounds.\n *\n * @example\n *  * const result1 = clamp(10, 5); // result1 will be 5, as 10 is clamped to the bound 5\n * const result2 = clamp(10, 5, 15); // result2 will be 10, as it is within the bounds 5 and 15\n * const result3 = clamp(2, 5, 15); // result3 will be 5, as 2 is clamped to the lower bound 5\n * const result4 = clamp(20, 5, 15); // result4 will be 15, as 20 is clamped to the upper bound 15\n */\nexport function clamp(value: number, maximum: number): number;\nexport function clamp(value: number, minimum: number, maximum: number): number;\nexport function clamp(value: number, bound1: number, bound2?: number): number {\n  if (bound2 == null) {\n    return Math.min(value, bound1);\n  }\n\n  return Math.min(Math.max(value, bound1), bound2);\n}\n"],"mappings":";AAmBO,SAAS,MAAM,OAAe,QAAgB,QAAyB;AAC5E,MAAI,UAAU,MAAM;AAClB,WAAO,KAAK,IAAI,OAAO,MAAM;AAAA,EAC/B;AAEA,SAAO,KAAK,IAAI,KAAK,IAAI,OAAO,MAAM,GAAG,MAAM;AACjD;","names":[]}

package/dist/chunk-RLDY4N3Q.mjs

@@ -1,13 +0,0 @@
-import {
-  uniq
-} from "./chunk-QRQPLMV4.mjs";
-
-// src/array/union.ts
-function union(arr1, arr2) {
-  return uniq(arr1.concat(arr2));
-}
-
-export {
-  union
-};
-//# sourceMappingURL=chunk-RLDY4N3Q.mjs.map

package/dist/chunk-RLDY4N3Q.mjs.map

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

package/dist/chunk-RU3RXBUC.mjs

@@ -1,17 +0,0 @@
-// src/array/zipWith.ts
-function zipWith(arr1, ...rest) {
-  const arrs = [arr1, ...rest.slice(0, -1)];
-  const combine = rest[rest.length - 1];
-  const result = [];
-  const maxIndex = Math.max(...arrs.map((arr) => arr.length));
-  for (let i = 0; i < maxIndex; i++) {
-    const elements = arrs.map((arr) => arr[i]);
-    result.push(combine(...elements));
-  }
-  return result;
-}
-
-export {
-  zipWith
-};
-//# sourceMappingURL=chunk-RU3RXBUC.mjs.map

package/dist/chunk-RU3RXBUC.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/array/zipWith.ts"],"sourcesContent":["/**\n * Combines multiple arrays into a single array using a custom combiner function.\n * \n * This function takes multiple arrays and a combiner function, and returns a new array where each element \n * is the result of applying the combiner function to the corresponding elements of the input arrays.\n *\n * @param {T[]} arr1 - The first array to zip.\n * @param {U[]} [arr2] - The second array to zip (optional).\n * @param {V[]} [arr3] - The third array to zip (optional).\n * @param {W[]} [arr4] - The fourth array to zip (optional).\n * @param {function} combine - The combiner function that takes corresponding elements from each array and returns a single value.\n * @returns {R[]} A new array where each element is the result of applying the combiner function to the corresponding elements of the input arrays.\n *\n * @example\n * // Example usage with two arrays:\n * const arr1 = [1, 2, 3];\n * const arr2 = [4, 5, 6];\n * const result = zipWith(arr1, arr2, (a, b) => a + b);\n * // result will be [5, 7, 9]\n *\n * @example\n * // Example usage with three arrays:\n * const arr1 = [1, 2];\n * const arr2 = [3, 4];\n * const arr3 = [5, 6];\n * const result = zipWith(arr1, arr2, arr3, (a, b, c) => `${a}${b}${c}`);\n * // result will be [`135`, `246`]\n */\nexport function zipWith<T, R>(arr1: T[], combine: (item: T) => R): R[];\nexport function zipWith<T, U, R>(arr1: T[], arr2: U[], combine: (item1: T, item2: U) => R): R[];\nexport function zipWith<T, U, V, R>(arr1: T[], arr2: U[], arr3: V[], combine: (item1: T, item2: U, item3: V) => R): R[];\nexport function zipWith<T, U, V, W, R>(arr1: T[], arr2: U[], arr3: V[], arr4: W[], combine: (item1: T, item2: U, item3: V, item4: W) => R): R[];\nexport function zipWith<T, R>(arr1: T[], ...rest: any[]): R[] {\n  const arrs = [arr1, ...rest.slice(0, -1)];\n  const combine = rest[rest.length - 1] as (...items: T[]) => R;\n\n  const result: R[] = [];\n  const maxIndex = Math.max(...arrs.map(arr => arr.length));\n\n  for (let i = 0; i < maxIndex; i++) {\n    const elements: T[] = arrs.map(arr => arr[i]);\n    result.push(combine(...elements));\n  }\n\n  return result;\n}"],"mappings":";AAgCO,SAAS,QAAc,SAAc,MAAkB;AAC5D,QAAM,OAAO,CAAC,MAAM,GAAG,KAAK,MAAM,GAAG,EAAE,CAAC;AACxC,QAAM,UAAU,KAAK,KAAK,SAAS,CAAC;AAEpC,QAAM,SAAc,CAAC;AACrB,QAAM,WAAW,KAAK,IAAI,GAAG,KAAK,IAAI,SAAO,IAAI,MAAM,CAAC;AAExD,WAAS,IAAI,GAAG,IAAI,UAAU,KAAK;AACjC,UAAM,WAAgB,KAAK,IAAI,SAAO,IAAI,CAAC,CAAC;AAC5C,WAAO,KAAK,QAAQ,GAAG,QAAQ,CAAC;AAAA,EAClC;AAEA,SAAO;AACT;","names":[]}

package/dist/chunk-S767XFOS.mjs

@@ -1,10 +0,0 @@
-// src/array/dropWhile.ts
-function dropWhile(arr, canContinueDropping) {
-  const dropEndIndex = arr.findIndex((item) => !canContinueDropping(item));
-  return arr.slice(dropEndIndex);
-}
-
-export {
-  dropWhile
-};
-//# sourceMappingURL=chunk-S767XFOS.mjs.map

package/dist/chunk-S767XFOS.mjs.map

@@ -1 +0,0 @@
-{"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 * @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: T[], canContinueDropping: (item: T) => boolean): T[] {\n  const dropEndIndex = arr.findIndex(item => !canContinueDropping(item));\n  return arr.slice(dropEndIndex);\n}\n"],"mappings":";AAiBO,SAAS,UAAa,KAAU,qBAAgD;AACrF,QAAM,eAAe,IAAI,UAAU,UAAQ,CAAC,oBAAoB,IAAI,CAAC;AACrE,SAAO,IAAI,MAAM,YAAY;AAC/B;","names":[]}

package/dist/chunk-SGSQKXDO.mjs

@@ -1,15 +0,0 @@
-import {
-  dropWhile
-} from "./chunk-S767XFOS.mjs";
-
-// src/array/dropRightWhile.ts
-function dropRightWhile(arr, canContinueDropping) {
-  const reversed = arr.slice().reverse();
-  const dropped = dropWhile(reversed, canContinueDropping);
-  return dropped.slice().reverse();
-}
-
-export {
-  dropRightWhile
-};
-//# sourceMappingURL=chunk-SGSQKXDO.mjs.map

package/dist/chunk-SGSQKXDO.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/array/dropRightWhile.ts"],"sourcesContent":["import { dropWhile } from \"./dropWhile\";\n\n/**\n * Removes elements from the end of an array until the predicate returns false.\n * \n * This function iterates over an array from the end and drops elements until the provided \n * predicate function returns false. It then returns a new array with the remaining elements.\n *\n * @param {T[]} arr - The array from which to drop elements.\n * @param {function(item: T): boolean} canContinueDropping - A predicate function that determines \n * whether to continue dropping elements. The function is called with each element from the end, \n * and dropping 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 = dropRightWhile(array, x => x > 3);\n * // result will be [1, 2, 3] since elements greater than 3 are dropped from the end.\n */\nexport function dropRightWhile<T>(arr: T[], canContinueDropping: (item: T) => boolean) {\n  const reversed = arr.slice().reverse();\n  const dropped = dropWhile(reversed, canContinueDropping);\n  return dropped.slice().reverse();\n}"],"mappings":";;;;;AAmBO,SAAS,eAAkB,KAAU,qBAA2C;AACrF,QAAM,WAAW,IAAI,MAAM,EAAE,QAAQ;AACrC,QAAM,UAAU,UAAU,UAAU,mBAAmB;AACvD,SAAO,QAAQ,MAAM,EAAE,QAAQ;AACjC;","names":[]}

package/dist/chunk-SYQTG4N4.mjs

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

package/dist/chunk-SYQTG4N4.mjs.map

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

package/dist/chunk-T5JCRGXA.mjs

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

package/dist/chunk-T5JCRGXA.mjs.map

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

package/dist/chunk-TOLR2FNF.mjs

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

package/dist/chunk-TOLR2FNF.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 * @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: T[]): T[] {\n  /**\n   * https://en.wikipedia.org/wiki/Fisher%E2%80%93Yates_shuffle#The_modern_algorithm\n   */\n  for (let i = arr.length - 1; i >= 1; i--) {\n    const j = Math.floor(Math.random() * (i + 1));\n    \n    [arr[i], arr[j]] = [arr[j], arr[i]];\n  }\n\n  return arr;\n}\n"],"mappings":";AAaO,SAAS,QAAW,KAAe;AAIxC,WAAS,IAAI,IAAI,SAAS,GAAG,KAAK,GAAG,KAAK;AACxC,UAAM,IAAI,KAAK,MAAM,KAAK,OAAO,KAAK,IAAI,EAAE;AAE5C,KAAC,IAAI,CAAC,GAAG,IAAI,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,CAAC;AAAA,EACpC;AAEA,SAAO;AACT;","names":[]}

package/dist/chunk-U42V7PZH.mjs

@@ -1,9 +0,0 @@
-// src/predicate/isNil.ts
-function isNil(x) {
-  return x == null || x == void 0;
-}
-
-export {
-  isNil
-};
-//# sourceMappingURL=chunk-U42V7PZH.mjs.map

package/dist/chunk-U42V7PZH.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/predicate/isNil.ts"],"sourcesContent":["/**\n * Checks if a given value is null or undefined.\n * \n * This function tests whether the provided value is either `null` or `undefined`. \n * It returns `true` if the value is `null` or `undefined`, and `false` otherwise.\n * \n * This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to `null` or `undefined`.\n *\n * @param {unknown} x - The value to test for null or undefined.\n * @returns {boolean} `true` if the value is null or undefined, `false` otherwise.\n *\n * @example\n *  * const value1 = null;\n * const value2 = undefined;\n * const value3 = 42;\n * const result1 = isNil(value1); // true\n * const result2 = isNil(value2); // true\n * const result3 = isNil(value3); // false\n */\nexport function isNil(x: unknown): x is null | undefined {\n  return x == null || x == undefined;\n}"],"mappings":";AAmBO,SAAS,MAAM,GAAmC;AACvD,SAAO,KAAK,QAAQ,KAAK;AAC3B;","names":[]}

package/dist/chunk-UNX3KZO2.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-UNX3KZO2.mjs.map

package/dist/chunk-UNX3KZO2.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 * @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 string>(arr: 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":";AA8BO,SAAS,QAA6B,KAAU,gBAAgD;AACrG,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-UZP4YX7I.mjs

@@ -1,17 +0,0 @@
-import {
-  __spreadValues
-} from "./chunk-2MM5EJJX.mjs";
-
-// src/object/omit.ts
-function omit(obj, keys) {
-  const result = __spreadValues({}, obj);
-  for (const key of keys) {
-    delete result[key];
-  }
-  return result;
-}
-
-export {
-  omit
-};
-//# sourceMappingURL=chunk-UZP4YX7I.mjs.map

package/dist/chunk-UZP4YX7I.mjs.map

@@ -1 +0,0 @@
-{"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 * @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, 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":";;;;;AAeO,SAAS,KAA2B,KAAQ,MAAuB;AACxE,QAAM,SAAS,mBAAK;AAEpB,aAAW,OAAO,MAAM;AACtB,WAAO,OAAO,GAAG;AAAA,EACnB;AAEA,SAAO;AACT;","names":[]}

package/dist/chunk-VACGGQOL.mjs

@@ -1,9 +0,0 @@
-// src/array/dropRight.ts
-function dropRight(arr, itemsCount) {
-  return arr.slice(0, -itemsCount);
-}
-
-export {
-  dropRight
-};
-//# sourceMappingURL=chunk-VACGGQOL.mjs.map

package/dist/chunk-VACGGQOL.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/array/dropRight.ts"],"sourcesContent":["/**\n * Removes a specified number of elements from the end 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 end.\n *\n * @param {T[]} arr - The array from which to drop elements.\n * @param {number} itemsCount - The number of elements to drop from the end of the array.\n * @returns {T[]} A new array with the specified number of elements removed from the end.\n *\n * @example\n *  * const array = [1, 2, 3, 4, 5];\n * const result = dropRight(array, 2);\n * // result will be [1, 2, 3] since the last two elements are dropped.\n */\nexport function dropRight<T>(arr: T[], itemsCount: number): T[] {\n  return arr.slice(0, -itemsCount);\n}\n"],"mappings":";AAeO,SAAS,UAAa,KAAU,YAAyB;AAC9D,SAAO,IAAI,MAAM,GAAG,CAAC,UAAU;AACjC;","names":[]}

package/dist/chunk-VAKCSKGR.mjs

@@ -1,17 +0,0 @@
-// src/function/throttle.ts
-function throttle(func, throttleMs) {
-  let lastCallTime;
-  const throttledFunction = function() {
-    const now = Date.now();
-    if (lastCallTime == null || now - lastCallTime >= throttleMs) {
-      lastCallTime = now;
-      func();
-    }
-  };
-  return throttledFunction;
-}
-
-export {
-  throttle
-};
-//# sourceMappingURL=chunk-VAKCSKGR.mjs.map

package/dist/chunk-VAKCSKGR.mjs.map

@@ -1 +0,0 @@
-{"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 {() => void} func - The function to throttle.\n * @param {number} throttleMs - The number of milliseconds to throttle executions to.\n * @returns {() => void} A new throttled 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(func: () => void, throttleMs: number) {\n  let lastCallTime: number | null;\n\n  const throttledFunction = function () {\n    const now = Date.now();\n\n    if (lastCallTime == null || now - lastCallTime >= throttleMs) {\n      lastCallTime = now;\n      func();\n    }\n  }\n\n  return throttledFunction;\n}"],"mappings":";AAyBO,SAAS,SAAS,MAAkB,YAAoB;AAC7D,MAAI;AAEJ,QAAM,oBAAoB,WAAY;AACpC,UAAM,MAAM,KAAK,IAAI;AAErB,QAAI,gBAAgB,QAAQ,MAAM,gBAAgB,YAAY;AAC5D,qBAAe;AACf,WAAK;AAAA,IACP;AAAA,EACF;AAEA,SAAO;AACT;","names":[]}

package/dist/chunk-XAJYDHCM.mjs

@@ -1,16 +0,0 @@
-// src/array/uniqWith.ts
-function uniqWith(arr, areItemsEqual) {
-  const result = [];
-  for (const item of arr) {
-    const isUniq = result.every((v) => !areItemsEqual(v, item));
-    if (isUniq) {
-      result.push(item);
-    }
-  }
-  return result;
-}
-
-export {
-  uniqWith
-};
-//# sourceMappingURL=chunk-XAJYDHCM.mjs.map

package/dist/chunk-XAJYDHCM.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/array/uniqWith.ts"],"sourcesContent":["import { uniq } from \"./uniq\";\n\n/**\n * The `uniqWith` function takes an array as its first argument and a 'comparator' function as the second.\n *\n * It evaluates the elements of the array using the comparator function, and if true is returned, it considers those elements as duplicates and removes them.\n *\n * @example\n * ```ts\n * uniqWith([1.2, 1.5, 2.1, 3.2, 5.7, 5.3, 7.19], (a, b) => Math.abs(a - b) < 1);\n * // [1, 2, 3, 5, 7]\n * ```\n */\nexport function uniqWith<T>(\n  arr: T[],\n  areItemsEqual: (item1: T, item2: T) => boolean\n): T[] {\n  const result: T[] = [];\n\n  for (const item of arr) {\n    const isUniq = result.every((v) => !areItemsEqual(v, item));\n\n    if (isUniq) {\n      result.push(item);\n    }\n  }\n\n  return result;\n}\n"],"mappings":";AAaO,SAAS,SACd,KACA,eACK;AACL,QAAM,SAAc,CAAC;AAErB,aAAW,QAAQ,KAAK;AACtB,UAAM,SAAS,OAAO,MAAM,CAAC,MAAM,CAAC,cAAc,GAAG,IAAI,CAAC;AAE1D,QAAI,QAAQ;AACV,aAAO,KAAK,IAAI;AAAA,IAClB;AAAA,EACF;AAEA,SAAO;AACT;","names":[]}

package/dist/chunk-XW452I77.mjs

@@ -1,16 +0,0 @@
-// src/object/pickBy.ts
-function pickBy(obj, shouldPick) {
-  const result = {};
-  for (const [key, value] of Object.entries(obj)) {
-    if (!shouldPick(value, key)) {
-      continue;
-    }
-    result[key] = value;
-  }
-  return result;
-}
-
-export {
-  pickBy
-};
-//# sourceMappingURL=chunk-XW452I77.mjs.map

package/dist/chunk-XW452I77.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/object/pickBy.ts"],"sourcesContent":["/**\n * Creates a new object composed of the properties that satisfy the predicate function.\n *\n * This function takes an object and a predicate function, and returns a new object that \n * includes only the properties for which the predicate function returns true.\n *\n * @param {T} obj - The object to pick properties from.\n * @param {(value: T[keyof T], key: string) => boolean} shouldPick - A predicate function that determines \n * whether a property should be picked. It takes the property's key and value as arguments and returns `true` \n * if the property should be picked, and `false` otherwise.\n * @returns {Partial<T>} A new object with the properties that satisfy the predicate function.\n *\n * @example\n * const obj = { a: 1, b: 'pick', c: 3 };\n * const shouldPick = (value) => typeof value === 'string';\n * const result = pickBy(obj, shouldPick);\n * // result will be { b: 'pick' }\n */\nexport function pickBy<T extends Record<string, any>>(obj: T, shouldPick: (value: T[keyof T], key: string) => boolean): Partial<T> {\n  const result: Partial<T> = {};\n\n  for (const [key, value] of Object.entries(obj)) {\n    if (!shouldPick(value, key)) {\n      continue;\n    }\n\n    (result as any)[key] = value;\n  }\n\n  return result;\n}\n"],"mappings":";AAkBO,SAAS,OAAsC,KAAQ,YAAqE;AACjI,QAAM,SAAqB,CAAC;AAE5B,aAAW,CAAC,KAAK,KAAK,KAAK,OAAO,QAAQ,GAAG,GAAG;AAC9C,QAAI,CAAC,WAAW,OAAO,GAAG,GAAG;AAC3B;AAAA,IACF;AAEA,IAAC,OAAe,GAAG,IAAI;AAAA,EACzB;AAEA,SAAO;AACT;","names":[]}

package/dist/chunk-Z4IO7EIH.mjs

@@ -1,16 +0,0 @@
-// src/object/omitBy.ts
-function omitBy(obj, shouldOmit) {
-  const result = {};
-  for (const [key, value] of Object.entries(obj)) {
-    if (shouldOmit(value, key)) {
-      continue;
-    }
-    result[key] = value;
-  }
-  return result;
-}
-
-export {
-  omitBy
-};
-//# sourceMappingURL=chunk-Z4IO7EIH.mjs.map

package/dist/chunk-Z4IO7EIH.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/object/omitBy.ts"],"sourcesContent":["/**\n * Creates a new object composed of the properties that do not satisfy the predicate function.\n *\n * This function takes an object and a predicate function, and returns a new object that \n * includes only the properties for which the predicate function returns false.\n *\n * @param {T} obj - The object to omit properties from.\n * @param {(value: T[string], key: string) => boolean} shouldOmit - A predicate function that determines \n * whether a property should be omitted. It takes the property's key and value as arguments and returns `true` \n * if the property should be omitted, and `false` otherwise.\n * @returns {Partial<T>} A new object with the properties that do not satisfy the predicate function.\n *\n * @example\n * const obj = { a: 1, b: 'omit', c: 3 };\n * const shouldOmit = (key, value) => typeof value === 'string';\n * const result = omitBy(obj, shouldOmit);\n * // result will be { a: 1, c: 3 }\n */\nexport function omitBy<T extends Record<string, any>>(obj: T, shouldOmit: (value: T[keyof T], key: string) => boolean): Partial<T> {\n  const result: Partial<T> = {};\n\n  for (const [key, value] of Object.entries(obj)) {\n    if (shouldOmit(value, key)) {\n      continue;\n    }\n\n    (result as any)[key] = value;\n  }\n\n  return result;\n}"],"mappings":";AAkBO,SAAS,OAAsC,KAAQ,YAAqE;AACjI,QAAM,SAAqB,CAAC;AAE5B,aAAW,CAAC,KAAK,KAAK,KAAK,OAAO,QAAQ,GAAG,GAAG;AAC9C,QAAI,WAAW,OAAO,GAAG,GAAG;AAC1B;AAAA,IACF;AAEA,IAAC,OAAe,GAAG,IAAI;AAAA,EACzB;AAEA,SAAO;AACT;","names":[]}

package/dist/function/debounce.js

@@ -1,47 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/function/debounce.ts
-var debounce_exports = {};
-__export(debounce_exports, {
-  debounce: () => debounce
-});
-module.exports = __toCommonJS(debounce_exports);
-function debounce(func, debounceMs) {
-  let timeoutId = null;
-  const debounced = function() {
-    if (timeoutId != null) {
-      clearTimeout(timeoutId);
-    }
-    timeoutId = setTimeout(() => {
-      func();
-    }, debounceMs);
-  };
-  debounced.cancel = function() {
-    if (timeoutId != null) {
-      clearTimeout(timeoutId);
-    }
-  };
-  return debounced;
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  debounce
-});
-//# sourceMappingURL=debounce.js.map

package/dist/function/debounce.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/function/debounce.ts"],"sourcesContent":["/**\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 {() => void} func - The function to debounce.\n * @param {number} debounceMs - The number of milliseconds to delay.\n * @returns {{ (): void; 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 */\nexport function debounce(func: () => void, debounceMs: number): { (): void; cancel: () => void } {\n  let timeoutId: number | NodeJS.Timeout | null = null;\n\n  const debounced = function () {\n    if (timeoutId != null) {\n      clearTimeout(timeoutId);\n    }\n    \n    \n    timeoutId = setTimeout(() => {\n      func();\n    }, debounceMs);\n  };\n\n  debounced.cancel = function () {\n    if (timeoutId != null) {\n      clearTimeout(timeoutId);\n    }\n  }  \n\n  return debounced;\n}"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAoBO,SAAS,SAAS,MAAkB,YAAsD;AAC/F,MAAI,YAA4C;AAEhD,QAAM,YAAY,WAAY;AAC5B,QAAI,aAAa,MAAM;AACrB,mBAAa,SAAS;AAAA,IACxB;AAGA,gBAAY,WAAW,MAAM;AAC3B,WAAK;AAAA,IACP,GAAG,UAAU;AAAA,EACf;AAEA,YAAU,SAAS,WAAY;AAC7B,QAAI,aAAa,MAAM;AACrB,mBAAa,SAAS;AAAA,IACxB;AAAA,EACF;AAEA,SAAO;AACT;","names":[]}

package/dist/function/debounce.mjs

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

package/dist/function/debounce.mjs.map

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

package/dist/function/index.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/function/index.ts","../../src/function/debounce.ts","../../src/function/once.ts","../../src/function/throttle.ts"],"sourcesContent":["export { debounce } from './debounce';\nexport { once } from './once';\nexport { throttle } from './throttle';","/**\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 {() => void} func - The function to debounce.\n * @param {number} debounceMs - The number of milliseconds to delay.\n * @returns {{ (): void; 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 */\nexport function debounce(func: () => void, debounceMs: number): { (): void; cancel: () => void } {\n  let timeoutId: number | NodeJS.Timeout | null = null;\n\n  const debounced = function () {\n    if (timeoutId != null) {\n      clearTimeout(timeoutId);\n    }\n    \n    \n    timeoutId = setTimeout(() => {\n      func();\n    }, debounceMs);\n  };\n\n  debounced.cancel = function () {\n    if (timeoutId != null) {\n      clearTimeout(timeoutId);\n    }\n  }  \n\n  return debounced;\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 {() => void} func - The function to throttle.\n * @param {number} throttleMs - The number of milliseconds to throttle executions to.\n * @returns {() => void} A new throttled 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(func: () => void, throttleMs: number) {\n  let lastCallTime: number | null;\n\n  const throttledFunction = function () {\n    const now = Date.now();\n\n    if (lastCallTime == null || now - lastCallTime >= throttleMs) {\n      lastCallTime = now;\n      func();\n    }\n  }\n\n  return throttledFunction;\n}"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACoBO,SAAS,SAAS,MAAkB,YAAsD;AAC/F,MAAI,YAA4C;AAEhD,QAAM,YAAY,WAAY;AAC5B,QAAI,aAAa,MAAM;AACrB,mBAAa,SAAS;AAAA,IACxB;AAGA,gBAAY,WAAW,MAAM;AAC3B,WAAK;AAAA,IACP,GAAG,UAAU;AAAA,EACf;AAEA,YAAU,SAAS,WAAY;AAC7B,QAAI,aAAa,MAAM;AACrB,mBAAa,SAAS;AAAA,IACxB;AAAA,EACF;AAEA,SAAO;AACT;;;ACzBO,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,SAAS,MAAkB,YAAoB;AAC7D,MAAI;AAEJ,QAAM,oBAAoB,WAAY;AACpC,UAAM,MAAM,KAAK,IAAI;AAErB,QAAI,gBAAgB,QAAQ,MAAM,gBAAgB,YAAY;AAC5D,qBAAe;AACf,WAAK;AAAA,IACP;AAAA,EACF;AAEA,SAAO;AACT;","names":[]}

package/dist/function/index.mjs

@@ -1,17 +0,0 @@
-import "../chunk-SYQTG4N4.mjs";
-import {
-  debounce
-} from "../chunk-L4Y3G6AJ.mjs";
-import {
-  once
-} from "../chunk-ARWKEQMQ.mjs";
-import {
-  throttle
-} from "../chunk-VAKCSKGR.mjs";
-import "../chunk-2MM5EJJX.mjs";
-export {
-  debounce,
-  once,
-  throttle
-};
-//# sourceMappingURL=index.mjs.map

package/dist/function/index.mjs.map

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

package/dist/function/once.js

@@ -1,43 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/function/once.ts
-var once_exports = {};
-__export(once_exports, {
-  once: () => once
-});
-module.exports = __toCommonJS(once_exports);
-function once(func) {
-  let called = false;
-  let cache;
-  return function() {
-    if (called) {
-      return cache;
-    }
-    const result = func();
-    called = true;
-    cache = result;
-    return result;
-  };
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  once
-});
-//# sourceMappingURL=once.js.map

package/dist/function/once.js.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 * @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":[]}