es-toolkit 1.13.1-dev.329 → 1.13.1-dev.333

package/dist/_chunk/index-CwRt_M.js

@@ -0,0 +1,47 @@
+'use strict';
+
+class AbortError extends Error {
+    constructor(message = 'The operation was aborted') {
+        super(message);
+        this.name = 'AbortError';
+    }
+}
+
+class TimeoutError extends Error {
+    constructor(message = 'The operation was timed out') {
+        super(message);
+        this.name = 'TimeoutError';
+    }
+}
+
+function delay(ms, { signal } = {}) {
+    return new Promise((resolve, reject) => {
+        const abortError = () => {
+            reject(new AbortError());
+        };
+        const abortHandler = () => {
+            clearTimeout(timeoutId);
+            abortError();
+        };
+        if (signal?.aborted) {
+            return abortError();
+        }
+        const timeoutId = setTimeout(resolve, ms);
+        signal?.addEventListener('abort', abortHandler, { once: true });
+    });
+}
+
+async function timeout(ms) {
+    await delay(ms);
+    throw new TimeoutError();
+}
+
+async function withTimeout(run, ms) {
+    return Promise.race([run(), timeout(ms)]);
+}
+
+exports.AbortError = AbortError;
+exports.TimeoutError = TimeoutError;
+exports.delay = delay;
+exports.withTimeout = withTimeout;
+//# sourceMappingURL=index-CwRt_M.js.map

package/dist/_chunk/index-CwRt_M.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-CwRt_M.js","sources":["../../src/error/AbortError.ts","../../src/error/TimeoutError.ts","../../src/promise/delay.ts","../../src/promise/timeout.ts","../../src/promise/withTimeout.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","/**\n * An error class representing an timeout operation.\n * @augments Error\n */\nexport class TimeoutError extends Error {\n  constructor(message = 'The operation was timed out') {\n    super(message);\n    this.name = 'TimeoutError';\n  }\n}\n","import { AbortError } from '../error/AbortError.ts';\n\ninterface DelayOptions {\n  signal?: AbortSignal;\n}\n\n/**\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 * @param {DelayOptions} options - The options object.\n * @param {AbortSignal} options.signal - An optional AbortSignal to cancel the 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 *\n * // With AbortSignal\n * const controller = new AbortController();\n * const { signal } = controller;\n *\n * setTimeout(() => controller.abort(), 50); // Will cancel the delay after 50ms\n * try {\n *   await delay(100, { signal });\n *  } catch (error) {\n *   console.error(error); // Will log 'AbortError'\n *  }\n * }\n */\nexport function delay(ms: number, { signal }: DelayOptions = {}): Promise<void> {\n  return new Promise((resolve, reject) => {\n    const abortError = () => {\n      reject(new AbortError());\n    };\n\n    const abortHandler = () => {\n      clearTimeout(timeoutId);\n      abortError();\n    };\n\n    if (signal?.aborted) {\n      return abortError();\n    }\n\n    const timeoutId = setTimeout(resolve, ms);\n\n    signal?.addEventListener('abort', abortHandler, { once: true });\n  });\n}\n","import { delay } from './delay.ts';\nimport { TimeoutError } from '../error/TimeoutError.ts';\n\n/**\n * Returns a promise that rejects with a `TimeoutError` after a specified delay.\n *\n * @param {number} ms - The delay duration in milliseconds.\n * @returns {Promise<void>} A promise that rejects with a `TimeoutError` after the specified delay.\n * @throws {TimeoutError} Throws a `TimeoutError` after the specified delay.\n */\nexport async function timeout(ms: number): Promise<never> {\n  await delay(ms);\n  throw new TimeoutError();\n}\n","import { timeout } from './timeout.ts';\n\n/**\n * Executes an async function and enforces a timeout. \n * \n * If the promise does not resolve within the specified time,\n * the timeout will trigger and the returned promise will be rejected.\n *\n *\n * @template T \n * @param {() => Promise<T>} run - A function that returns a promise to be executed.\n * @param {number} ms - The timeout duration in milliseconds.\n * @returns {Promise<T>} A promise that resolves with the result of the `run` function or rejects if the timeout is reached.\n *\n * @example\n * try {\n *   await withTimeout(() => {}, 1000); // Timeout exception after 1 second\n * } catch (error) {\n *   console.error(error); // Will log 'TimeoutError'\n * }\n */\nexport async function withTimeout<T>(run: () => Promise<T>, ms: number): Promise<T> {\n  return Promise.race([run(), timeout(ms) as T]);\n}\n"],"names":[],"mappings":";;AAIM,MAAO,UAAW,SAAQ,KAAK,CAAA;IACnC,WAAY,CAAA,OAAO,GAAG,2BAA2B,EAAA;QAC/C,KAAK,CAAC,OAAO,CAAC,CAAC;AACf,QAAA,IAAI,CAAC,IAAI,GAAG,YAAY,CAAC;KAC1B;AACF;;ACLK,MAAO,YAAa,SAAQ,KAAK,CAAA;IACrC,WAAY,CAAA,OAAO,GAAG,6BAA6B,EAAA;QACjD,KAAK,CAAC,OAAO,CAAC,CAAC;AACf,QAAA,IAAI,CAAC,IAAI,GAAG,cAAc,CAAC;KAC5B;AACF;;AC6BK,SAAU,KAAK,CAAC,EAAU,EAAE,EAAE,MAAM,KAAmB,EAAE,EAAA;IAC7D,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,MAAM,KAAI;QACrC,MAAM,UAAU,GAAG,MAAK;AACtB,YAAA,MAAM,CAAC,IAAI,UAAU,EAAE,CAAC,CAAC;AAC3B,SAAC,CAAC;QAEF,MAAM,YAAY,GAAG,MAAK;YACxB,YAAY,CAAC,SAAS,CAAC,CAAC;AACxB,YAAA,UAAU,EAAE,CAAC;AACf,SAAC,CAAC;AAEF,QAAA,IAAI,MAAM,EAAE,OAAO,EAAE;YACnB,OAAO,UAAU,EAAE,CAAC;SACrB;QAED,MAAM,SAAS,GAAG,UAAU,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC;AAE1C,QAAA,MAAM,EAAE,gBAAgB,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC;AAClE,KAAC,CAAC,CAAC;AACL;;AC/CO,eAAe,OAAO,CAAC,EAAU,EAAA;AACtC,IAAA,MAAM,KAAK,CAAC,EAAE,CAAC,CAAC;IAChB,MAAM,IAAI,YAAY,EAAE,CAAC;AAC3B;;ACQO,eAAe,WAAW,CAAI,GAAqB,EAAE,EAAU,EAAA;AACpE,IAAA,OAAO,OAAO,CAAC,IAAI,CAAC,CAAC,GAAG,EAAE,EAAE,OAAO,CAAC,EAAE,CAAM,CAAC,CAAC,CAAC;AACjD;;;;;;;"}

