@duplojs/lang 0.0.0

package/dist/generator/asyncChunk.mjs

@@ -0,0 +1,21 @@
+//#region scripts/generator/asyncChunk.ts
+function asyncChunk(...args) {
+	if (args.length === 1) {
+		const [size] = args;
+		return (iterator) => asyncChunk(iterator, size);
+	}
+	const [iterator, size] = args;
+	return (async function* () {
+		let buffer = [];
+		for await (const item of iterator) {
+			buffer.push(item);
+			if (buffer.length === size) {
+				yield buffer;
+				buffer = [];
+			}
+		}
+		if (buffer.length > 0) yield buffer;
+	})();
+}
+//#endregion
+export { asyncChunk };

package/dist/generator/asyncConcat.cjs

@@ -0,0 +1,15 @@
+//#region scripts/generator/asyncConcat.ts
+function asyncConcat(...args) {
+	if (args.length === 1) {
+		const [items] = args;
+		return (iterator) => asyncConcat(iterator, items);
+	}
+	const [iterator, items, ...itemsRest] = args;
+	return (async function* () {
+		yield* iterator;
+		yield* items;
+		for (const value of itemsRest) yield* value;
+	})();
+}
+//#endregion
+exports.asyncConcat = asyncConcat;

package/dist/generator/asyncConcat.d.ts

@@ -0,0 +1,2 @@
+export declare function asyncConcat<const GenericItem extends unknown>(items: AsyncIterable<GenericItem> | Iterable<GenericItem>): (iterator: AsyncIterable<GenericItem> | Iterable<GenericItem>) => AsyncGenerator<GenericItem, unknown, unknown>;
+export declare function asyncConcat<const GenericItem extends unknown>(iterator: AsyncIterable<GenericItem> | Iterable<GenericItem>, items: AsyncIterable<GenericItem> | Iterable<GenericItem>, ...itemsRest: (AsyncIterable<GenericItem> | Iterable<GenericItem>)[]): AsyncGenerator<GenericItem, unknown, unknown>;

package/dist/generator/asyncConcat.mjs

@@ -0,0 +1,15 @@
+//#region scripts/generator/asyncConcat.ts
+function asyncConcat(...args) {
+	if (args.length === 1) {
+		const [items] = args;
+		return (iterator) => asyncConcat(iterator, items);
+	}
+	const [iterator, items, ...itemsRest] = args;
+	return (async function* () {
+		yield* iterator;
+		yield* items;
+		for (const value of itemsRest) yield* value;
+	})();
+}
+//#endregion
+export { asyncConcat };

package/dist/generator/asyncFilter.cjs

@@ -0,0 +1,17 @@
+//#region scripts/generator/asyncFilter.ts
+function asyncFilter(...args) {
+	if (args.length === 1) {
+		const [predicate] = args;
+		return (iterator) => asyncFilter(iterator, predicate);
+	}
+	const [iterator, predicate] = args;
+	let index = 0;
+	return (async function* () {
+		for await (const item of iterator) {
+			if (predicate(item, { index })) yield item;
+			index++;
+		}
+	})();
+}
+//#endregion
+exports.asyncFilter = asyncFilter;

package/dist/generator/asyncFilter.d.ts

@@ -0,0 +1,7 @@
+export interface AsyncFilterParams {
+    index: number;
+}
+export declare function asyncFilter<const GenericItem extends unknown, const GenericOutput extends GenericItem>(predicate: (item: GenericItem, params: AsyncFilterParams) => item is GenericOutput): (iterator: Iterable<GenericItem> | AsyncIterable<GenericItem>) => AsyncGenerator<GenericOutput, unknown, unknown>;
+export declare function asyncFilter<const GenericItem extends unknown, const GenericOutput extends GenericItem>(iterator: Iterable<GenericItem> | AsyncIterable<GenericItem>, predicate: (item: GenericItem, params: AsyncFilterParams) => item is GenericOutput): AsyncGenerator<GenericOutput, unknown, unknown>;
+export declare function asyncFilter<const GenericItem extends unknown>(predicate: (item: GenericItem, params: AsyncFilterParams) => boolean): (iterator: Iterable<GenericItem> | AsyncIterable<GenericItem>) => AsyncGenerator<GenericItem, unknown, unknown>;
+export declare function asyncFilter<const GenericItem extends unknown>(iterator: Iterable<GenericItem> | AsyncIterable<GenericItem>, predicate: (item: GenericItem, params: AsyncFilterParams) => boolean): AsyncGenerator<GenericItem, unknown, unknown>;

