avo-cli 4.2.0.beta.4 → 4.2.0.beta.5

data/payload/node_modules/es-toolkit/dist/array/flatten.d.mts

@@ -0,0 +1,20 @@
+//#region src/array/flatten.d.ts
+/**
+ * Flattens an array up to the specified depth.
+ *
+ * @template T - The type of elements within the array.
+ * @template D - The depth to which the array should be flattened.
+ * @param arr - The array to flatten.
+ * @param depth - The depth level specifying how deep a nested array structure should be flattened. Defaults to 1.
+ * @returns A new array that has been flattened.
+ *
+ * @example
+ * const arr = flatten([1, [2, 3], [4, [5, 6]]], 1);
+ * // Returns: [1, 2, 3, 4, [5, 6]]
+ *
+ * const arr = flatten([1, [2, 3], [4, [5, 6]]], 2);
+ * // Returns: [1, 2, 3, 4, 5, 6]
+ */
+declare function flatten<T, D extends number = 1>(arr: readonly T[], depth?: D): Array<FlatArray<T[], D>>;
+//#endregion
+export { flatten };

data/payload/node_modules/es-toolkit/dist/array/flatten.d.ts

@@ -0,0 +1,20 @@
+//#region src/array/flatten.d.ts
+/**
+ * Flattens an array up to the specified depth.
+ *
+ * @template T - The type of elements within the array.
+ * @template D - The depth to which the array should be flattened.
+ * @param arr - The array to flatten.
+ * @param depth - The depth level specifying how deep a nested array structure should be flattened. Defaults to 1.
+ * @returns A new array that has been flattened.
+ *
+ * @example
+ * const arr = flatten([1, [2, 3], [4, [5, 6]]], 1);
+ * // Returns: [1, 2, 3, 4, [5, 6]]
+ *
+ * const arr = flatten([1, [2, 3], [4, [5, 6]]], 2);
+ * // Returns: [1, 2, 3, 4, 5, 6]
+ */
+declare function flatten<T, D extends number = 1>(arr: readonly T[], depth?: D): Array<FlatArray<T[], D>>;
+//#endregion
+export { flatten };

data/payload/node_modules/es-toolkit/dist/array/flatten.js

@@ -0,0 +1,32 @@
+//#region src/array/flatten.ts
+/**
+* Flattens an array up to the specified depth.
+*
+* @template T - The type of elements within the array.
+* @template D - The depth to which the array should be flattened.
+* @param arr - The array to flatten.
+* @param depth - The depth level specifying how deep a nested array structure should be flattened. Defaults to 1.
+* @returns A new array that has been flattened.
+*
+* @example
+* const arr = flatten([1, [2, 3], [4, [5, 6]]], 1);
+* // Returns: [1, 2, 3, 4, [5, 6]]
+*
+* const arr = flatten([1, [2, 3], [4, [5, 6]]], 2);
+* // Returns: [1, 2, 3, 4, 5, 6]
+*/
+function flatten(arr, depth = 1) {
+	const result = [];
+	const flooredDepth = Math.floor(depth);
+	const recursive = (arr, currentDepth) => {
+		for (let i = 0; i < arr.length; i++) {
+			const item = arr[i];
+			if (Array.isArray(item) && currentDepth < flooredDepth) recursive(item, currentDepth + 1);
+			else result.push(item);
+		}
+	};
+	recursive(arr, 0);
+	return result;
+}
+//#endregion
+exports.flatten = flatten;

data/payload/node_modules/es-toolkit/dist/array/flatten.mjs

@@ -0,0 +1,32 @@
+//#region src/array/flatten.ts
+/**
+* Flattens an array up to the specified depth.
+*
+* @template T - The type of elements within the array.
+* @template D - The depth to which the array should be flattened.
+* @param arr - The array to flatten.
+* @param depth - The depth level specifying how deep a nested array structure should be flattened. Defaults to 1.
+* @returns A new array that has been flattened.
+*
+* @example
+* const arr = flatten([1, [2, 3], [4, [5, 6]]], 1);
+* // Returns: [1, 2, 3, 4, [5, 6]]
+*
+* const arr = flatten([1, [2, 3], [4, [5, 6]]], 2);
+* // Returns: [1, 2, 3, 4, 5, 6]
+*/
+function flatten(arr, depth = 1) {
+	const result = [];
+	const flooredDepth = Math.floor(depth);
+	const recursive = (arr, currentDepth) => {
+		for (let i = 0; i < arr.length; i++) {
+			const item = arr[i];
+			if (Array.isArray(item) && currentDepth < flooredDepth) recursive(item, currentDepth + 1);
+			else result.push(item);
+		}
+	};
+	recursive(arr, 0);
+	return result;
+}
+//#endregion
+export { flatten };