package/dist/_chunk/isPlainObject-bK22pA.js

@@ -0,0 +1,24 @@
+'use strict';
+
+function isPlainObject(object) {
+    if (typeof object !== 'object') {
+        return false;
+    }
+    if (object == null) {
+        return false;
+    }
+    if (Object.getPrototypeOf(object) === null) {
+        return true;
+    }
+    if (object.toString() !== '[object Object]') {
+        return false;
+    }
+    let proto = object;
+    while (Object.getPrototypeOf(proto) !== null) {
+        proto = Object.getPrototypeOf(proto);
+    }
+    return Object.getPrototypeOf(object) === proto;
+}
+
+exports.isPlainObject = isPlainObject;
+//# sourceMappingURL=isPlainObject-bK22pA.js.map

package/dist/_chunk/isPlainObject-bK22pA.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"isPlainObject-bK22pA.js","sources":["../../src/predicate/isPlainObject.ts"],"sourcesContent":["/**\n * Checks if a given value is a plain object.\n * \n * @param {object} object - The value to check.\n * @returns {boolean} - True if the value is a plain object, otherwise false.\n * \n * @example\n * console.log(isPlainObject({})); // true\n * console.log(isPlainObject([])); // false\n * console.log(isPlainObject(null)); // false\n * console.log(isPlainObject(Object.create(null))); // true\n * console.log(Buffer.from('hello, world')); // false\n */\nexport function isPlainObject(object: object): boolean {\n  if (typeof object !== 'object') {\n    return false;\n  }\n\n  if (object == null) {\n    return false;\n  }\n\n  if (Object.getPrototypeOf(object) === null) {\n    return true;\n  }\n\n  if (object.toString() !== '[object Object]') {\n    return false;\n  }\n\n  let proto = object;\n\n  while (Object.getPrototypeOf(proto) !== null) {\n    proto = Object.getPrototypeOf(proto);\n  }\n\n  return Object.getPrototypeOf(object) === proto;\n}"],"names":[],"mappings":";;AAaM,SAAU,aAAa,CAAC,MAAc,EAAA;AAC1C,IAAA,IAAI,OAAO,MAAM,KAAK,QAAQ,EAAE;AAC9B,QAAA,OAAO,KAAK,CAAC;KACd;AAED,IAAA,IAAI,MAAM,IAAI,IAAI,EAAE;AAClB,QAAA,OAAO,KAAK,CAAC;KACd;IAED,IAAI,MAAM,CAAC,cAAc,CAAC,MAAM,CAAC,KAAK,IAAI,EAAE;AAC1C,QAAA,OAAO,IAAI,CAAC;KACb;AAED,IAAA,IAAI,MAAM,CAAC,QAAQ,EAAE,KAAK,iBAAiB,EAAE;AAC3C,QAAA,OAAO,KAAK,CAAC;KACd;IAED,IAAI,KAAK,GAAG,MAAM,CAAC;IAEnB,OAAO,MAAM,CAAC,cAAc,CAAC,KAAK,CAAC,KAAK,IAAI,EAAE;AAC5C,QAAA,KAAK,GAAG,MAAM,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC;KACtC;IAED,OAAO,MAAM,CAAC,cAAc,CAAC,MAAM,CAAC,KAAK,KAAK,CAAC;AACjD;;;;"}

package/dist/_chunk/randomInt-CF7bZK.js

@@ -0,0 +1,20 @@
+'use strict';
+
+function random(minimum, maximum) {
+    if (maximum == null) {
+        maximum = minimum;
+        minimum = 0;
+    }
+    if (minimum >= maximum) {
+        throw new Error('Invalid input: The maximum value must be greater than the minimum value.');
+    }
+    return Math.random() * (maximum - minimum) + minimum;
+}
+
+function randomInt(minimum, maximum) {
+    return Math.floor(random(minimum, maximum));
+}
+
+exports.random = random;
+exports.randomInt = randomInt;
+//# sourceMappingURL=randomInt-CF7bZK.js.map

package/dist/_chunk/randomInt-CF7bZK.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"randomInt-CF7bZK.js","sources":["../../src/math/random.ts","../../src/math/randomInt.ts"],"sourcesContent":["/**\n * Generate a random number within the given range.\n *\n * If only one argument is provided, a number between `0` and the given number is returned.\n *\n * @param {number} minimum - The lower bound (inclusive).\n * @param {number} maximum - The upper bound (exclusive).\n * @returns {number} A random number between minimum (inclusive) and maximum (exclusive). The number can be an integer or a decimal.\n * @throws {Error} Throws an error if `maximum` is not greater than `minimum`.\n *\n * @example\n * const result1 = random(0, 5); // Returns a random number between 0 and 5.\n * const result2 = random(5, 0); // If the minimum is greater than the maximum, an error is thrown\n * const result3 = random(5, 5); // If the minimum is equal to the maximum, an error is thrown.\n */\nexport function random(maximum: number): number;\nexport function random(minimum: number, maximum: number): number;\nexport function random(minimum: number, maximum?: number): number {\n  if (maximum == null) {\n    maximum = minimum;\n    minimum = 0;\n  }\n\n  if (minimum >= maximum) {\n    throw new Error('Invalid input: The maximum value must be greater than the minimum value.');\n  }\n\n  return Math.random() * (maximum - minimum) + minimum;\n}\n","import { random } from './random.ts';\n\n/**\n * Generates a random integer between minimum (inclusive) and maximum (exclusive).\n *\n * If only one argument is provided, a number between `0` and the given number is returned.\n *\n * @param {number} minimum - The lower bound (inclusive).\n * @param {number} maximum - The upper bound (exclusive).\n * @returns {number} A random integer between minimum (inclusive) and maximum (exclusive).\n * @throws {Error} Throws an error if `maximum` is not greater than `minimum`.\n *\n * @example\n * const result = randomInt(0, 5); // result will be a random integer between 0 (inclusive) and 5 (exclusive)\n * const result2 = randomInt(5, 0); // This will throw an error\n */\nexport function randomInt(maximum: number): number;\nexport function randomInt(minimum: number, maximum: number): number;\nexport function randomInt(minimum: number, maximum?: number): number {\n  return Math.floor(random(minimum, maximum!));\n}\n"],"names":[],"mappings":";;AAiBgB,SAAA,MAAM,CAAC,OAAe,EAAE,OAAgB,EAAA;AACtD,IAAA,IAAI,OAAO,IAAI,IAAI,EAAE;QACnB,OAAO,GAAG,OAAO,CAAC;QAClB,OAAO,GAAG,CAAC,CAAC;KACb;AAED,IAAA,IAAI,OAAO,IAAI,OAAO,EAAE;AACtB,QAAA,MAAM,IAAI,KAAK,CAAC,0EAA0E,CAAC,CAAC;KAC7F;AAED,IAAA,OAAO,IAAI,CAAC,MAAM,EAAE,IAAI,OAAO,GAAG,OAAO,CAAC,GAAG,OAAO,CAAC;AACvD;;ACVgB,SAAA,SAAS,CAAC,OAAe,EAAE,OAAgB,EAAA;IACzD,OAAO,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,OAAO,EAAE,OAAQ,CAAC,CAAC,CAAC;AAC/C;;;;;"}