package/dist/generator/asyncFilter.mjs

@@ -0,0 +1,17 @@
+//#region scripts/generator/asyncFilter.ts
+function asyncFilter(...args) {
+	if (args.length === 1) {
+		const [predicate] = args;
+		return (iterator) => asyncFilter(iterator, predicate);
+	}
+	const [iterator, predicate] = args;
+	let index = 0;
+	return (async function* () {
+		for await (const item of iterator) {
+			if (predicate(item, { index })) yield item;
+			index++;
+		}
+	})();
+}
+//#endregion
+export { asyncFilter };

package/dist/generator/asyncFlat.cjs

@@ -0,0 +1,7 @@
+//#region scripts/generator/asyncFlat.ts
+async function* asyncFlat(iterator, depth = 1) {
+	for await (const item of iterator) if (depth >= 1 && item && typeof item === "object" && (Symbol.iterator in item || Symbol.asyncIterator in item)) yield* asyncFlat(item, depth - 1);
+	else yield item;
+}
+//#endregion
+exports.asyncFlat = asyncFlat;

package/dist/generator/asyncFlat.d.ts

@@ -0,0 +1,2 @@
+import { FlatAsyncIterator } from './types';
+export declare function asyncFlat<const GenericItem extends unknown, const GenericDepth extends number = 1>(iterator: AsyncIterable<GenericItem> | Iterable<GenericItem>, depth?: GenericDepth): AsyncGenerator<FlatAsyncIterator<GenericItem, GenericDepth>, void, unknown>;

package/dist/generator/asyncFlat.mjs

@@ -0,0 +1,7 @@
+//#region scripts/generator/asyncFlat.ts
+async function* asyncFlat(iterator, depth = 1) {
+	for await (const item of iterator) if (depth >= 1 && item && typeof item === "object" && (Symbol.iterator in item || Symbol.asyncIterator in item)) yield* asyncFlat(item, depth - 1);
+	else yield item;
+}
+//#endregion
+export { asyncFlat };

package/dist/generator/asyncGroup.cjs

@@ -0,0 +1,25 @@
+const require_group = require("./group.cjs");
+//#region scripts/generator/asyncGroup.ts
+function asyncGroup(...args) {
+	if (args.length === 1) {
+		const [theFunction] = args;
+		return (asyncIterator) => asyncGroup(asyncIterator, theFunction);
+	}
+	const [asyncIterator, theFunction] = args;
+	const result = {};
+	let index = 0;
+	return (async () => {
+		for await (const item of asyncIterator) {
+			const { group, value } = await theFunction(item, {
+				index,
+				output: require_group.groupOutput
+			});
+			if (result[group]) result[group].push(value);
+			else result[group] = [value];
+			index++;
+		}
+		return result;
+	})();
+}
+//#endregion
+exports.asyncGroup = asyncGroup;

package/dist/generator/asyncGroup.d.ts

@@ -0,0 +1,4 @@
+import { GroupResult, GroupOutputResult, GroupTheFunctionParams } from './group';
+import type * as DCommon from '../common';
+export declare function asyncGroup<GenericItem extends unknown, GenericOutput extends GroupOutputResult>(theFunction: (item: GenericItem, params: GroupTheFunctionParams) => DCommon.MaybePromise<GenericOutput>): (asyncIterator: AsyncIterable<GenericItem>) => Promise<GroupResult<GenericOutput>>;
+export declare function asyncGroup<GenericItem extends unknown, GenericOutput extends GroupOutputResult>(asyncIterator: AsyncIterable<GenericItem>, theFunction: (item: GenericItem, params: GroupTheFunctionParams) => DCommon.MaybePromise<GenericOutput>): Promise<GroupResult<GenericOutput>>;

package/dist/generator/asyncGroup.mjs