data/payload/node_modules/es-toolkit/dist/array/flattenDeep.d.mts

@@ -0,0 +1,26 @@
+//#region src/array/flattenDeep.d.ts
+/**
+ * Utility type for recursively unpacking nested array types to extract the type of the innermost element
+ *
+ * @example
+ * ExtractNestedArrayType<(number | (number | number[])[])[]>
+ * // number
+ *
+ * ExtractNestedArrayType<(boolean | (string | number[])[])[]>
+ * // string | number | boolean
+ */
+type ExtractNestedArrayType<T> = T extends ReadonlyArray<infer U> ? ExtractNestedArrayType<U> : T;
+/**
+ * Flattens all depths of a nested array.
+ *
+ * @template T - The type of elements within the array.
+ * @param arr - The array to flatten.
+ * @returns A new array that has been flattened.
+ *
+ * @example
+ * const arr = flattenDeep([1, [2, [3]], [4, [5, 6]]]);
+ * // Returns: [1, 2, 3, 4, 5, 6]
+ */
+declare function flattenDeep<T>(arr: readonly T[]): Array<ExtractNestedArrayType<T>>;
+//#endregion
+export { ExtractNestedArrayType, flattenDeep };

data/payload/node_modules/es-toolkit/dist/array/flattenDeep.d.ts

@@ -0,0 +1,26 @@
+//#region src/array/flattenDeep.d.ts
+/**
+ * Utility type for recursively unpacking nested array types to extract the type of the innermost element
+ *
+ * @example
+ * ExtractNestedArrayType<(number | (number | number[])[])[]>
+ * // number
+ *
+ * ExtractNestedArrayType<(boolean | (string | number[])[])[]>
+ * // string | number | boolean
+ */
+type ExtractNestedArrayType<T> = T extends ReadonlyArray<infer U> ? ExtractNestedArrayType<U> : T;
+/**
+ * Flattens all depths of a nested array.
+ *
+ * @template T - The type of elements within the array.
+ * @param arr - The array to flatten.
+ * @returns A new array that has been flattened.
+ *
+ * @example
+ * const arr = flattenDeep([1, [2, [3]], [4, [5, 6]]]);
+ * // Returns: [1, 2, 3, 4, 5, 6]
+ */
+declare function flattenDeep<T>(arr: readonly T[]): Array<ExtractNestedArrayType<T>>;
+//#endregion
+export { ExtractNestedArrayType, flattenDeep };

data/payload/node_modules/es-toolkit/dist/array/flattenDeep.js

@@ -0,0 +1,18 @@
+const require_flatten = require("./flatten.js");
+//#region src/array/flattenDeep.ts
+/**
+* Flattens all depths of a nested array.
+*
+* @template T - The type of elements within the array.
+* @param arr - The array to flatten.
+* @returns A new array that has been flattened.
+*
+* @example
+* const arr = flattenDeep([1, [2, [3]], [4, [5, 6]]]);
+* // Returns: [1, 2, 3, 4, 5, 6]
+*/
+function flattenDeep(arr) {
+	return require_flatten.flatten(arr, Infinity);
+}
+//#endregion
+exports.flattenDeep = flattenDeep;

data/payload/node_modules/es-toolkit/dist/array/flattenDeep.mjs

@@ -0,0 +1,18 @@
+import { flatten } from "./flatten.mjs";
+//#region src/array/flattenDeep.ts
+/**
+* Flattens all depths of a nested array.
+*
+* @template T - The type of elements within the array.
+* @param arr - The array to flatten.
+* @returns A new array that has been flattened.
+*
+* @example
+* const arr = flattenDeep([1, [2, [3]], [4, [5, 6]]]);
+* // Returns: [1, 2, 3, 4, 5, 6]
+*/
+function flattenDeep(arr) {
+	return flatten(arr, Infinity);
+}
+//#endregion
+export { flattenDeep };

data/payload/node_modules/es-toolkit/dist/array/forEachAsync.d.mts