package/dist/_chunk/union-CdQeDK.js

@@ -0,0 +1,13 @@
+'use strict';
+
+function uniq(arr) {
+    return Array.from(new Set(arr));
+}
+
+function union(arr1, arr2) {
+    return uniq(arr1.concat(arr2));
+}
+
+exports.union = union;
+exports.uniq = uniq;
+//# sourceMappingURL=union-CdQeDK.js.map

package/dist/_chunk/union-CdQeDK.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"union-CdQeDK.js","sources":["../../src/array/uniq.ts","../../src/array/union.ts"],"sourcesContent":["/**\n * Creates a duplicate-free version of an array.\n *\n * This function takes an array and returns a new array containing only the unique values\n * from the original array, preserving the order of first occurrence.\n *\n * @template T - The type of elements in the array.\n * @param {T[]} arr - The array to process.\n * @returns {T[]} A new array with only unique values from the original array.\n *\n * @example\n * const array = [1, 2, 2, 3, 4, 4, 5];\n * const result = uniq(array);\n * // result will be [1, 2, 3, 4, 5]\n */\nexport function uniq<T>(arr: readonly T[]): T[] {\n  return Array.from(new Set(arr));\n}\n","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"],"names":[],"mappings":";;AAeM,SAAU,IAAI,CAAI,GAAiB,EAAA;IACvC,OAAO,KAAK,CAAC,IAAI,CAAC,IAAI,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC;AAClC;;ACEgB,SAAA,KAAK,CAAI,IAAkB,EAAE,IAAkB,EAAA;IAC7D,OAAO,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC;AACjC;;;;;"}

package/dist/array/chunk.mjs

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

package/dist/array/chunk.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}
+{"version":3,"file":"chunk.mjs","sources":["../../src/array/chunk.ts"],"sourcesContent":["/**\n * Splits an array into smaller arrays of a specified length.\n *\n * This function takes an input array and divides it into multiple smaller arrays,\n * each of a specified length. If the input array cannot be evenly divided,\n * the final sub-array will contain the remaining elements.\n *\n * @template T The type of elements in the array.\n * @param {T[]} arr - The array to be chunked into smaller arrays.\n * @param {number} size - The size of each smaller array. Must be a positive integer.\n * @returns {T[][]} A two-dimensional array where each sub-array has a maximum length of `size`.\n * @throws {Error} Throws an error if `size` is not a positive integer.\n *\n * @example\n * // Splits an array of numbers into sub-arrays of length 2\n * chunk([1, 2, 3, 4, 5], 2);\n * // Returns: [[1, 2], [3, 4], [5]]\n *\n * @example\n * // Splits an array of strings into sub-arrays of length 3\n * chunk(['a', 'b', 'c', 'd', 'e', 'f', 'g'], 3);\n * // Returns: [['a', 'b', 'c'], ['d', 'e', 'f'], ['g']]\n */\nexport function chunk<T>(arr: readonly T[], size: number): T[][] {\n  if (!Number.isInteger(size) || size <= 0) {\n    throw new Error('Size must be an integer greater than zero.');\n  }\n\n  const chunkLength = Math.ceil(arr.length / size);\n  const result: T[][] = Array(chunkLength);\n\n  for (let index = 0; index < chunkLength; index++) {\n    const start = index * size;\n    const end = start + size;\n\n    result[index] = arr.slice(start, end);\n  }\n\n  return result;\n}\n"],"names":[],"mappings":"AAuBgB,SAAA,KAAK,CAAI,GAAiB,EAAE,IAAY,EAAA;AACtD,IAAA,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,EAAE;AACxC,QAAA,MAAM,IAAI,KAAK,CAAC,4CAA4C,CAAC,CAAC;KAC/D;AAED,IAAA,MAAM,WAAW,GAAG,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;AACjD,IAAA,MAAM,MAAM,GAAU,KAAK,CAAC,WAAW,CAAC,CAAC;AAEzC,IAAA,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,WAAW,EAAE,KAAK,EAAE,EAAE;AAChD,QAAA,MAAM,KAAK,GAAG,KAAK,GAAG,IAAI,CAAC;AAC3B,QAAA,MAAM,GAAG,GAAG,KAAK,GAAG,IAAI,CAAC;AAEzB,QAAA,MAAM,CAAC,KAAK,CAAC,GAAG,GAAG,CAAC,KAAK,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;KACvC;AAED,IAAA,OAAO,MAAM,CAAC;AAChB;;;;"}

package/dist/array/compact.mjs

@@ -1,8 +1,12 @@
-import {
-  compact
-} from "../chunk-PJPGJ2O6.mjs";
-import "../chunk-J5LGTIGS.mjs";
-export {
-  compact
-};
-//# sourceMappingURL=compact.mjs.map
+function compact(arr) {
+    const result = [];
+    for (const item of arr) {
+        if (item) {
+            result.push(item);
+        }
+    }
+    return result;
+}
+
+export { compact };
+//# sourceMappingURL=compact.mjs.map