@@ -0,0 +1,25 @@
+import { groupOutput } from "./group.mjs";
+//#region scripts/generator/asyncGroup.ts
+function asyncGroup(...args) {
+	if (args.length === 1) {
+		const [theFunction] = args;
+		return (asyncIterator) => asyncGroup(asyncIterator, theFunction);
+	}
+	const [asyncIterator, theFunction] = args;
+	const result = {};
+	let index = 0;
+	return (async () => {
+		for await (const item of asyncIterator) {
+			const { group, value } = await theFunction(item, {
+				index,
+				output: groupOutput
+			});
+			if (result[group]) result[group].push(value);
+			else result[group] = [value];
+			index++;
+		}
+		return result;
+	})();
+}
+//#endregion
+export { asyncGroup };

package/dist/generator/asyncLoop.cjs

@@ -0,0 +1,20 @@
+//#region scripts/generator/asyncLoop.ts
+async function* asyncLoop(loop) {
+	let previousOutput = void 0;
+	for (let count = 0;; count++) {
+		const result = await loop({
+			previousOutput,
+			count,
+			next: (data) => ({ "-nextData": data }),
+			exit: (data) => ({ "-exitData": data })
+		});
+		if ("-exitData" in result) {
+			if (result["-exitData"] !== void 0) yield result["-exitData"];
+			break;
+		}
+		previousOutput = result["-nextData"];
+		if (previousOutput !== void 0) yield previousOutput;
+	}
+}
+//#endregion
+exports.asyncLoop = asyncLoop;

package/dist/generator/asyncLoop.d.ts

@@ -0,0 +1,3 @@
+import { LoopOutputExistResult, LoopOutputNextResult, LoopParams } from './loop';
+import type * as DCommon from '../common';
+export declare function asyncLoop<GenericRawNextOutput extends unknown, GenericOutput extends DCommon.MaybePromise<LoopOutputNextResult<GenericRawNextOutput> | LoopOutputExistResult<unknown> | LoopOutputNextResult<undefined> | LoopOutputExistResult<undefined>>>(loop: (params: LoopParams<GenericRawNextOutput>) => GenericOutput): AsyncGenerator<Exclude<Awaited<GenericOutput> extends infer InferredOutput ? InferredOutput extends LoopOutputNextResult ? InferredOutput["-nextData"] : InferredOutput extends LoopOutputExistResult ? InferredOutput["-exitData"] : never : never, undefined>, unknown, unknown>;

package/dist/generator/asyncLoop.mjs

@@ -0,0 +1,20 @@
+//#region scripts/generator/asyncLoop.ts
+async function* asyncLoop(loop) {
+	let previousOutput = void 0;
+	for (let count = 0;; count++) {
+		const result = await loop({
+			previousOutput,
+			count,
+			next: (data) => ({ "-nextData": data }),
+			exit: (data) => ({ "-exitData": data })
+		});
+		if ("-exitData" in result) {
+			if (result["-exitData"] !== void 0) yield result["-exitData"];
+			break;
+		}
+		previousOutput = result["-nextData"];
+		if (previousOutput !== void 0) yield previousOutput;
+	}
+}
+//#endregion
+export { asyncLoop };

package/dist/generator/asyncMap.cjs

@@ -0,0 +1,17 @@
+//#region scripts/generator/asyncMap.ts
+function asyncMap(...args) {
+	if (args.length === 1) {
+		const [theFunction] = args;
+		return (iterator) => asyncMap(iterator, theFunction);
+	}
+	const [iterator, theFunction] = args;
+	let index = 0;
+	return (async function* () {
+		for await (const item of iterator) {
+			yield await theFunction(item, { index });
+			index++;
+		}
+	})();
+}
+//#endregion
+exports.asyncMap = asyncMap;

package/dist/generator/asyncMap.d.ts

@@ -0,0 +1,5 @@
+export interface AsyncMapParams {
+    index: number;
+}
+export declare function asyncMap<const GenericItem extends unknown, const GenericOutput extends unknown>(theFunction: (item: GenericItem, params: AsyncMapParams) => GenericOutput): (iterator: AsyncIterable<GenericItem> | Iterable<GenericItem>) => AsyncGenerator<Awaited<GenericOutput>, unknown, unknown>;
+export declare function asyncMap<const GenericItem extends unknown, const GenericOutput extends unknown>(iterator: AsyncIterable<GenericItem> | Iterable<GenericItem>, theFunction: (item: GenericItem, params: AsyncMapParams) => GenericOutput): AsyncGenerator<Awaited<GenericOutput>, unknown, unknown>;