@@ -0,0 +1,36 @@
+//#region src/array/forEachAsync.d.ts
+interface ForEachAsyncOptions {
+  concurrency?: number;
+}
+/**
+ * Executes an async callback function for each element in an array.
+ *
+ * Unlike the native `forEach`, this function returns a promise that resolves
+ * when all async operations complete. It supports optional concurrency limiting.
+ *
+ * @template T - The type of elements in the array.
+ * @param array The array to iterate over.
+ * @param callback An async function to execute for each element.
+ * @param [options] Optional configuration object.
+ * @param [options.concurrency] Maximum number of concurrent async operations. If not specified, all operations run concurrently.
+ * @returns A promise that resolves when all operations complete.
+ * @example
+ * const users = [{ id: 1 }, { id: 2 }, { id: 3 }];
+ * await forEachAsync(users, async (user) => {
+ *   await updateUser(user.id);
+ * });
+ * // All users have been updated
+ *
+ * @example
+ * // With concurrency limit
+ * const items = [1, 2, 3, 4, 5];
+ * await forEachAsync(
+ *   items,
+ *   async (item) => await processItem(item),
+ *   { concurrency: 2 }
+ * );
+ * // Processes at most 2 items concurrently
+ */
+declare function forEachAsync<T>(array: readonly T[], callback: (item: T, index: number, array: readonly T[]) => Promise<void>, options?: ForEachAsyncOptions): Promise<void>;
+//#endregion
+export { forEachAsync };

data/payload/node_modules/es-toolkit/dist/array/forEachAsync.d.ts

@@ -0,0 +1,36 @@
+//#region src/array/forEachAsync.d.ts
+interface ForEachAsyncOptions {
+  concurrency?: number;
+}
+/**
+ * Executes an async callback function for each element in an array.
+ *
+ * Unlike the native `forEach`, this function returns a promise that resolves
+ * when all async operations complete. It supports optional concurrency limiting.
+ *
+ * @template T - The type of elements in the array.
+ * @param array The array to iterate over.
+ * @param callback An async function to execute for each element.
+ * @param [options] Optional configuration object.
+ * @param [options.concurrency] Maximum number of concurrent async operations. If not specified, all operations run concurrently.
+ * @returns A promise that resolves when all operations complete.
+ * @example
+ * const users = [{ id: 1 }, { id: 2 }, { id: 3 }];
+ * await forEachAsync(users, async (user) => {
+ *   await updateUser(user.id);
+ * });
+ * // All users have been updated
+ *
+ * @example
+ * // With concurrency limit
+ * const items = [1, 2, 3, 4, 5];
+ * await forEachAsync(
+ *   items,
+ *   async (item) => await processItem(item),
+ *   { concurrency: 2 }
+ * );
+ * // Processes at most 2 items concurrently
+ */
+declare function forEachAsync<T>(array: readonly T[], callback: (item: T, index: number, array: readonly T[]) => Promise<void>, options?: ForEachAsyncOptions): Promise<void>;
+//#endregion
+export { forEachAsync };

data/payload/node_modules/es-toolkit/dist/array/forEachAsync.js

@@ -0,0 +1,37 @@
+const require_limitAsync = require("../promise/limitAsync.js");
+//#region src/array/forEachAsync.ts
+/**
+* Executes an async callback function for each element in an array.
+*
+* Unlike the native `forEach`, this function returns a promise that resolves
+* when all async operations complete. It supports optional concurrency limiting.
+*
+* @template T - The type of elements in the array.
+* @param array The array to iterate over.
+* @param callback An async function to execute for each element.
+* @param [options] Optional configuration object.
+* @param [options.concurrency] Maximum number of concurrent async operations. If not specified, all operations run concurrently.
+* @returns A promise that resolves when all operations complete.
+* @example
+* const users = [{ id: 1 }, { id: 2 }, { id: 3 }];
+* await forEachAsync(users, async (user) => {
+*   await updateUser(user.id);
+* });
+* // All users have been updated
+*
+* @example
+* // With concurrency limit
+* const items = [1, 2, 3, 4, 5];
+* await forEachAsync(
+*   items,
+*   async (item) => await processItem(item),
+*   { concurrency: 2 }
+* );
+* // Processes at most 2 items concurrently
+*/
+async function forEachAsync(array, callback, options) {
+	if (options?.concurrency != null) callback = require_limitAsync.limitAsync(callback, options.concurrency);
+	await Promise.all(array.map(callback));
+}
+//#endregion
+exports.forEachAsync = forEachAsync;

data/payload/node_modules/es-toolkit/dist/array/forEachAsync.mjs