package/dist/array/compact.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}
+{"version":3,"file":"compact.mjs","sources":["../../src/array/compact.ts"],"sourcesContent":["type NotFalsey<T> = Exclude<T, false | null | 0 | '' | undefined>;\n\n/**\n * Removes falsey values (false, null, 0, '', undefined, NaN) from an array.\n *\n * @template T - The type of elements in the array.\n * @param {T[]} arr - The input array to remove falsey values.\n * @returns {Array<Exclude<T, false | null | 0 | '' | undefined>>} - A new array with all falsey values removed.\n *\n * @example\n * compact([0, 1, false, 2, '', 3, null, undefined, 4, NaN, 5]);\n * Returns: [1, 2, 3, 4, 5]\n */\nexport function compact<T>(arr: readonly T[]): Array<NotFalsey<T>> {\n  const result: Array<NotFalsey<T>> = [];\n\n  for (const item of arr) {\n    if (item) {\n      result.push(item as NotFalsey<T>);\n    }\n  }\n\n  return result;\n}\n"],"names":[],"mappings":"AAaM,SAAU,OAAO,CAAI,GAAiB,EAAA;IAC1C,MAAM,MAAM,GAAwB,EAAE,CAAC;AAEvC,IAAA,KAAK,MAAM,IAAI,IAAI,GAAG,EAAE;QACtB,IAAI,IAAI,EAAE;AACR,YAAA,MAAM,CAAC,IAAI,CAAC,IAAoB,CAAC,CAAC;SACnC;KACF;AAED,IAAA,OAAO,MAAM,CAAC;AAChB;;;;"}

package/dist/array/countBy.mjs

@@ -1,8 +1,11 @@
-import {
-  countBy
-} from "../chunk-Z7HWEOQX.mjs";
-import "../chunk-J5LGTIGS.mjs";
-export {
-  countBy
-};
-//# sourceMappingURL=countBy.mjs.map
+function countBy(arr, mapper) {
+    const result = {};
+    for (const item of arr) {
+        const key = mapper(item);
+        result[key] = (result[key] ?? 0) + 1;
+    }
+    return result;
+}
+
+export { countBy };
+//# sourceMappingURL=countBy.mjs.map

package/dist/array/countBy.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}
+{"version":3,"file":"countBy.mjs","sources":["../../src/array/countBy.ts"],"sourcesContent":["/**\n * Count the occurrences of each item in an array\n * based on a transformation function.\n *\n * This function takes an array and a transformation function\n * that converts each item in the array to a string. It then\n * counts the occurrences of each transformed item and returns\n * an object with the transformed items as keys and the counts\n * as values.\n *\n * @template T - The type of the items in the input array.\n *\n * @param {T[]} arr - The input array to count occurrences.\n * @param {(item: T) => string} mapper - The transformation function that maps each item to a string key.\n * @returns {Record<string, number>} An object containing the transformed items as keys and the\n * counts as values.\n */\nexport function countBy<T>(arr: T[], mapper: (item: T) => string): Record<string, number> {\n  const result: Record<string, number> = {};\n  \n  for (const item of arr) {\n    const key = mapper(item);\n    \n    result[key] = (result[key] ?? 0) + 1;\n  }\n  \n  return result;\n}\n"],"names":[],"mappings":"AAiBgB,SAAA,OAAO,CAAI,GAAQ,EAAE,MAA2B,EAAA;IAC9D,MAAM,MAAM,GAA2B,EAAE,CAAC;AAE1C,IAAA,KAAK,MAAM,IAAI,IAAI,GAAG,EAAE;AACtB,QAAA,MAAM,GAAG,GAAG,MAAM,CAAC,IAAI,CAAC,CAAC;AAEzB,QAAA,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;KACtC;AAED,IAAA,OAAO,MAAM,CAAC;AAChB;;;;"}

package/dist/array/difference.mjs

@@ -1,8 +1,7 @@
-import {
-  difference
-} from "../chunk-JPUKH67K.mjs";
-import "../chunk-J5LGTIGS.mjs";
-export {
-  difference
-};
-//# sourceMappingURL=difference.mjs.map
+function difference(firstArr, secondArr) {
+    const secondSet = new Set(secondArr);
+    return firstArr.filter(item => !secondSet.has(item));
+}
+
+export { difference };
+//# sourceMappingURL=difference.mjs.map

package/dist/array/difference.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}
+{"version":3,"file":"difference.mjs","sources":["../../src/array/difference.ts"],"sourcesContent":["/**\n * Computes the difference between two arrays.\n *\n * This function takes two arrays and returns a new array containing the elements\n * that are present in the first array but not in the second array. It effectively\n * filters out any elements from the first array that also appear in the second array.\n *\n * @template T\n * @param {T[]} firstArr - The array from which to derive the difference. This is the primary array\n * from which elements will be compared and filtered.\n * @param {T[]} secondArr - The array containing elements to be excluded from the first array.\n * Each element in this array will be checked against the first array, and if a match is found,\n * that element will be excluded from the result.\n * @returns {T[]} A new array containing the elements that are present in the first array but not\n * in the second array.\n *\n * @example\n * const array1 = [1, 2, 3, 4, 5];\n * const array2 = [2, 4];\n * const result = difference(array1, array2);\n * // result will be [1, 3, 5] since 2 and 4 are in both arrays and are excluded from the result.\n */\nexport function difference<T>(firstArr: readonly T[], secondArr: readonly T[]): T[] {\n  const secondSet = new Set(secondArr);\n\n  return firstArr.filter(item => !secondSet.has(item));\n}\n"],"names":[],"mappings":"AAsBgB,SAAA,UAAU,CAAI,QAAsB,EAAE,SAAuB,EAAA;AAC3E,IAAA,MAAM,SAAS,GAAG,IAAI,GAAG,CAAC,SAAS,CAAC,CAAC;AAErC,IAAA,OAAO,QAAQ,CAAC,MAAM,CAAC,IAAI,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC;AACvD;;;;"}

package/dist/array/differenceBy.mjs

@@ -1,8 +1,9 @@
-import {
-  differenceBy
-} from "../chunk-LVWX5B43.mjs";
-import "../chunk-J5LGTIGS.mjs";
-export {
-  differenceBy
-};
-//# sourceMappingURL=differenceBy.mjs.map
+function differenceBy(firstArr, secondArr, mapper) {
+    const mappedSecondSet = new Set(secondArr.map(item => mapper(item)));
+    return firstArr.filter(item => {
+        return !mappedSecondSet.has(mapper(item));
+    });
+}
+
+export { differenceBy };
+//# sourceMappingURL=differenceBy.mjs.map