package/dist/generator/asyncMap.mjs

@@ -0,0 +1,17 @@
+//#region scripts/generator/asyncMap.ts
+function asyncMap(...args) {
+	if (args.length === 1) {
+		const [theFunction] = args;
+		return (iterator) => asyncMap(iterator, theFunction);
+	}
+	const [iterator, theFunction] = args;
+	let index = 0;
+	return (async function* () {
+		for await (const item of iterator) {
+			yield await theFunction(item, { index });
+			index++;
+		}
+	})();
+}
+//#endregion
+export { asyncMap };

package/dist/generator/asyncReduce.cjs

@@ -0,0 +1,28 @@
+const require_reduce = require("../array/reduce.cjs");
+const require_reduce$1 = require("./reduce.cjs");
+//#region scripts/generator/asyncReduce.ts
+function asyncReduce(...args) {
+	if (args.length === 2) {
+		const [fromValue, theFunction] = args;
+		return (iterator) => asyncReduce(iterator, fromValue, theFunction);
+	}
+	const [iterator, fromValue, theFunction] = args;
+	let lastValue = require_reduce$1.reduceKind.has(fromValue) ? require_reduce$1.reduceKind.getValue(fromValue) : fromValue;
+	return (async () => {
+		let index = 0;
+		for await (const item of iterator) {
+			const result = await theFunction({
+				item,
+				index,
+				lastValue,
+				...require_reduce.reduceTools
+			});
+			if ("-exit" in result) return result["-exit"];
+			lastValue = result["-next"];
+			index++;
+		}
+		return lastValue;
+	})();
+}
+//#endregion
+exports.asyncReduce = asyncReduce;

package/dist/generator/asyncReduce.d.ts

@@ -0,0 +1,4 @@
+import { ReduceFromValue, EligibleReduceFromValue, ReduceTheFunctionParams, ReduceExit, ReduceNext } from './reduce';
+import type * as DCommon from '../common';
+export declare function asyncReduce<GenericItem extends unknown, GenericReduceFrom extends EligibleReduceFromValue, GenericExit extends ReduceExit = ReduceExit<never>>(startValue: GenericReduceFrom, theFunction: (params: ReduceTheFunctionParams<GenericItem, ReduceFromValue<GenericReduceFrom>>) => DCommon.MaybePromise<ReduceNext<ReduceFromValue<GenericReduceFrom>> | GenericExit>): (iterator: Iterable<GenericItem> | AsyncIterable<GenericItem>) => Promise<ReduceFromValue<GenericReduceFrom> | (DCommon.IsEqual<GenericExit, ReduceExit> extends true ? never : GenericExit["-exit"])>;
+export declare function asyncReduce<GenericItem extends unknown, GenericReduceFrom extends EligibleReduceFromValue, GenericExit extends ReduceExit = ReduceExit<never>>(iterator: Iterable<GenericItem> | AsyncIterable<GenericItem>, startValue: GenericReduceFrom, theFunction: (params: ReduceTheFunctionParams<GenericItem, ReduceFromValue<GenericReduceFrom>>) => DCommon.MaybePromise<ReduceNext<ReduceFromValue<GenericReduceFrom>> | GenericExit>): Promise<ReduceFromValue<GenericReduceFrom> | (DCommon.IsEqual<GenericExit, ReduceExit> extends true ? never : GenericExit["-exit"])>;

package/dist/generator/asyncReduce.mjs

@@ -0,0 +1,28 @@
+import { reduceTools } from "../array/reduce.mjs";
+import { reduceKind } from "./reduce.mjs";
+//#region scripts/generator/asyncReduce.ts
+function asyncReduce(...args) {
+	if (args.length === 2) {
+		const [fromValue, theFunction] = args;
+		return (iterator) => asyncReduce(iterator, fromValue, theFunction);
+	}
+	const [iterator, fromValue, theFunction] = args;
+	let lastValue = reduceKind.has(fromValue) ? reduceKind.getValue(fromValue) : fromValue;
+	return (async () => {
+		let index = 0;
+		for await (const item of iterator) {
+			const result = await theFunction({
+				item,
+				index,
+				lastValue,
+				...reduceTools
+			});
+			if ("-exit" in result) return result["-exit"];
+			lastValue = result["-next"];
+			index++;
+		}
+		return lastValue;
+	})();
+}
+//#endregion
+export { asyncReduce };