@@ -0,0 +1,37 @@
+import { limitAsync } from "../promise/limitAsync.mjs";
+//#region src/array/forEachAsync.ts
+/**
+* Executes an async callback function for each element in an array.
+*
+* Unlike the native `forEach`, this function returns a promise that resolves
+* when all async operations complete. It supports optional concurrency limiting.
+*
+* @template T - The type of elements in the array.
+* @param array The array to iterate over.
+* @param callback An async function to execute for each element.
+* @param [options] Optional configuration object.
+* @param [options.concurrency] Maximum number of concurrent async operations. If not specified, all operations run concurrently.
+* @returns A promise that resolves when all operations complete.
+* @example
+* const users = [{ id: 1 }, { id: 2 }, { id: 3 }];
+* await forEachAsync(users, async (user) => {
+*   await updateUser(user.id);
+* });
+* // All users have been updated
+*
+* @example
+* // With concurrency limit
+* const items = [1, 2, 3, 4, 5];
+* await forEachAsync(
+*   items,
+*   async (item) => await processItem(item),
+*   { concurrency: 2 }
+* );
+* // Processes at most 2 items concurrently
+*/
+async function forEachAsync(array, callback, options) {
+	if (options?.concurrency != null) callback = limitAsync(callback, options.concurrency);
+	await Promise.all(array.map(callback));
+}
+//#endregion
+export { forEachAsync };

data/payload/node_modules/es-toolkit/dist/array/forEachRight.d.mts

@@ -0,0 +1,49 @@
+//#region src/array/forEachRight.d.ts
+/**
+ * Iterates over elements of 'arr' from right to left and invokes 'callback' for each element.
+ *
+ * @template T - The type of elements in the array.
+ * @param arr - The array to iterate over.
+ * @param callback - The function invoked per iteration.
+ * The callback function receives three arguments:
+ *  - 'value': The current element being processed in the array.
+ *  - 'index': The index of the current element being processed in the array.
+ *  - 'arr': The array 'forEachRight' was called upon.
+ *
+ * @example
+ * const array = [1, 2, 3];
+ * const result: number[] = [];
+ *
+ * // Use the forEachRight function to iterate through the array and add each element to the result array.
+ * forEachRight(array, (value) => {
+ *  result.push(value);
+ * })
+ *
+ * console.log(result) // Output: [3, 2, 1]
+ */
+declare function forEachRight<T>(arr: T[], callback: (value: T, index: number, arr: T[]) => void): void;
+/**
+ * Iterates over elements of 'arr' from right to left and invokes 'callback' for each element.
+ *
+ * @template T - The type of elements in the array.
+ * @param arr - The array to iterate over.
+ * @param callback - The function invoked per iteration.
+ * The callback function receives three arguments:
+ *  - 'value': The current element being processed in the array.
+ *  - 'index': The index of the current element being processed in the array.
+ *  - 'arr': The array 'forEachRight' was called upon.
+ *
+ * @example
+ * const array = [1, 2, 3];
+ * const result: number[] = [];
+ *
+ * // Use the forEachRight function to iterate through the array and add each element to the result array.
+ * forEachRight(array, (value) => {
+ *  result.push(value);
+ * })
+ *
+ * console.log(result) // Output: [3, 2, 1]
+ */
+declare function forEachRight<T>(arr: readonly T[], callback: (value: T, index: number, arr: readonly T[]) => void): void;
+//#endregion
+export { forEachRight };

data/payload/node_modules/es-toolkit/dist/array/forEachRight.d.ts

