es-toolkit 1.0.3 → 1.0.4-dev.41

package/dist/chunk-SYQTG4N4.mjs

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

package/dist/chunk-SYQTG4N4.mjs.map

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

package/dist/chunk-T2C2WVFL.mjs

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

package/dist/chunk-T2C2WVFL.mjs.map

@@ -0,0 +1 @@
+{"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>>(\n  obj: T,\n  shouldPick: (value: T[keyof T], key: string) => boolean\n): 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,OACd,KACA,YACY;AACZ,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-T5JCRGXA.mjs

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

package/dist/chunk-T5JCRGXA.mjs.map

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

package/dist/chunk-TCHT4HCP.mjs

@@ -0,0 +1,21 @@
+import {
+  unionWith
+} from "./chunk-YEZIGQJG.mjs";
+import {
+  intersectionWith
+} from "./chunk-7LAOIS6P.mjs";
+import {
+  differenceWith
+} from "./chunk-M3SHJ3LL.mjs";
+
+// src/array/xorWith.ts
+function xorWith(arr1, arr2, areElementsEqual) {
+  const union = unionWith(arr1, arr2, areElementsEqual);
+  const intersection = intersectionWith(arr1, arr2, areElementsEqual);
+  return differenceWith(union, intersection, areElementsEqual);
+}
+
+export {
+  xorWith
+};
+//# sourceMappingURL=chunk-TCHT4HCP.mjs.map

package/dist/chunk-TCHT4HCP.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/array/xorWith.ts"],"sourcesContent":["import { differenceWith } from './differenceWith';\nimport { intersectionWith } from './intersectionWith';\nimport { unionWith } from './unionWith';\n\n/**\n * Computes the symmetric difference between two arrays using a custom equality function.\n * The symmetric difference is the set of elements which are in either of the arrays,\n * but not in their intersection.\n *\n * @template T - Type of elements in the input arrays.\n *\n * @param {T[]} arr1 - The first array.\n * @param {T[]} arr2 - The second array.\n * @param {(item1: T, item2: T) => boolean} areElementsEqual - The custom equality function to compare elements.\n * @returns {T[]} An array containing the elements that are present in either `arr1` or `arr2` but not in both, based on the custom equality function.\n *\n * @example\n * // Custom equality function for objects with an 'id' property\n * const areObjectsEqual = (a, b) => a.id === b.id;\n * xorWith([{ id: 1 }, { id: 2 }], [{ id: 2 }, { id: 3 }], areObjectsEqual);\n * // Returns [{ id: 1 }, { id: 3 }]\n */\nexport function xorWith<T>(arr1: T[], arr2: T[], areElementsEqual: (item1: T, item2: T) => boolean): T[] {\n  const union = unionWith(arr1, arr2, areElementsEqual);\n  const intersection = intersectionWith(arr1, arr2, areElementsEqual);\n\n  return differenceWith(union, intersection, areElementsEqual);\n}\n"],"mappings":";;;;;;;;;;;AAsBO,SAAS,QAAW,MAAW,MAAW,kBAAwD;AACvG,QAAM,QAAQ,UAAU,MAAM,MAAM,gBAAgB;AACpD,QAAM,eAAe,iBAAiB,MAAM,MAAM,gBAAgB;AAElE,SAAO,eAAe,OAAO,cAAc,gBAAgB;AAC7D;","names":[]}

package/dist/chunk-TF6N37OE.mjs

@@ -0,0 +1,18 @@
+// src/array/partition.ts
+function partition(arr, isInTruthy) {
+  const truthy = [];
+  const falsy = [];
+  for (const item of arr) {
+    if (isInTruthy(item)) {
+      truthy.push(item);
+    } else {
+      falsy.push(item);
+    }
+  }
+  return [truthy, falsy];
+}
+
+export {
+  partition
+};
+//# sourceMappingURL=chunk-TF6N37OE.mjs.map

package/dist/chunk-TF6N37OE.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/array/partition.ts"],"sourcesContent":["/**\n * Splits an array into two groups based on a predicate function.\n *\n * This function takes an array and a predicate function. It returns a tuple of two arrays:\n * the first array contains elements for which the predicate function returns true, and\n * the second array contains elements for which the predicate function returns false.\n *\n * @param {T[]} arr - The array to partition.\n * @param {(value: T) => boolean} isInTruthy - A predicate function that determines\n * whether an element should be placed in the truthy array. The function is called with each\n * element of the array.\n * @returns {[T[], T[]]} A tuple containing two arrays: the first array contains elements for\n * which the predicate returned true, and the second array contains elements for which the\n * predicate returned false.\n *\n * @example\n * const array = [1, 2, 3, 4, 5];\n * const isEven = x => x % 2 === 0;\n * const [even, odd] = partition(array, isEven);\n * // even will be [2, 4], and odd will be [1, 3, 5]\n */\nexport function partition<T>(arr: T[], isInTruthy: (value: T) => boolean): [truthy: T[], falsy: T[]] {\n  const truthy: T[] = [];\n  const falsy: T[] = [];\n\n  for (const item of arr) {\n    if (isInTruthy(item)) {\n      truthy.push(item);\n    } else {\n      falsy.push(item);\n    }\n  }\n\n  return [truthy, falsy];\n}\n"],"mappings":";AAqBO,SAAS,UAAa,KAAU,YAA8D;AACnG,QAAM,SAAc,CAAC;AACrB,QAAM,QAAa,CAAC;AAEpB,aAAW,QAAQ,KAAK;AACtB,QAAI,WAAW,IAAI,GAAG;AACpB,aAAO,KAAK,IAAI;AAAA,IAClB,OAAO;AACL,YAAM,KAAK,IAAI;AAAA,IACjB;AAAA,EACF;AAEA,SAAO,CAAC,QAAQ,KAAK;AACvB;","names":[]}

package/dist/chunk-TK2EDHSP.mjs

@@ -0,0 +1,13 @@
+import {
+  uniqWith
+} from "./chunk-SQOYF647.mjs";
+
+// src/array/uniqBy.ts
+function uniqBy(arr, converter) {
+  return uniqWith(arr, (item1, item2) => converter(item1) === converter(item2));
+}
+
+export {
+  uniqBy
+};
+//# sourceMappingURL=chunk-TK2EDHSP.mjs.map

package/dist/chunk-TK2EDHSP.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/array/uniqBy.ts"],"sourcesContent":["import { uniqWith } from './uniqWith';\n\n/**\n * The `uniqBy` function takes an array as its first argument and a 'converter' function as the second. It maps the array elements using the converter function, then removes any duplicates.\n *\n * It filters out elements with the same value, meaning it does not check for duplicates in data types like Objects.\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: T[], converter: (item: T) => U): T[] {\n  return uniqWith(arr, (item1, item2) => converter(item1) === converter(item2));\n}\n"],"mappings":";;;;;AAaO,SAAS,OAAa,KAAU,WAAgC;AACrE,SAAO,SAAS,KAAK,CAAC,OAAO,UAAU,UAAU,KAAK,MAAM,UAAU,KAAK,CAAC;AAC9E;","names":[]}

package/dist/chunk-TULUUJ3E.mjs

@@ -0,0 +1,21 @@
+import {
+  unionBy
+} from "./chunk-SPLO5OZW.mjs";
+import {
+  intersectionBy
+} from "./chunk-ANJSX6WH.mjs";
+import {
+  differenceBy
+} from "./chunk-PUQLVKMB.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-TULUUJ3E.mjs.map

package/dist/chunk-TULUUJ3E.mjs.map

@@ -0,0 +1 @@
+{"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-UFAA5WKR.mjs

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

package/dist/chunk-UFAA5WKR.mjs.map

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

package/dist/chunk-V6LXSPMF.mjs

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

package/dist/chunk-V6LXSPMF.mjs.map

@@ -0,0 +1 @@
+{"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-Y6ZRNII6.mjs

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

package/dist/chunk-Y6ZRNII6.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/predicate/isNull.ts"],"sourcesContent":["/**\n * Checks if the given value is null.\n *\n * This function tests whether the provided value is strictly equal to `null`.\n * It returns `true` if the value is `null`, and `false` otherwise.\n *\n * This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to `null`.\n *\n * @param {unknown} x - The value to test if it is null.\n * @returns {x is null} True if the value is null, false otherwise.\n *\n * @example\n *  * const value1 = null;\n * const value2 = undefined;\n * const value3 = 42;\n *\n * console.log(isNull(value1)); // true\n * console.log(isNull(value2)); // false\n * console.log(isNull(value3)); // false\n */\nexport function isNull(x: unknown): x is null {\n  return x === null;\n}\n"],"mappings":";AAoBO,SAAS,OAAO,GAAuB;AAC5C,SAAO,MAAM;AACf;","names":[]}

package/dist/chunk-YEZIGQJG.mjs

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

package/dist/chunk-YEZIGQJG.mjs.map

@@ -0,0 +1 @@
+{"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-YHY2XTJW.mjs

@@ -0,0 +1,10 @@
+// src/math/round.ts
+function round(value, precision = 0) {
+  const multiplier = Math.pow(10, precision);
+  return Math.round(value * multiplier) / multiplier;
+}
+
+export {
+  round
+};
+//# sourceMappingURL=chunk-YHY2XTJW.mjs.map

package/dist/chunk-YHY2XTJW.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/math/round.ts"],"sourcesContent":["/**\n * Rounds a number to a specified precision.\n *\n * This function takes a number and an optional precision value, and returns the number rounded\n * to the specified number of decimal places.\n *\n * @param {number} value - The number to round.\n * @param {number} [precision=0] - The number of decimal places to round to. Defaults to 0.\n * @returns {number} The rounded number.\n *\n * @example\n *  * const result1 = round(1.2345); // result1 will be 1\n * const result2 = round(1.2345, 2); // result2 will be 1.23\n * const result3 = round(1.2345, 3); // result3 will be 1.235\n */\nexport function round(value: number, precision: number = 0): number {\n  const multiplier = Math.pow(10, precision);\n  return Math.round(value * multiplier) / multiplier;\n}\n"],"mappings":";AAeO,SAAS,MAAM,OAAe,YAAoB,GAAW;AAClE,QAAM,aAAa,KAAK,IAAI,IAAI,SAAS;AACzC,SAAO,KAAK,MAAM,QAAQ,UAAU,IAAI;AAC1C;","names":[]}

package/dist/chunk-YNRYG5OB.mjs

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

package/dist/chunk-YNRYG5OB.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/array/intersection.ts"],"sourcesContent":["/**\n * Returns the intersection of two arrays.\n *\n * This function takes two arrays and returns a new array containing the elements that are\n * present in both arrays. It effectively filters out any elements from the first array that\n * are not found in the second array.\n *\n * @param {T[]} firstArr - The first array to compare.\n * @param {T[]} secondArr - The second array to compare.\n * @returns {T[]} A new array containing the elements that are present in both arrays.\n *\n * @example\n * const array1 = [1, 2, 3, 4, 5];\n * const array2 = [3, 4, 5, 6, 7];\n * const result = intersection(array1, array2);\n * // result will be [3, 4, 5] since these elements are in both arrays.\n */\nexport function intersection<T>(firstArr: T[], secondArr: T[]): T[] {\n  return firstArr.filter(item => {\n    return secondArr.includes(item);\n  });\n}\n"],"mappings":";AAiBO,SAAS,aAAgB,UAAe,WAAqB;AAClE,SAAO,SAAS,OAAO,UAAQ;AAC7B,WAAO,UAAU,SAAS,IAAI;AAAA,EAChC,CAAC;AACH;","names":[]}

package/dist/chunk-ZBG3EYM3.mjs

@@ -0,0 +1,11 @@
+// src/promise/delay.ts
+function delay(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+
+export {
+  delay
+};
+//# sourceMappingURL=chunk-ZBG3EYM3.mjs.map

package/dist/chunk-ZBG3EYM3.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/promise/delay.ts"],"sourcesContent":["/**\n * Delays the execution of code for a specified number of milliseconds.\n *\n * This function returns a Promise that resolves after the specified delay, allowing you to use it\n * with async/await to pause execution.\n *\n * @param {number} ms - The number of milliseconds to delay.\n * @returns {Promise<void>} A Promise that resolves after the specified delay.\n *\n * @example\n * async function foo() {\n *   console.log('Start');\n *   await delay(1000); // Delays execution for 1 second\n *   console.log('End');\n * }\n *\n * foo();\n */\nexport function delay(ms: number): Promise<void> {\n  return new Promise(resolve => {\n    setTimeout(resolve, ms);\n  });\n}\n"],"mappings":";AAkBO,SAAS,MAAM,IAA2B;AAC/C,SAAO,IAAI,QAAQ,aAAW;AAC5B,eAAW,SAAS,EAAE;AAAA,EACxB,CAAC;AACH;","names":[]}

package/dist/chunk-ZQNAZPSK.mjs

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

package/dist/chunk-ZQNAZPSK.mjs.map

@@ -0,0 +1 @@
+{"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,MAAM,QAAQ,MAAM;AAC7B;","names":[]}

package/{esm/function/debounce.mjs → dist/function/debounce.d.mts}

@@ -14,26 +14,13 @@
  *
  * // Will log 'Function executed' after 1 second if not called again in that time
  * debouncedFunction();
- * 
+ *
  * // Will not log anything as the previous call is canceled
  * debouncedFunction.cancel();
  */
-function debounce(func, debounceMs) {
-  var timeoutId = null;
-  var debounced = function debounced() {
-    if (timeoutId != null) {
-      clearTimeout(timeoutId);
-    }
-    timeoutId = setTimeout(function () {
-      func();
-    }, debounceMs);
-  };
-  debounced.cancel = function () {
-    if (timeoutId != null) {
-      clearTimeout(timeoutId);
-    }
-  };
-  return debounced;
-}
+declare function debounce(func: () => void, debounceMs: number): {
+    (): void;
+    cancel: () => void;
+};
 
 export { debounce };

package/dist/function/debounce.d.ts

@@ -18,7 +18,9 @@
  * // Will not log anything as the previous call is canceled
  * debouncedFunction.cancel();
  */
-export declare function debounce(func: () => void, debounceMs: number): {
+declare function debounce(func: () => void, debounceMs: number): {
     (): void;
     cancel: () => void;
 };
+
+export { debounce };

package/dist/function/debounce.js

@@ -0,0 +1,47 @@
+"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

@@ -0,0 +1 @@
+{"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    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"],"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;AAEA,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

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

package/dist/function/debounce.mjs.map

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

package/dist/function/index.d.ts

@@ -1,3 +1,3 @@
-export { debounce } from './debounce';
-export { once } from './once';
-export { throttle } from './throttle';
+export { debounce } from './debounce.js';
+export { once } from './once.js';
+export { throttle } from './throttle.js';

package/dist/function/index.js

@@ -1,38 +1,43 @@
-'use strict';
+"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);
 
-Object.defineProperty(exports, '__esModule', { value: true });
+// src/function/index.ts
+var function_exports = {};
+__export(function_exports, {
+  debounce: () => debounce,
+  once: () => once,
+  throttle: () => throttle
+});
+module.exports = __toCommonJS(function_exports);
 
-/**
- * Creates a debounced function that delays invoking the provided function until after `debounceMs` milliseconds
- * have elapsed since the last time the debounced function was invoked. The debounced function also has a `cancel`
- * method to cancel any pending execution.
- *
- * @param {() => void} func - The function to debounce.
- * @param {number} debounceMs - The number of milliseconds to delay.
- * @returns {{ (): void; cancel: () => void }} A new debounced function with a `cancel` method.
- *
- * @example
- * const debouncedFunction = debounce(() => {
- *   console.log('Function executed');
- * }, 1000);
- *
- * // Will log 'Function executed' after 1 second if not called again in that time
- * debouncedFunction();
- * 
- * // Will not log anything as the previous call is canceled
- * debouncedFunction.cancel();
- */
+// src/function/debounce.ts
 function debounce(func, debounceMs) {
-  var timeoutId = null;
-  var debounced = function debounced() {
+  let timeoutId = null;
+  const debounced = function() {
     if (timeoutId != null) {
       clearTimeout(timeoutId);
     }
-    timeoutId = setTimeout(function () {
+    timeoutId = setTimeout(() => {
       func();
     }, debounceMs);
   };
-  debounced.cancel = function () {
+  debounced.cancel = function() {
     if (timeoutId != null) {
       clearTimeout(timeoutId);
     }
@@ -40,65 +45,26 @@ function debounce(func, debounceMs) {
   return debounced;
 }
 
-/**
- * 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.
- *
- * @param {F} func - The function to restrict.
- * @returns {F} A new function that invokes `func` once and caches the result.
- *
- * @example
- * const initialize = once(() => {
- *   console.log('Initialized!');
- *   return true;
- * });
- * 
- * initialize(); // Logs: 'Initialized!' and returns true
- * initialize(); // Returns true without logging
- */
+// src/function/once.ts
 function once(func) {
-  var called = false;
-  var cache;
-  return function () {
+  let called = false;
+  let cache;
+  return function() {
     if (called) {
       return cache;
     }
-    var result = func();
+    const result = func();
     called = true;
     cache = result;
     return result;
   };
 }
 
-/**
- * Creates a throttled function that only invokes the provided function at most once
- * per every `throttleMs` milliseconds. Subsequent calls to the throttled function
- * within the wait time will not trigger the execution of the original function.
- *
- * @param {() => void} func - The function to throttle.
- * @param {number} throttleMs - The number of milliseconds to throttle executions to.
- * @returns {() => void} A new throttled function.
- *
- * @example
- * const throttledFunction = throttle(() => {
- *   console.log('Function executed');
- * }, 1000);
- *
- * // Will log 'Function executed' immediately
- * throttledFunction();
- * 
- * // Will not log anything as it is within the throttle time
- * throttledFunction();
- * 
- * // After 1 second
- * setTimeout(() => {
- *   throttledFunction(); // Will log 'Function executed'
- * }, 1000);
- */
+// src/function/throttle.ts
 function throttle(func, throttleMs) {
-  var lastCallTime;
-  var throttledFunction = function throttledFunction() {
-    var now = Date.now();
+  let lastCallTime;
+  const throttledFunction = function() {
+    const now = Date.now();
     if (lastCallTime == null || now - lastCallTime >= throttleMs) {
       lastCallTime = now;
       func();
@@ -106,7 +72,10 @@ function throttle(func, throttleMs) {
   };
   return throttledFunction;
 }
-
-exports.debounce = debounce;
-exports.once = once;
-exports.throttle = throttle;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  debounce,
+  once,
+  throttle
+});
+//# sourceMappingURL=index.js.map

package/dist/function/index.js.map

@@ -0,0 +1 @@
+{"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","/**\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    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","/**\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}\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;AAEA,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;;;ACxBO,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

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

package/dist/function/index.mjs.map

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

package/{esm/function/once.mjs → dist/function/once.d.mts}

@@ -10,22 +10,10 @@
  *   console.log('Initialized!');
  *   return true;
  * });
- * 
+ *
  * initialize(); // Logs: 'Initialized!' and returns true
  * initialize(); // Returns true without logging
  */
-function once(func) {
-  var called = false;
-  var cache;
-  return function () {
-    if (called) {
-      return cache;
-    }
-    var result = func();
-    called = true;
-    cache = result;
-    return result;
-  };
-}
+declare function once<F extends () => any>(func: F): F;
 
 export { once };

package/dist/function/once.d.ts

@@ -14,4 +14,6 @@
  * initialize(); // Logs: 'Initialized!' and returns true
  * initialize(); // Returns true without logging
  */
-export declare function once<F extends () => any>(func: F): F;
+declare function once<F extends () => any>(func: F): F;
+
+export { once };