package/dist/generator/chunk.cjs

@@ -0,0 +1,21 @@
+//#region scripts/generator/chunk.ts
+function chunk(...args) {
+	if (args.length === 1) {
+		const [size] = args;
+		return (iterator) => chunk(iterator, size);
+	}
+	const [iterator, size] = args;
+	return (function* () {
+		let buffer = [];
+		for (const item of iterator) {
+			buffer.push(item);
+			if (buffer.length === size) {
+				yield buffer;
+				buffer = [];
+			}
+		}
+		if (buffer.length > 0) yield buffer;
+	})();
+}
+//#endregion
+exports.chunk = chunk;

package/dist/generator/chunk.d.ts

@@ -0,0 +1,2 @@
+export declare function chunk<const GenericItem extends unknown>(size: number): (iterator: Iterable<GenericItem>) => Generator<GenericItem[], unknown, unknown>;
+export declare function chunk<const GenericItem extends unknown>(iterator: Iterable<GenericItem>, size: number): Generator<GenericItem[], unknown, unknown>;

package/dist/generator/chunk.mjs

@@ -0,0 +1,21 @@
+//#region scripts/generator/chunk.ts
+function chunk(...args) {
+	if (args.length === 1) {
+		const [size] = args;
+		return (iterator) => chunk(iterator, size);
+	}
+	const [iterator, size] = args;
+	return (function* () {
+		let buffer = [];
+		for (const item of iterator) {
+			buffer.push(item);
+			if (buffer.length === size) {
+				yield buffer;
+				buffer = [];
+			}
+		}
+		if (buffer.length > 0) yield buffer;
+	})();
+}
+//#endregion
+export { chunk };

package/dist/generator/concat.cjs

@@ -0,0 +1,15 @@
+//#region scripts/generator/concat.ts
+function concat(...args) {
+	if (args.length === 1) {
+		const [items] = args;
+		return (iterator) => concat(iterator, items);
+	}
+	const [iterator, items, ...itemsRest] = args;
+	return (function* () {
+		yield* iterator;
+		yield* items;
+		for (const value of itemsRest) yield* value;
+	})();
+}
+//#endregion
+exports.concat = concat;

package/dist/generator/concat.d.ts

@@ -0,0 +1,2 @@
+export declare function concat<const GenericItem extends unknown>(items: Iterable<GenericItem>): (iterator: Iterable<GenericItem>) => Generator<GenericItem, unknown, unknown>;
+export declare function concat<const GenericItem extends unknown>(iterator: Iterable<GenericItem>, items: Iterable<GenericItem>, ...itemsRest: Iterable<GenericItem>[]): Generator<GenericItem, unknown, unknown>;

package/dist/generator/concat.mjs

@@ -0,0 +1,15 @@
+//#region scripts/generator/concat.ts
+function concat(...args) {
+	if (args.length === 1) {
+		const [items] = args;
+		return (iterator) => concat(iterator, items);
+	}
+	const [iterator, items, ...itemsRest] = args;
+	return (function* () {
+		yield* iterator;
+		yield* items;
+		for (const value of itemsRest) yield* value;
+	})();
+}
+//#endregion
+export { concat };

package/dist/generator/createExternalAsyncGenerator.cjs

@@ -0,0 +1,18 @@
+//#region scripts/generator/createExternalAsyncGenerator.ts
+const exitExternalAsync = Symbol("exitExternalAsync");
+function createExternalAsyncGenerator() {
+	let externalResolve = void 0;
+	return {
+		asyncGenerator: (async function* () {
+			const result = await new Promise((resolve) => {
+				externalResolve = resolve;
+			});
+			if (result === exitExternalAsync) return;
+			else yield result;
+		})(),
+		next: (item) => void externalResolve?.(item),
+		exit: () => void externalResolve?.(exitExternalAsync)
+	};
+}
+//#endregion
+exports.createExternalAsyncGenerator = createExternalAsyncGenerator;