@@ -0,0 +1,49 @@
+//#region src/array/forEachRight.d.ts
+/**
+ * Iterates over elements of 'arr' from right to left and invokes 'callback' for each element.
+ *
+ * @template T - The type of elements in the array.
+ * @param arr - The array to iterate over.
+ * @param callback - The function invoked per iteration.
+ * The callback function receives three arguments:
+ *  - 'value': The current element being processed in the array.
+ *  - 'index': The index of the current element being processed in the array.
+ *  - 'arr': The array 'forEachRight' was called upon.
+ *
+ * @example
+ * const array = [1, 2, 3];
+ * const result: number[] = [];
+ *
+ * // Use the forEachRight function to iterate through the array and add each element to the result array.
+ * forEachRight(array, (value) => {
+ *  result.push(value);
+ * })
+ *
+ * console.log(result) // Output: [3, 2, 1]
+ */
+declare function forEachRight<T>(arr: T[], callback: (value: T, index: number, arr: T[]) => void): void;
+/**
+ * Iterates over elements of 'arr' from right to left and invokes 'callback' for each element.
+ *
+ * @template T - The type of elements in the array.
+ * @param arr - The array to iterate over.
+ * @param callback - The function invoked per iteration.
+ * The callback function receives three arguments:
+ *  - 'value': The current element being processed in the array.
+ *  - 'index': The index of the current element being processed in the array.
+ *  - 'arr': The array 'forEachRight' was called upon.
+ *
+ * @example
+ * const array = [1, 2, 3];
+ * const result: number[] = [];
+ *
+ * // Use the forEachRight function to iterate through the array and add each element to the result array.
+ * forEachRight(array, (value) => {
+ *  result.push(value);
+ * })
+ *
+ * console.log(result) // Output: [3, 2, 1]
+ */
+declare function forEachRight<T>(arr: readonly T[], callback: (value: T, index: number, arr: readonly T[]) => void): void;
+//#endregion
+export { forEachRight };

data/payload/node_modules/es-toolkit/dist/array/forEachRight.js

@@ -0,0 +1,31 @@
+//#region src/array/forEachRight.ts
+/**
+* Iterates over elements of 'arr' from right to left and invokes 'callback' for each element.
+*
+* @template T - The type of elements in the array.
+* @param arr - The array to iterate over.
+* @param callback - The function invoked per iteration.
+* The callback function receives three arguments:
+*  - 'value': The current element being processed in the array.
+*  - 'index': The index of the current element being processed in the array.
+*  - 'arr': The array 'forEachRight' was called upon.
+*
+* @example
+* const array = [1, 2, 3];
+* const result: number[] = [];
+*
+* // Use the forEachRight function to iterate through the array and add each element to the result array.
+* forEachRight(array, (value) => {
+*  result.push(value);
+* })
+*
+* console.log(result) // Output: [3, 2, 1]
+*/
+function forEachRight(arr, callback) {
+	for (let i = arr.length - 1; i >= 0; i--) {
+		const element = arr[i];
+		callback(element, i, arr);
+	}
+}
+//#endregion
+exports.forEachRight = forEachRight;

data/payload/node_modules/es-toolkit/dist/array/forEachRight.mjs

@@ -0,0 +1,31 @@
+//#region src/array/forEachRight.ts
+/**
+* Iterates over elements of 'arr' from right to left and invokes 'callback' for each element.
+*
+* @template T - The type of elements in the array.
+* @param arr - The array to iterate over.
+* @param callback - The function invoked per iteration.
+* The callback function receives three arguments:
+*  - 'value': The current element being processed in the array.
+*  - 'index': The index of the current element being processed in the array.
+*  - 'arr': The array 'forEachRight' was called upon.
+*
+* @example
+* const array = [1, 2, 3];
+* const result: number[] = [];
+*
+* // Use the forEachRight function to iterate through the array and add each element to the result array.
+* forEachRight(array, (value) => {
+*  result.push(value);
+* })
+*
+* console.log(result) // Output: [3, 2, 1]
+*/
+function forEachRight(arr, callback) {
+	for (let i = arr.length - 1; i >= 0; i--) {
+		const element = arr[i];
+		callback(element, i, arr);
+	}
+}
+//#endregion
+export { forEachRight };

data/payload/node_modules/es-toolkit/dist/array/groupBy.d.mts

@@ -0,0 +1,42 @@
+//#region src/array/groupBy.d.ts
+/**
+ * Groups the elements of an array based on a provided key-generating function.
+ *
+ * This function takes an array and a function that generates a key from each element. It returns
+ * an object where the keys are the generated keys and the values are arrays of elements that share
+ * the same key.
+ *
+ * @template T - The type of elements in the array.
+ * @template K - The type of keys.
+ * @param arr - The array to group.
+ * @param getKeyFromItem - A function that generates a key from an element, its index, and the array.
+ * @returns An object where each key is associated with an array of elements that
+ * share that key.
+ *
+ * @example
+ * const array = [
+ *   { category: 'fruit', name: 'apple' },
+ *   { category: 'fruit', name: 'banana' },
+ *   { category: 'vegetable', name: 'carrot' }
+ * ];
+ * const result = groupBy(array, item => item.category);
+ * // result will be:
+ * // {
+ * //   fruit: [
+ * //     { category: 'fruit', name: 'apple' },
+ * //     { category: 'fruit', name: 'banana' }
+ * //   ],
+ * //   vegetable: [
+ * //     { category: 'vegetable', name: 'carrot' }
+ * //   ]
+ * // }
+ *
+ * @example
+ * // Using index parameter
+ * const items = ['a', 'b', 'c', 'd'];
+ * const result = groupBy(items, (item, index) => index % 2 === 0 ? 'even' : 'odd');
+ * // result will be: { even: ['a', 'c'], odd: ['b', 'd'] }
+ */
+declare function groupBy<T, K extends PropertyKey>(arr: readonly T[], getKeyFromItem: (item: T, index: number, array: readonly T[]) => K): Record<K, T[]>;
+//#endregion
+export { groupBy };