package/dist/array/differenceBy.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}
+{"version":3,"file":"differenceBy.mjs","sources":["../../src/array/differenceBy.ts"],"sourcesContent":["/**\n * Computes the difference between two arrays after mapping their elements through a provided function.\n *\n * This function takes two arrays and a mapper function. It returns a new array containing the elements\n * that are present in the first array but not in the second array, based on the identity calculated\n * by the mapper function.\n *\n * Essentially, it filters out any elements from the first array that, when\n * mapped, match an element in the mapped version of the second array.\n *\n * @template T, U\n * @param {T[]} firstArr - The primary array from which to derive the difference.\n * @param {T[]} secondArr - The array containing elements to be excluded from the first array.\n * @param {(value: T) => U} mapper - The function to map the elements of both arrays. This function\n * is applied to each element in both arrays, and the comparison is made based on the mapped values.\n * @returns {T[]} A new array containing the elements from the first array that do not have a corresponding\n * mapped identity 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 = differenceBy(array1, array2, mapper);\n * // result will be [{ id: 1 }, { id: 3 }] since the elements with id 2 are in both arrays and are excluded from the result.\n */\nexport function differenceBy<T, U>(firstArr: readonly T[], secondArr: readonly T[], mapper: (value: T) => U): T[] {\n  const mappedSecondSet = new Set(secondArr.map(item => mapper(item)));\n\n  return firstArr.filter(item => {\n    return !mappedSecondSet.has(mapper(item));\n  });\n}\n"],"names":[],"mappings":"SAyBgB,YAAY,CAAO,QAAsB,EAAE,SAAuB,EAAE,MAAuB,EAAA;AACzG,IAAA,MAAM,eAAe,GAAG,IAAI,GAAG,CAAC,SAAS,CAAC,GAAG,CAAC,IAAI,IAAI,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;AAErE,IAAA,OAAO,QAAQ,CAAC,MAAM,CAAC,IAAI,IAAG;QAC5B,OAAO,CAAC,eAAe,CAAC,GAAG,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC;AAC5C,KAAC,CAAC,CAAC;AACL;;;;"}

package/dist/array/differenceWith.mjs

@@ -1,8 +1,10 @@
-import {
-  differenceWith
-} from "../chunk-6NVQAHXP.mjs";
-import "../chunk-J5LGTIGS.mjs";
-export {
-  differenceWith
-};
-//# sourceMappingURL=differenceWith.mjs.map
+function differenceWith(firstArr, secondArr, areItemsEqual) {
+    return firstArr.filter(firstItem => {
+        return secondArr.every(secondItem => {
+            return !areItemsEqual(firstItem, secondItem);
+        });
+    });
+}
+
+export { differenceWith };
+//# sourceMappingURL=differenceWith.mjs.map

package/dist/array/differenceWith.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}
+{"version":3,"file":"differenceWith.mjs","sources":["../../src/array/differenceWith.ts"],"sourcesContent":["/**\n * Computes the difference between two arrays based on a custom equality function.\n *\n * This function takes two arrays and a custom comparison function. It returns a new array containing\n * the elements that are present in the first array but not in the second array. The comparison to determine\n * if elements are equal is made using the provided custom function.\n *\n * @template T\n * @param {T[]} firstArr - The array from which to get the difference.\n * @param {T[]} secondArr - The array containing elements to exclude from the first array.\n * @param {(x: T, y: T) => boolean} areItemsEqual - A function to determine if two items are equal.\n * @returns {T[]} A new array containing the elements from the first array that do not match any elements in the second array\n * 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 = differenceWith(array1, array2, areItemsEqual);\n * // result will be [{ id: 1 }, { id: 3 }] since the elements with id 2 are considered equal and are excluded from the result.\n */\nexport function differenceWith<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.every(secondItem => {\n      return !areItemsEqual(firstItem, secondItem);\n    });\n  });\n}\n"],"names":[],"mappings":"SAqBgB,cAAc,CAC5B,QAAsB,EACtB,SAAuB,EACvB,aAAsC,EAAA;AAEtC,IAAA,OAAO,QAAQ,CAAC,MAAM,CAAC,SAAS,IAAG;AACjC,QAAA,OAAO,SAAS,CAAC,KAAK,CAAC,UAAU,IAAG;AAClC,YAAA,OAAO,CAAC,aAAa,CAAC,SAAS,EAAE,UAAU,CAAC,CAAC;AAC/C,SAAC,CAAC,CAAC;AACL,KAAC,CAAC,CAAC;AACL;;;;"}

package/dist/array/drop.mjs

@@ -1,8 +1,7 @@
-import {
-  drop
-} from "../chunk-3EZAFZG3.mjs";
-import "../chunk-J5LGTIGS.mjs";
-export {
-  drop
-};
-//# sourceMappingURL=drop.mjs.map
+function drop(arr, itemsCount) {
+    itemsCount = Math.max(itemsCount, 0);
+    return arr.slice(itemsCount);
+}
+
+export { drop };
+//# sourceMappingURL=drop.mjs.map

package/dist/array/drop.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}
+{"version":3,"file":"drop.mjs","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  itemsCount = Math.max(itemsCount, 0);\n\n  return arr.slice(itemsCount);\n}\n"],"names":[],"mappings":"AAgBgB,SAAA,IAAI,CAAI,GAAiB,EAAE,UAAkB,EAAA;IAC3D,UAAU,GAAG,IAAI,CAAC,GAAG,CAAC,UAAU,EAAE,CAAC,CAAC,CAAC;AAErC,IAAA,OAAO,GAAG,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC;AAC/B;;;;"}

package/dist/array/dropRight.mjs

@@ -1,8 +1,10 @@
-import {
-  dropRight
-} from "../chunk-OXZCMC5I.mjs";
-import "../chunk-J5LGTIGS.mjs";
-export {
-  dropRight
-};
-//# sourceMappingURL=dropRight.mjs.map
+function dropRight(arr, itemsCount) {
+    itemsCount = Math.min(-itemsCount, 0);
+    if (itemsCount === 0) {
+        return arr.slice();
+    }
+    return arr.slice(0, itemsCount);
+}
+
+export { dropRight };
+//# sourceMappingURL=dropRight.mjs.map

package/dist/array/dropRight.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}
+{"version":3,"file":"dropRight.mjs","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 * @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 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: readonly T[], itemsCount: number): T[] {\n  itemsCount = Math.min(-itemsCount, 0);\n\n  if (itemsCount === 0) {\n    return arr.slice();\n  }\n\n  return arr.slice(0, itemsCount);\n}\n"],"names":[],"mappings":"AAgBgB,SAAA,SAAS,CAAI,GAAiB,EAAE,UAAkB,EAAA;IAChE,UAAU,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,UAAU,EAAE,CAAC,CAAC,CAAC;AAEtC,IAAA,IAAI,UAAU,KAAK,CAAC,EAAE;AACpB,QAAA,OAAO,GAAG,CAAC,KAAK,EAAE,CAAC;KACpB;IAED,OAAO,GAAG,CAAC,KAAK,CAAC,CAAC,EAAE,UAAU,CAAC,CAAC;AAClC;;;;"}