package/dist/generator/createExternalAsyncGenerator.d.ts

@@ -0,0 +1,5 @@
+export declare function createExternalAsyncGenerator<GenericItem extends unknown>(): {
+    asyncGenerator: AsyncGenerator<Awaited<GenericItem>, void, unknown>;
+    next: (item: GenericItem) => undefined;
+    exit: () => undefined;
+};

package/dist/generator/createExternalAsyncGenerator.mjs

@@ -0,0 +1,18 @@
+//#region scripts/generator/createExternalAsyncGenerator.ts
+const exitExternalAsync = Symbol("exitExternalAsync");
+function createExternalAsyncGenerator() {
+	let externalResolve = void 0;
+	return {
+		asyncGenerator: (async function* () {
+			const result = await new Promise((resolve) => {
+				externalResolve = resolve;
+			});
+			if (result === exitExternalAsync) return;
+			else yield result;
+		})(),
+		next: (item) => void externalResolve?.(item),
+		exit: () => void externalResolve?.(exitExternalAsync)
+	};
+}
+//#endregion
+export { createExternalAsyncGenerator };

package/dist/generator/execute.cjs

@@ -0,0 +1,11 @@
+//#region scripts/generator/execute.ts
+function execute(iterator) {
+	if (Symbol.iterator in iterator) {
+		for (const __ of iterator);
+		return;
+	} else return (async () => {
+		for await (const __ of iterator);
+	})();
+}
+//#endregion
+exports.execute = execute;

package/dist/generator/execute.d.ts

@@ -0,0 +1,2 @@
+import type * as DCommon from '../common';
+export declare function execute<GenericIterator extends AsyncIterable<unknown> | Iterable<unknown>>(iterator: GenericIterator): GenericIterator extends AsyncIterable<unknown> ? Promise<void> : DCommon.EscapeVoid;

package/dist/generator/execute.mjs

@@ -0,0 +1,11 @@
+//#region scripts/generator/execute.ts
+function execute(iterator) {
+	if (Symbol.iterator in iterator) {
+		for (const __ of iterator);
+		return;
+	} else return (async () => {
+		for await (const __ of iterator);
+	})();
+}
+//#endregion
+export { execute };

package/dist/generator/filter.cjs

@@ -0,0 +1,20 @@
+//#region scripts/generator/filter.ts
+function filter(...args) {
+	if (args.length === 1) {
+		const [predicate] = args;
+		return (iterator) => filter(iterator, predicate);
+	}
+	const [iterator, predicate] = args;
+	let index = 0;
+	return (function* () {
+		for (const item of iterator) {
+			if (predicate(item, {
+				index,
+				self: iterator
+			})) yield item;
+			index++;
+		}
+	})();
+}
+//#endregion
+exports.filter = filter;

package/dist/generator/filter.d.ts

@@ -0,0 +1,8 @@
+export interface FilterParams<GenericItem extends unknown = unknown> {
+    index: number;
+    self: Iterable<GenericItem>;
+}
+export declare function filter<const GenericItem extends unknown, const GenericOutput extends GenericItem>(predicate: (item: GenericItem, params: FilterParams<GenericItem>) => item is GenericOutput): (iterator: Iterable<GenericItem>) => Generator<GenericOutput, unknown, unknown>;
+export declare function filter<const GenericItem extends unknown, const GenericOutput extends GenericItem>(iterator: Iterable<GenericItem>, predicate: (item: GenericItem, params: FilterParams<GenericItem>) => item is GenericOutput): Generator<GenericOutput, unknown, unknown>;
+export declare function filter<const GenericItem extends unknown>(predicate: (item: GenericItem, params: FilterParams<GenericItem>) => boolean): (iterator: Iterable<GenericItem>) => Generator<GenericItem, unknown, unknown>;
+export declare function filter<const GenericItem extends unknown>(iterator: Iterable<GenericItem>, predicate: (item: GenericItem, params: FilterParams<GenericItem>) => boolean): Generator<GenericItem, unknown, unknown>;