data/payload/node_modules/es-toolkit/dist/array/groupBy.d.ts

@@ -0,0 +1,42 @@
+//#region src/array/groupBy.d.ts
+/**
+ * Groups the elements of an array based on a provided key-generating function.
+ *
+ * This function takes an array and a function that generates a key from each element. It returns
+ * an object where the keys are the generated keys and the values are arrays of elements that share
+ * the same key.
+ *
+ * @template T - The type of elements in the array.
+ * @template K - The type of keys.
+ * @param arr - The array to group.
+ * @param getKeyFromItem - A function that generates a key from an element, its index, and the array.
+ * @returns An object where each key is associated with an array of elements that
+ * share that key.
+ *
+ * @example
+ * const array = [
+ *   { category: 'fruit', name: 'apple' },
+ *   { category: 'fruit', name: 'banana' },
+ *   { category: 'vegetable', name: 'carrot' }
+ * ];
+ * const result = groupBy(array, item => item.category);
+ * // result will be:
+ * // {
+ * //   fruit: [
+ * //     { category: 'fruit', name: 'apple' },
+ * //     { category: 'fruit', name: 'banana' }
+ * //   ],
+ * //   vegetable: [
+ * //     { category: 'vegetable', name: 'carrot' }
+ * //   ]
+ * // }
+ *
+ * @example
+ * // Using index parameter
+ * const items = ['a', 'b', 'c', 'd'];
+ * const result = groupBy(items, (item, index) => index % 2 === 0 ? 'even' : 'odd');
+ * // result will be: { even: ['a', 'c'], odd: ['b', 'd'] }
+ */
+declare function groupBy<T, K extends PropertyKey>(arr: readonly T[], getKeyFromItem: (item: T, index: number, array: readonly T[]) => K): Record<K, T[]>;
+//#endregion
+export { groupBy };

data/payload/node_modules/es-toolkit/dist/array/groupBy.js

@@ -0,0 +1,51 @@
+//#region src/array/groupBy.ts
+/**
+* Groups the elements of an array based on a provided key-generating function.
+*
+* This function takes an array and a function that generates a key from each element. It returns
+* an object where the keys are the generated keys and the values are arrays of elements that share
+* the same key.
+*
+* @template T - The type of elements in the array.
+* @template K - The type of keys.
+* @param arr - The array to group.
+* @param getKeyFromItem - A function that generates a key from an element, its index, and the array.
+* @returns An object where each key is associated with an array of elements that
+* share that key.
+*
+* @example
+* const array = [
+*   { category: 'fruit', name: 'apple' },
+*   { category: 'fruit', name: 'banana' },
+*   { category: 'vegetable', name: 'carrot' }
+* ];
+* const result = groupBy(array, item => item.category);
+* // result will be:
+* // {
+* //   fruit: [
+* //     { category: 'fruit', name: 'apple' },
+* //     { category: 'fruit', name: 'banana' }
+* //   ],
+* //   vegetable: [
+* //     { category: 'vegetable', name: 'carrot' }
+* //   ]
+* // }
+*
+* @example
+* // Using index parameter
+* const items = ['a', 'b', 'c', 'd'];
+* const result = groupBy(items, (item, index) => index % 2 === 0 ? 'even' : 'odd');
+* // result will be: { even: ['a', 'c'], odd: ['b', 'd'] }
+*/
+function groupBy(arr, getKeyFromItem) {
+	const result = {};
+	for (let i = 0; i < arr.length; i++) {
+		const item = arr[i];
+		const key = getKeyFromItem(item, i, arr);
+		if (!Object.hasOwn(result, key)) result[key] = [];
+		result[key].push(item);
+	}
+	return result;
+}
+//#endregion
+exports.groupBy = groupBy;