package/dist/array/dropRightWhile.mjs

@@ -1,8 +1,11 @@
-import {
-  dropRightWhile
-} from "../chunk-M7SBBYV2.mjs";
-import "../chunk-J5LGTIGS.mjs";
-export {
-  dropRightWhile
-};
-//# sourceMappingURL=dropRightWhile.mjs.map
+function dropRightWhile(arr, canContinueDropping) {
+    for (let i = arr.length - 1; i >= 0; i--) {
+        if (!canContinueDropping(arr[i])) {
+            return arr.slice(0, i + 1);
+        }
+    }
+    return [];
+}
+
+export { dropRightWhile };
+//# sourceMappingURL=dropRightWhile.mjs.map

package/dist/array/dropRightWhile.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}
+{"version":3,"file":"dropRightWhile.mjs","sources":["../../src/array/dropRightWhile.ts"],"sourcesContent":["/**\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 * @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 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: readonly T[], canContinueDropping: (item: T) => boolean): T[] {\n  for (let i = arr.length - 1; i >= 0; i--) {\n    if (!canContinueDropping(arr[i])) {\n      return arr.slice(0, i + 1);\n    }\n  }\n\n  return [];\n}\n"],"names":[],"mappings":"AAkBgB,SAAA,cAAc,CAAI,GAAiB,EAAE,mBAAyC,EAAA;AAC5F,IAAA,KAAK,IAAI,CAAC,GAAG,GAAG,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,EAAE;QACxC,IAAI,CAAC,mBAAmB,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE;YAChC,OAAO,GAAG,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;SAC5B;KACF;AAED,IAAA,OAAO,EAAE,CAAC;AACZ;;;;"}

package/dist/array/dropWhile.mjs

@@ -1,8 +1,10 @@
-import {
-  dropWhile
-} from "../chunk-LJ2C6MVP.mjs";
-import "../chunk-J5LGTIGS.mjs";
-export {
-  dropWhile
-};
-//# sourceMappingURL=dropWhile.mjs.map
+function dropWhile(arr, canContinueDropping) {
+    const dropEndIndex = arr.findIndex(item => !canContinueDropping(item));
+    if (dropEndIndex === -1) {
+        return [];
+    }
+    return arr.slice(dropEndIndex);
+}
+
+export { dropWhile };
+//# sourceMappingURL=dropWhile.mjs.map

package/dist/array/dropWhile.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}
+{"version":3,"file":"dropWhile.mjs","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"],"names":[],"mappings":"AAkBgB,SAAA,SAAS,CAAI,GAAiB,EAAE,mBAAyC,EAAA;AACvF,IAAA,MAAM,YAAY,GAAG,GAAG,CAAC,SAAS,CAAC,IAAI,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,CAAC,CAAC;AACvE,IAAA,IAAI,YAAY,KAAK,CAAC,CAAC,EAAE;AACvB,QAAA,OAAO,EAAE,CAAC;KACX;AAED,IAAA,OAAO,GAAG,CAAC,KAAK,CAAC,YAAY,CAAC,CAAC;AACjC;;;;"}

package/dist/array/fill.mjs

@@ -1,8 +1,12 @@
-import {
-  fill
-} from "../chunk-GTFDDKZ2.mjs";
-import "../chunk-J5LGTIGS.mjs";
-export {
-  fill
-};
-//# sourceMappingURL=fill.mjs.map
+function fill(array, value, start = 0, end = array.length) {
+    const length = array.length;
+    const finalStart = Math.max(start >= 0 ? start : length + start, 0);
+    const finalEnd = Math.min(end >= 0 ? end : length + end, length);
+    for (let i = finalStart; i < finalEnd; i++) {
+        array[i] = value;
+    }
+    return array;
+}
+
+export { fill };
+//# sourceMappingURL=fill.mjs.map

package/dist/array/fill.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}
+{"version":3,"file":"fill.mjs","sources":["../../src/array/fill.ts"],"sourcesContent":["/**\n * Fills elements of an array with a specified value from the start position up to, but not including, the end position.\n *\n * This function mutates the original array and replaces its elements with the provided value, starting from the specified\n * start index up to the end index (non-inclusive). If the start or end indices are not provided, it defaults to filling the\n * entire array.\n *\n * @template T, U\n * @param {Array<T | U>} array - The array to fill.\n * @param {U} value - The value to fill the array with.\n * @param {number} [start=0] - The start position. Defaults to 0.\n * @param {number} [end=arr.length] - The end position. Defaults to the array's length.\n * @returns {Array<T | U>} The array with the filled values.\n *\n * @example\n * const array = [1, 2, 3];\n * const result = fill(array, 'a');\n * // => ['a', 'a', 'a']\n *\n * const result = fill(Array(3), 2);\n * // => [2, 2, 2]\n *\n * const result = fill([4, 6, 8, 10], '*', 1, 3);\n * // => [4, '*', '*', 10]\n *\n * const result = fill(array, '*', -2, -1);\n * // => [1, '*', 3]\n */\nexport function fill<T>(array: unknown[], value: T): T[];\nexport function fill<T, U>(array: Array<T | U>, value: U, start: number): Array<T | U>;\nexport function fill<T, U>(array: Array<T | U>, value: U, start: number, end: number): Array<T | U>;\nexport function fill<T, U>(array: Array<T | U>, value: U, start = 0, end = array.length): Array<T | U> {\n  const length = array.length;\n  const finalStart = Math.max(start >= 0 ? start : length + start, 0);\n  const finalEnd = Math.min(end >= 0 ? end : length + end, length);\n\n  for (let i = finalStart; i < finalEnd; i++) {\n    array[i] = value;\n  }\n\n  return array;\n}\n"],"names":[],"mappings":"AA+BgB,SAAA,IAAI,CAAO,KAAmB,EAAE,KAAQ,EAAE,KAAK,GAAG,CAAC,EAAE,GAAG,GAAG,KAAK,CAAC,MAAM,EAAA;AACrF,IAAA,MAAM,MAAM,GAAG,KAAK,CAAC,MAAM,CAAC;IAC5B,MAAM,UAAU,GAAG,IAAI,CAAC,GAAG,CAAC,KAAK,IAAI,CAAC,GAAG,KAAK,GAAG,MAAM,GAAG,KAAK,EAAE,CAAC,CAAC,CAAC;IACpE,MAAM,QAAQ,GAAG,IAAI,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC,GAAG,GAAG,GAAG,MAAM,GAAG,GAAG,EAAE,MAAM,CAAC,CAAC;AAEjE,IAAA,KAAK,IAAI,CAAC,GAAG,UAAU,EAAE,CAAC,GAAG,QAAQ,EAAE,CAAC,EAAE,EAAE;AAC1C,QAAA,KAAK,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC;KAClB;AAED,IAAA,OAAO,KAAK,CAAC;AACf;;;;"}