package/dist/generator/filter.mjs

@@ -0,0 +1,20 @@
+//#region scripts/generator/filter.ts
+function filter(...args) {
+	if (args.length === 1) {
+		const [predicate] = args;
+		return (iterator) => filter(iterator, predicate);
+	}
+	const [iterator, predicate] = args;
+	let index = 0;
+	return (function* () {
+		for (const item of iterator) {
+			if (predicate(item, {
+				index,
+				self: iterator
+			})) yield item;
+			index++;
+		}
+	})();
+}
+//#endregion
+export { filter };

package/dist/generator/flat.cjs

@@ -0,0 +1,7 @@
+//#region scripts/generator/flat.ts
+function* flat(iterator, depth = 1) {
+	for (const item of iterator) if (depth >= 1 && item && typeof item === "object" && Symbol.iterator in item) yield* flat(item, depth - 1);
+	else yield item;
+}
+//#endregion
+exports.flat = flat;

package/dist/generator/flat.d.ts

@@ -0,0 +1,2 @@
+import { FlatIterator } from './types';
+export declare function flat<const GenericItem extends unknown, const GenericDepth extends number = 1>(iterator: Iterable<GenericItem>, depth?: GenericDepth): Generator<FlatIterator<GenericItem, GenericDepth>, void, unknown>;

package/dist/generator/flat.mjs

@@ -0,0 +1,7 @@
+//#region scripts/generator/flat.ts
+function* flat(iterator, depth = 1) {
+	for (const item of iterator) if (depth >= 1 && item && typeof item === "object" && Symbol.iterator in item) yield* flat(item, depth - 1);
+	else yield item;
+}
+//#endregion
+export { flat };

package/dist/generator/group.cjs

@@ -0,0 +1,34 @@
+//#region scripts/generator/group.ts
+function groupOutput(...args) {
+	if (args.length === 1) {
+		const [group] = args;
+		return (value) => groupOutput(group, value);
+	}
+	const [group, value] = args;
+	return {
+		group,
+		value
+	};
+}
+function group(...args) {
+	if (args.length === 1) {
+		const [theFunction] = args;
+		return (iterator) => group(iterator, theFunction);
+	}
+	const [iterator, theFunction] = args;
+	const result = {};
+	let index = 0;
+	for (const item of iterator) {
+		const { group, value } = theFunction(item, {
+			index,
+			output: groupOutput
+		});
+		if (result[group]) result[group].push(value);
+		else result[group] = [value];
+		index++;
+	}
+	return result;
+}
+//#endregion
+exports.group = group;
+exports.groupOutput = groupOutput;

package/dist/generator/group.d.ts

@@ -0,0 +1,16 @@
+import type * as DCommon from '../common';
+export interface GroupOutputResult<GenericGroupName extends string = string, GenericGroupValue extends unknown = unknown> {
+    group: GenericGroupName;
+    value: GenericGroupValue;
+}
+export declare function groupOutput<const GenericGroupName extends string, GenericGroupValue extends unknown>(group: GenericGroupName): (value: GenericGroupValue) => GroupOutputResult<GenericGroupName, GenericGroupValue>;
+export declare function groupOutput<const GenericGroupName extends string, GenericGroupValue extends unknown>(group: GenericGroupName, value: GenericGroupValue): GroupOutputResult<GenericGroupName, GenericGroupValue>;
+export interface GroupTheFunctionParams {
+    index: number;
+    output: typeof groupOutput;
+}
+export type GroupResult<GenericOutput extends GroupOutputResult> = DCommon.SimplifyTopLevel<{
+    readonly [Output in GenericOutput as Output["group"]]?: readonly [Output["value"], ...Output["value"][]];
+}>;
+export declare function group<GenericItem extends unknown, GenericOutput extends GroupOutputResult>(theFunction: (item: GenericItem, params: GroupTheFunctionParams) => GenericOutput): (iterator: Iterable<GenericItem>) => GroupResult<GenericOutput>;
+export declare function group<GenericItem extends unknown, GenericOutput extends GroupOutputResult>(iterator: Iterable<GenericItem>, theFunction: (item: GenericItem, params: GroupTheFunctionParams) => GenericOutput): GroupResult<GenericOutput>;