package/dist/array/flatMap.mjs

@@ -1,9 +1,8 @@
-import {
-  flatMap
-} from "../chunk-UY76KTPE.mjs";
-import "../chunk-33MSBDC6.mjs";
-import "../chunk-J5LGTIGS.mjs";
-export {
-  flatMap
-};
-//# sourceMappingURL=flatMap.mjs.map
+import { flatten } from './flatten.mjs';
+
+function flatMap(arr, iteratee, depth = 1) {
+    return flatten(arr.map(item => iteratee(item)), depth);
+}
+
+export { flatMap };
+//# sourceMappingURL=flatMap.mjs.map

package/dist/array/flatMap.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}
+{"version":3,"file":"flatMap.mjs","sources":["../../src/array/flatMap.ts"],"sourcesContent":["import { flatten } from './flatten.ts';\n\n/**\n * Maps each element in the array using the iteratee function and flattens the result up to the specified depth.\n *\n * @template T - The type of elements within the array.\n * @template U - The type of elements within the returned array from the iteratee function.\n * @template D - The depth to which the array should be flattened.\n * @param {T[]} arr - The array to flatten.\n * @param {(item: T) => U} iteratee - The function that produces the new array elements.\n * @param {D} depth - The depth level specifying how deep a nested array structure should be flattened. Defaults to 1.\n * @returns {Array<FlatArray<U[], D>>} The new array with the mapped and flattened elements.\n *\n * @example\n * const arr = [1, 2, 3];\n *\n * flatMap(arr, (item: number) => [item, item]);\n * // [1, 1, 2, 2, 3, 3]\n *\n * flatMap(arr, (item: number) => [[item, item]], 2);\n * // [1, 1, 2, 2, 3, 3]\n */\nexport function flatMap<T, U, D extends number>(\n  arr: readonly T[],\n  iteratee: (item: T) => U,\n  depth = 1 as D\n): Array<FlatArray<U[], D>> {\n  return flatten(arr.map(item => iteratee(item)), depth);\n}\n"],"names":[],"mappings":";;AAsBM,SAAU,OAAO,CACrB,GAAiB,EACjB,QAAwB,EACxB,QAAQ,CAAM,EAAA;AAEd,IAAA,OAAO,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,IAAI,QAAQ,CAAC,IAAI,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC;AACzD;;;;"}

package/dist/array/flatten.mjs

@@ -1,8 +1,19 @@
-import {
-  flatten
-} from "../chunk-33MSBDC6.mjs";
-import "../chunk-J5LGTIGS.mjs";
-export {
-  flatten
-};
-//# sourceMappingURL=flatten.mjs.map
+function flatten(arr, depth = 1) {
+    const result = [];
+    const flooredDepth = Math.floor(depth);
+    const recursive = (arr, currentDepth) => {
+        for (const item of arr) {
+            if (Array.isArray(item) && currentDepth < flooredDepth) {
+                recursive(item, currentDepth + 1);
+            }
+            else {
+                result.push(item);
+            }
+        }
+    };
+    recursive(arr, 0);
+    return result;
+}
+
+export { flatten };
+//# sourceMappingURL=flatten.mjs.map

package/dist/array/flatten.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}
+{"version":3,"file":"flatten.mjs","sources":["../../src/array/flatten.ts"],"sourcesContent":["/**\n * Flattens an array up to the specified depth.\n *\n * @template T - The type of elements within the array.\n * @template D - The depth to which the array should be flattened.\n * @param {T[]} arr - The array to flatten.\n * @param {D} depth - The depth level specifying how deep a nested array structure should be flattened. Defaults to 1.\n * @returns {Array<FlatArray<T[], D>>} A new array that has been flattened.\n *\n * @example\n * const arr = flatten([1, [2, 3], [4, [5, 6]]], 1);\n * // Returns: [1, 2, 3, 4, [5, 6]]\n *\n * const arr = flatten([1, [2, 3], [4, [5, 6]]], 2);\n * // Returns: [1, 2, 3, 4, 5, 6]\n */\nexport function flatten<T, D extends number = 1>(arr: readonly T[], depth = 1 as D): Array<FlatArray<T[], D>> {\n  const result: Array<FlatArray<T[], D>> = [];\n  const flooredDepth = Math.floor(depth);\n\n  const recursive = (arr: readonly T[], currentDepth: number) => {\n    for (const item of arr) {\n      if (Array.isArray(item) && currentDepth < flooredDepth) {\n        recursive(item, currentDepth + 1);\n      } else {\n        result.push(item as FlatArray<T[], D>);\n      }\n    }\n  };\n\n  recursive(arr, 0);\n  return result;\n}\n"],"names":[],"mappings":"SAgBgB,OAAO,CAA0B,GAAiB,EAAE,QAAQ,CAAM,EAAA;IAChF,MAAM,MAAM,GAA6B,EAAE,CAAC;IAC5C,MAAM,YAAY,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;AAEvC,IAAA,MAAM,SAAS,GAAG,CAAC,GAAiB,EAAE,YAAoB,KAAI;AAC5D,QAAA,KAAK,MAAM,IAAI,IAAI,GAAG,EAAE;YACtB,IAAI,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,YAAY,GAAG,YAAY,EAAE;AACtD,gBAAA,SAAS,CAAC,IAAI,EAAE,YAAY,GAAG,CAAC,CAAC,CAAC;aACnC;iBAAM;AACL,gBAAA,MAAM,CAAC,IAAI,CAAC,IAAyB,CAAC,CAAC;aACxC;SACF;AACH,KAAC,CAAC;AAEF,IAAA,SAAS,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC;AAClB,IAAA,OAAO,MAAM,CAAC;AAChB;;;;"}

package/dist/array/flattenDeep.mjs

@@ -1,9 +1,8 @@
-import {
-  flattenDeep
-} from "../chunk-ML727RRJ.mjs";
-import "../chunk-33MSBDC6.mjs";
-import "../chunk-J5LGTIGS.mjs";
-export {
-  flattenDeep
-};
-//# sourceMappingURL=flattenDeep.mjs.map
+import { flatten } from './flatten.mjs';
+
+function flattenDeep(arr) {
+    return flatten(arr, Infinity);
+}
+
+export { flattenDeep };
+//# sourceMappingURL=flattenDeep.mjs.map

package/dist/array/flattenDeep.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}
+{"version":3,"file":"flattenDeep.mjs","sources":["../../src/array/flattenDeep.ts"],"sourcesContent":["import { flatten } from './flatten.ts';\n\n/**\n * Utility type for recursively unpacking nested array types to extract the type of the innermost element\n *\n * @example\n * ExtractNestedArrayType<(number | (number | number[])[])[]>\n * // number\n *\n * ExtractNestedArrayType<(boolean | (string | number[])[])[]>\n * // string | number | boolean\n */\ntype ExtractNestedArrayType<T> = T extends ReadonlyArray<infer U> ? ExtractNestedArrayType<U> : T;\n\n/**\n * Flattens all depths of a nested array.\n *\n * @template T - The type of elements within the array.\n * @param {T[]} arr - The array to flatten.\n * @returns {Array<ExtractNestedArrayType<T>>} A new array that has been flattened.\n *\n * @example\n * const arr = flattenDeep([1, [2, [3]], [4, [5, 6]]]);\n * // Returns: [1, 2, 3, 4, 5, 6]\n */\nexport function flattenDeep<T>(arr: readonly T[]): Array<ExtractNestedArrayType<T>> {\n  return flatten(arr, Infinity) as Array<ExtractNestedArrayType<T>>;\n}\n"],"names":[],"mappings":";;AAyBM,SAAU,WAAW,CAAI,GAAiB,EAAA;AAC9C,IAAA,OAAO,OAAO,CAAC,GAAG,EAAE,QAAQ,CAAqC,CAAC;AACpE;;;;"}

package/dist/array/forEachRight.mjs

@@ -1,8 +1,9 @@
-import {
-  forEachRight
-} from "../chunk-IEA53J7P.mjs";
-import "../chunk-J5LGTIGS.mjs";
-export {
-  forEachRight
-};
-//# sourceMappingURL=forEachRight.mjs.map
+function forEachRight(arr, callback) {
+    for (let i = arr.length - 1; i >= 0; i--) {
+        const element = arr[i];
+        callback(element, i, arr);
+    }
+}
+
+export { forEachRight };
+//# sourceMappingURL=forEachRight.mjs.map

package/dist/array/forEachRight.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}
+{"version":3,"file":"forEachRight.mjs","sources":["../../src/array/forEachRight.ts"],"sourcesContent":["/**\n * Iterates over elements of 'arr' from right to left and invokes 'callback' for each element.\n * \n * @template T - The type of elements in the array.\n * @param {T[]} arr - The array to iterate over.\n * @param {(value: T, index: number, arr: T[]) => void} callback - The function invoked per iteration.\n * The callback function receives three arguments:\n *  - 'value': The current element being processed in the array.\n *  - 'index': The index of the current element being processed in the array.\n *  - 'arr': The array 'forEachRight' was called upon.\n * \n * @example\n * const array = [1, 2, 3];\n * const result: number[] = [];\n * \n * // Use the forEachRight function to iterate through the array and add each element to the result array.\n * forEachRight(array, (value) => {\n *  result.push(value);\n * })\n * \n * console.log(result) // Output: [3, 2, 1]\n */\n\nexport function forEachRight<T>(arr: T[], callback: (value: T, index: number, arr: T[]) => void): void {\n  for (let i = arr.length - 1; i >= 0; i--) {\n    const element = arr[i];\n    callback(element, i, arr);\n  }\n}\n"],"names":[],"mappings":"AAuBgB,SAAA,YAAY,CAAI,GAAQ,EAAE,QAAqD,EAAA;AAC7F,IAAA,KAAK,IAAI,CAAC,GAAG,GAAG,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,EAAE;AACxC,QAAA,MAAM,OAAO,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC;AACvB,QAAA,QAAQ,CAAC,OAAO,EAAE,CAAC,EAAE,GAAG,CAAC,CAAC;KAC3B;AACH;;;;"}

package/dist/array/groupBy.mjs

@@ -1,8 +1,14 @@
-import {
-  groupBy
-} from "../chunk-E6E4RZLN.mjs";
-import "../chunk-J5LGTIGS.mjs";
-export {
-  groupBy
-};
-//# sourceMappingURL=groupBy.mjs.map
+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=groupBy.mjs.map

package/dist/array/groupBy.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}
+{"version":3,"file":"groupBy.mjs","sources":["../../src/array/groupBy.ts"],"sourcesContent":["/**\n * Groups the elements of an array based on a provided key-generating function.\n *\n * This function takes an array and a function that generates a key from each element. It returns\n * an object where the keys are the generated keys and the values are arrays of elements that share\n * the same key.\n *\n * @template T - The type of elements in the array.\n * @template K - The type of keys.\n * @param {T[]} arr - The array to group.\n * @param {(item: T) => K} getKeyFromItem - A function that generates a key from an element.\n * @returns {Record<K, T[]>} An object where each key is associated with an array of elements that\n * share that key.\n *\n * @example\n * const array = [\n *   { category: 'fruit', name: 'apple' },\n *   { category: 'fruit', name: 'banana' },\n *   { category: 'vegetable', name: 'carrot' }\n * ];\n * const result = groupBy(array, item => item.category);\n * // result will be:\n * // {\n * //   fruit: [\n * //     { category: 'fruit', name: 'apple' },\n * //     { category: 'fruit', name: 'banana' }\n * //   ],\n * //   vegetable: [\n * //     { category: 'vegetable', name: 'carrot' }\n * //   ]\n * // }\n */\nexport function groupBy<T, K extends PropertyKey>(arr: readonly T[], getKeyFromItem: (item: T) => K): Record<K, T[]> {\n  const result = {} as Record<K, T[]>;\n\n  for (const item of arr) {\n    const key = getKeyFromItem(item);\n\n    if (result[key] == null) {\n      result[key] = [];\n    }\n\n    result[key].push(item);\n  }\n\n  return result;\n}\n"],"names":[],"mappings":"AAgCgB,SAAA,OAAO,CAA2B,GAAiB,EAAE,cAA8B,EAAA;IACjG,MAAM,MAAM,GAAG,EAAoB,CAAC;AAEpC,IAAA,KAAK,MAAM,IAAI,IAAI,GAAG,EAAE;AACtB,QAAA,MAAM,GAAG,GAAG,cAAc,CAAC,IAAI,CAAC,CAAC;AAEjC,QAAA,IAAI,MAAM,CAAC,GAAG,CAAC,IAAI,IAAI,EAAE;AACvB,YAAA,MAAM,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC;SAClB;QAED,MAAM,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;KACxB;AAED,IAAA,OAAO,MAAM,CAAC;AAChB;;;;"}