@dangayle/rustlike 0.1.0

package/dist/async-iter-aLdg-qp2.mjs

@@ -0,0 +1,1009 @@
+//#region src/core.ts
+const PANIC_STRING_MAX_LENGTH = 200;
+function toPanicString(value) {
+	let str;
+	if (value instanceof Error) str = value.message;
+	else try {
+		str = JSON.stringify(value);
+	} catch {
+		str = String(value);
+	}
+	if (str.length > PANIC_STRING_MAX_LENGTH) return str.slice(0, PANIC_STRING_MAX_LENGTH) + "...";
+	return str;
+}
+var SomeImpl = class SomeImpl {
+	constructor(value) {
+		this.value = value;
+		this.some = true;
+	}
+	map(fn) {
+		return new SomeImpl(fn(this.value));
+	}
+	mapOr(_defaultValue, fn) {
+		return fn(this.value);
+	}
+	mapOrElse(_defaultFn, fn) {
+		return fn(this.value);
+	}
+	andThen(fn) {
+		return fn(this.value);
+	}
+	and(other) {
+		return other;
+	}
+	or(_other) {
+		return this;
+	}
+	orElse(_fn) {
+		return this;
+	}
+	xor(other) {
+		return other.isSome() ? NoneValue : this;
+	}
+	filter(predicate) {
+		return predicate(this.value) ? this : NoneValue;
+	}
+	contains(value) {
+		return this.value === value;
+	}
+	unwrap() {
+		return this.value;
+	}
+	unwrapOr(_defaultValue) {
+		return this.value;
+	}
+	unwrapOrElse(_fn) {
+		return this.value;
+	}
+	expect(_message) {
+		return this.value;
+	}
+	match(handlers) {
+		return handlers.some(this.value);
+	}
+	okOr(_error) {
+		return new OkImpl(this.value);
+	}
+	zip(other) {
+		return other.isSome() ? new SomeImpl([this.value, other.value]) : NoneValue;
+	}
+	flatten() {
+		return this.unwrap();
+	}
+	inspect(fn) {
+		fn(this.value);
+		return this;
+	}
+	isSome() {
+		return true;
+	}
+	isNone() {
+		return false;
+	}
+};
+var NoneImpl = class {
+	constructor() {
+		this.some = false;
+	}
+	map(_fn) {
+		return this;
+	}
+	mapOr(defaultValue, _fn) {
+		return defaultValue;
+	}
+	mapOrElse(defaultFn, _fn) {
+		return defaultFn();
+	}
+	andThen(_fn) {
+		return this;
+	}
+	and(_other) {
+		return this;
+	}
+	or(other) {
+		return other;
+	}
+	orElse(fn) {
+		return fn();
+	}
+	xor(other) {
+		return other;
+	}
+	filter(_predicate) {
+		return this;
+	}
+	contains(_value) {
+		return false;
+	}
+	unwrap() {
+		throw new Error("Called unwrap on None");
+	}
+	unwrapOr(defaultValue) {
+		return defaultValue;
+	}
+	unwrapOrElse(fn) {
+		return fn();
+	}
+	expect(message) {
+		throw new Error(message);
+	}
+	match(handlers) {
+		return handlers.none();
+	}
+	okOr(error) {
+		return new ErrImpl(error);
+	}
+	zip(_other) {
+		return this;
+	}
+	flatten() {
+		return this;
+	}
+	inspect(_fn) {
+		return this;
+	}
+	isSome() {
+		return false;
+	}
+	isNone() {
+		return true;
+	}
+};
+const NoneValue = Object.freeze(new NoneImpl());
+var OkImpl = class OkImpl {
+	constructor(value) {
+		this.value = value;
+		this.ok = true;
+	}
+	map(fn) {
+		return new OkImpl(fn(this.value));
+	}
+	mapOr(_defaultValue, fn) {
+		return fn(this.value);
+	}
+	mapOrElse(_defaultFn, fn) {
+		return fn(this.value);
+	}
+	mapErr(_fn) {
+		return this;
+	}
+	andThen(fn) {
+		return fn(this.value);
+	}
+	and(other) {
+		return other;
+	}
+	or(_other) {
+		return this;
+	}
+	orElse(_fn) {
+		return this;
+	}
+	contains(value) {
+		return this.value === value;
+	}
+	containsErr(_error) {
+		return false;
+	}
+	unwrap() {
+		return this.value;
+	}
+	unwrapOr(_defaultValue) {
+		return this.value;
+	}
+	unwrapOrElse(_fn) {
+		return this.value;
+	}
+	expect(_message) {
+		return this.value;
+	}
+	unwrapErr() {
+		throw new Error(`Called unwrapErr on Ok: ${toPanicString(this.value)}`);
+	}
+	expectErr(message) {
+		throw new Error(`${message}: ${toPanicString(this.value)}`);
+	}
+	match(handlers) {
+		return handlers.ok(this.value);
+	}
+	toOption() {
+		return new SomeImpl(this.value);
+	}
+	err() {
+		return NoneValue;
+	}
+	flatten() {
+		return this.unwrap();
+	}
+	inspect(fn) {
+		fn(this.value);
+		return this;
+	}
+	inspectErr(_fn) {
+		return this;
+	}
+	isOk() {
+		return true;
+	}
+	isErr() {
+		return false;
+	}
+};
+var ErrImpl = class ErrImpl {
+	constructor(error) {
+		this.error = error;
+		this.ok = false;
+	}
+	map(_fn) {
+		return this;
+	}
+	mapOr(defaultValue, _fn) {
+		return defaultValue;
+	}
+	mapOrElse(defaultFn, _fn) {
+		return defaultFn(this.error);
+	}
+	mapErr(fn) {
+		return new ErrImpl(fn(this.error));
+	}
+	andThen(_fn) {
+		return this;
+	}
+	and(_other) {
+		return this;
+	}
+	or(other) {
+		return other;
+	}
+	orElse(fn) {
+		return fn(this.error);
+	}
+	contains(_value) {
+		return false;
+	}
+	containsErr(error) {
+		return this.error === error;
+	}
+	unwrap() {
+		throw new Error(`Called unwrap on Err: ${toPanicString(this.error)}`);
+	}
+	unwrapOr(defaultValue) {
+		return defaultValue;
+	}
+	unwrapOrElse(fn) {
+		return fn(this.error);
+	}
+	expect(message) {
+		throw new Error(`${message}: ${toPanicString(this.error)}`);
+	}
+	unwrapErr() {
+		return this.error;
+	}
+	expectErr(_message) {
+		return this.error;
+	}
+	match(handlers) {
+		return handlers.err(this.error);
+	}
+	toOption() {
+		return NoneValue;
+	}
+	err() {
+		return new SomeImpl(this.error);
+	}
+	flatten() {
+		return this;
+	}
+	inspect(_fn) {
+		return this;
+	}
+	inspectErr(fn) {
+		fn(this.error);
+		return this;
+	}
+	isOk() {
+		return false;
+	}
+	isErr() {
+		return true;
+	}
+};
+const Some = (value) => new SomeImpl(value);
+const None = NoneValue;
+const Ok = (value) => new OkImpl(value);
+const Err = (error) => new ErrImpl(error);
+const isSome = (option) => option.some;
+const isNone = (option) => !option.some;
+const isOk = (result) => result.ok;
+const isErr = (result) => !result.ok;
+const Option = {
+	some: Some,
+	none: None,
+	isSome,
+	isNone,
+	from: (value) => value != null ? Some(value) : None,
+	map: (option, fn) => option.map(fn),
+	andThen: (option, fn) => option.andThen(fn),
+	or: (option, other) => option.or(other),
+	orElse: (option, fn) => option.orElse(fn),
+	filter: (option, predicate) => option.some ? option.filter(predicate) : None,
+	unwrap: (option) => option.unwrap(),
+	unwrapOr: (option, defaultValue) => option.unwrapOr(defaultValue),
+	unwrapOrElse: (option, fn) => option.unwrapOrElse(fn),
+	match: (option, handlers) => option.match(handlers),
+	zip: (a, b) => a.zip(b),
+	okOr: (option, error) => option.some ? Ok(option.value) : Err(error),
+	flatten: (option) => option.flatten(),
+	transpose: (option) => {
+		if (option.isSome()) {
+			const val = option.unwrap();
+			if (val.isOk()) return Ok(Some(val.unwrap()));
+			else return Err(val.unwrapErr());
+		}
+		return Ok(None);
+	},
+	all: (options) => {
+		const values = [];
+		for (const option of options) {
+			if (option.isNone()) return None;
+			values.push(option.value);
+		}
+		return Some(values);
+	},
+	collect: (options) => Option.all(options)
+};
+const Result = {
+	ok: Ok,
+	err: Err,
+	isOk,
+	isErr,
+	map: (result, fn) => result.map(fn),
+	mapErr: (result, fn) => result.mapErr(fn),
+	andThen: (result, fn) => result.andThen(fn),
+	orElse: (result, fn) => result.orElse(fn),
+	unwrap: (result) => result.unwrap(),
+	unwrapOr: (result, defaultValue) => result.unwrapOr(defaultValue),
+	unwrapOrElse: (result, fn) => result.unwrapOrElse(fn),
+	unwrapErr: (result) => result.unwrapErr(),
+	expectErr: (result, message) => result.expectErr(message),
+	match: (result, handlers) => result.match(handlers),
+	toOption: (result) => result.toOption(),
+	fromThrowable: (fn) => {
+		try {
+			return Ok(fn());
+		} catch (e) {
+			return Err(e);
+		}
+	},
+	fromPromise: async (promise) => {
+		try {
+			return Ok(await promise);
+		} catch (e) {
+			return Err(e);
+		}
+	},
+	flatten: (result) => result.flatten(),
+	transpose: (result) => {
+		if (result.isOk()) {
+			const val = result.unwrap();
+			if (val.isSome()) return Some(Ok(val.unwrap()));
+			else return None;
+		}
+		return Some(Err(result.unwrapErr()));
+	},
+	all: (results) => {
+		const values = [];
+		for (const result of results) {
+			if (result.isErr()) return result;
+			values.push(result.value);
+		}
+		return Ok(values);
+	},
+	collect: (results) => Result.all(results)
+};
+
+//#endregion
+//#region src/iter.ts
+/**
+* Lazy Iterator: Iter<T>
+*
+* Rust-like lazy iterator wrappers around JavaScript's native Iterator protocol.
+* Enables composable, memory-efficient data processing pipelines.
+*/
+const EMPTY_PEEK = Object.freeze({
+	has: false,
+	value: void 0
+});
+/**
+* Core iterator implementation using idiomatic TypeScript.
+* Uses generator functions internally for lazy evaluation.
+*/
+var IterImpl = class IterImpl {
+	constructor(source) {
+		this.peeked = EMPTY_PEEK;
+		this.source = source;
+	}
+	map(fn) {
+		const source = this;
+		return new IterImpl((function* () {
+			for (const value of source) yield fn(value);
+		})());
+	}
+	filter(pred) {
+		const source = this;
+		return new IterImpl((function* () {
+			for (const value of source) if (pred(value)) yield value;
+		})());
+	}
+	flatMap(fn) {
+		const source = this;
+		return new IterImpl((function* () {
+			for (const value of source) for (const inner of fn(value)) yield inner;
+		})());
+	}
+	inspect(fn) {
+		const source = this;
+		return new IterImpl((function* () {
+			for (const value of source) {
+				fn(value);
+				yield value;
+			}
+		})());
+	}
+	peekable() {
+		return this;
+	}
+	find(pred) {
+		for (const value of this) if (pred(value)) return Some(value);
+		return None;
+	}
+	findMap(fn) {
+		for (const value of this) {
+			const result = fn(value);
+			if (result.isSome()) return result;
+		}
+		return None;
+	}
+	any(pred) {
+		for (const value of this) if (pred(value)) return true;
+		return false;
+	}
+	all(pred) {
+		for (const value of this) if (!pred(value)) return false;
+		return true;
+	}
+	position(pred) {
+		let index = 0;
+		for (const value of this) {
+			if (pred(value)) return Some(index);
+			index++;
+		}
+		return None;
+	}
+	fold(init, fn) {
+		let acc = init;
+		for (const value of this) acc = fn(acc, value);
+		return acc;
+	}
+	reduce(fn) {
+		const first = this.next();
+		if (first.done) return None;
+		let acc = first.value;
+		for (const value of this) acc = fn(acc, value);
+		return Some(acc);
+	}
+	tryFold(init, fn) {
+		let acc = init;
+		for (const value of this) {
+			const result = fn(acc, value);
+			if (result.isErr()) return result;
+			acc = result.value;
+		}
+		return Ok(acc);
+	}
+	count() {
+		let n = 0;
+		for (const _value of this) n++;
+		return n;
+	}
+	last() {
+		let last = None;
+		for (const value of this) last = Some(value);
+		return last;
+	}
+	nth(n) {
+		if (n < 0) return None;
+		let index = 0;
+		for (const value of this) {
+			if (index === n) return Some(value);
+			index++;
+		}
+		return None;
+	}
+	partition(pred) {
+		const matching = [];
+		const rest = [];
+		for (const value of this) if (pred(value)) matching.push(value);
+		else rest.push(value);
+		return [matching, rest];
+	}
+	tryMap(fn) {
+		return this.map(fn);
+	}
+	take(n) {
+		const source = this;
+		return new IterImpl((function* () {
+			let count = 0;
+			const iterator = source[Symbol.iterator]();
+			while (count < n) {
+				const result = iterator.next();
+				if (result.done) break;
+				yield result.value;
+				count++;
+			}
+		})());
+	}
+	skip(n) {
+		const source = this;
+		return new IterImpl((function* () {
+			let count = 0;
+			for (const value of source) {
+				if (count < n) {
+					count++;
+					continue;
+				}
+				yield value;
+			}
+		})());
+	}
+	stepBy(step) {
+		if (step <= 0) throw new Error("Iter.stepBy: step must be positive");
+		const source = this;
+		return new IterImpl((function* () {
+			let index = 0;
+			for (const value of source) {
+				if (index % step === 0) yield value;
+				index++;
+			}
+		})());
+	}
+	enumerate() {
+		const source = this;
+		return new IterImpl((function* () {
+			let index = 0;
+			for (const value of source) {
+				yield [index, value];
+				index++;
+			}
+		})());
+	}
+	zip(other) {
+		const source = this;
+		return new IterImpl((function* () {
+			const otherIter = other[Symbol.iterator]();
+			for (const value of source) {
+				const otherResult = otherIter.next();
+				if (otherResult.done) break;
+				yield [value, otherResult.value];
+			}
+		})());
+	}
+	chain(other) {
+		const source = this;
+		return new IterImpl((function* () {
+			for (const value of source) yield value;
+			for (const value of other) yield value;
+		})());
+	}
+	flatten() {
+		const source = this;
+		return new IterImpl((function* () {
+			for (const inner of source) for (const value of inner) yield value;
+		})());
+	}
+	peek() {
+		if (this.peeked.has) return Some(this.peeked.value);
+		const result = this.source.next();
+		if (result.done) return None;
+		this.peeked = {
+			has: true,
+			value: result.value
+		};
+		return Some(result.value);
+	}
+	collectResult() {
+		const out = [];
+		for (const item of this) {
+			if (item.isErr()) return Err(item.error);
+			out.push(item.value);
+		}
+		return Ok(out);
+	}
+	forEach(fn) {
+		for (const value of this) fn(value);
+	}
+	collect() {
+		const result = [];
+		for (const value of this) result.push(value);
+		return result;
+	}
+	[Symbol.iterator]() {
+		return this;
+	}
+	next() {
+		if (this.peeked.has) {
+			const value = this.peeked.value;
+			this.peeked = EMPTY_PEEK;
+			return {
+				done: false,
+				value
+			};
+		}
+		return this.source.next();
+	}
+};
+/**
+* Create an Iter from an iterator or iterable source.
+*
+* @example
+* const numbers = iter([1, 2, 3, 4, 5]);
+* const doubled = numbers.map(x => x * 2).collect();
+*/
+function iter(source) {
+	if (Symbol.iterator in source) return new IterImpl(source[Symbol.iterator]());
+	return new IterImpl(source);
+}
+/**
+* Create an Iter from an array.
+* Convenience function for the common case of iterating over arrays.
+*
+* @example
+* const items = iterFromArray(['a', 'b', 'c']);
+*/
+function iterFromArray(arr) {
+	return new IterImpl(arr[Symbol.iterator]());
+}
+/**
+* Create an Iter from a generator function.
+* Useful for creating custom lazy sequences.
+*
+* @example
+* const naturals = iterFromGenerator(function* () {
+*   let n = 0;
+*   while (true) yield n++;
+* });
+* const firstTen = naturals.take(10).collect();
+*/
+function iterFromGenerator(gen) {
+	return new IterImpl(gen());
+}
+const Iter = {
+	from: iter,
+	fromArray: iterFromArray,
+	fromGenerator: iterFromGenerator,
+	empty: () => new IterImpl((function* () {})()),
+	once: (value) => new IterImpl((function* () {
+		yield value;
+	})()),
+	repeat: (value, n) => new IterImpl((function* () {
+		for (let i = 0; i < n; i++) yield value;
+	})()),
+	range: (start, end, step = 1) => new IterImpl((function* () {
+		if (step === 0) throw new Error("Iter.range: step must be non-zero");
+		for (let i = start; step > 0 ? i < end : i > end; i += step) yield i;
+	})()),
+	sum: (iterator) => iterator.fold(0, (acc, x) => acc + x),
+	product: (iterator) => iterator.fold(1, (acc, x) => acc * x),
+	min: (iterator) => iterator.reduce((a, b) => a <= b ? a : b),
+	max: (iterator) => iterator.reduce((a, b) => a >= b ? a : b)
+};
+
+//#endregion
+//#region src/async-iter.ts
+/**
+* Async Lazy Iterator: AsyncIter<T>
+*
+* Rust-like async lazy iterator wrapper around JavaScript's native AsyncIterator protocol.
+* Enables composable, memory-efficient async data processing pipelines.
+*/
+/**
+* Core async iterator implementation using idiomatic TypeScript.
+* Uses async generator functions internally for lazy evaluation.
+*/
+var AsyncIterImpl = class AsyncIterImpl {
+	constructor(source) {
+		this.peeked = null;
+		this.source = source;
+	}
+	map(fn) {
+		const source = this;
+		return new AsyncIterImpl((async function* () {
+			for await (const value of source) yield await fn(value);
+		})());
+	}
+	filter(pred) {
+		const source = this;
+		return new AsyncIterImpl((async function* () {
+			for await (const value of source) if (await pred(value)) yield value;
+		})());
+	}
+	flatMap(fn) {
+		const source = this;
+		return new AsyncIterImpl((async function* () {
+			for await (const value of source) {
+				const inner = fn(value);
+				if (Symbol.asyncIterator in inner) for await (const item of inner) yield item;
+				else for (const item of inner) yield item;
+			}
+		})());
+	}
+	inspect(fn) {
+		const source = this;
+		return new AsyncIterImpl((async function* () {
+			for await (const value of source) {
+				await fn(value);
+				yield value;
+			}
+		})());
+	}
+	peekable() {
+		return this;
+	}
+	async find(pred) {
+		for await (const value of this) if (await pred(value)) return Some(value);
+		return None;
+	}
+	async findMap(fn) {
+		for await (const value of this) {
+			const result = await fn(value);
+			if (result.isSome()) return result;
+		}
+		return None;
+	}
+	async any(pred) {
+		for await (const value of this) if (await pred(value)) return true;
+		return false;
+	}
+	async all(pred) {
+		for await (const value of this) if (!await pred(value)) return false;
+		return true;
+	}
+	async position(pred) {
+		let index = 0;
+		for await (const value of this) {
+			if (await pred(value)) return Some(index);
+			index++;
+		}
+		return None;
+	}
+	async fold(init, fn) {
+		let acc = init;
+		for await (const value of this) acc = await fn(acc, value);
+		return acc;
+	}
+	async reduce(fn) {
+		const first = await this.next();
+		if (first.done) return None;
+		let acc = first.value;
+		for await (const value of this) acc = await fn(acc, value);
+		return Some(acc);
+	}
+	async tryFold(init, fn) {
+		let acc = init;
+		for await (const value of this) {
+			const result = await fn(acc, value);
+			if (result.isErr()) return result;
+			acc = result.value;
+		}
+		return Ok(acc);
+	}
+	async count() {
+		let n = 0;
+		for await (const _value of this) n++;
+		return n;
+	}
+	async last() {
+		let last = None;
+		for await (const value of this) last = Some(value);
+		return last;
+	}
+	async nth(n) {
+		if (n < 0) return None;
+		let index = 0;
+		for await (const value of this) {
+			if (index === n) return Some(value);
+			index++;
+		}
+		return None;
+	}
+	async partition(pred) {
+		const matching = [];
+		const rest = [];
+		for await (const value of this) if (await pred(value)) matching.push(value);
+		else rest.push(value);
+		return [matching, rest];
+	}
+	tryMap(fn) {
+		return this.map(fn);
+	}
+	take(n) {
+		const source = this;
+		return new AsyncIterImpl((async function* () {
+			let count = 0;
+			const iterator = source[Symbol.asyncIterator]();
+			while (count < n) {
+				const result = await iterator.next();
+				if (result.done) break;
+				yield result.value;
+				count++;
+			}
+		})());
+	}
+	skip(n) {
+		const source = this;
+		return new AsyncIterImpl((async function* () {
+			let count = 0;
+			for await (const value of source) {
+				if (count < n) {
+					count++;
+					continue;
+				}
+				yield value;
+			}
+		})());
+	}
+	stepBy(step) {
+		if (step <= 0) throw new Error("AsyncIter.stepBy: step must be positive");
+		const source = this;
+		return new AsyncIterImpl((async function* () {
+			let index = 0;
+			for await (const value of source) {
+				if (index % step === 0) yield value;
+				index++;
+			}
+		})());
+	}
+	enumerate() {
+		const source = this;
+		return new AsyncIterImpl((async function* () {
+			let index = 0;
+			for await (const value of source) {
+				yield [index, value];
+				index++;
+			}
+		})());
+	}
+	zip(other) {
+		const source = this;
+		return new AsyncIterImpl((async function* () {
+			const otherIter = other[Symbol.asyncIterator]();
+			for await (const value of source) {
+				const otherResult = await otherIter.next();
+				if (otherResult.done) break;
+				yield [value, otherResult.value];
+			}
+		})());
+	}
+	chain(other) {
+		const source = this;
+		return new AsyncIterImpl((async function* () {
+			for await (const value of source) yield value;
+			for await (const value of other) yield value;
+		})());
+	}
+	flatten() {
+		const source = this;
+		return new AsyncIterImpl((async function* () {
+			for await (const inner of source) if (Symbol.asyncIterator in inner) for await (const value of inner) yield value;
+			else for (const value of inner) yield value;
+		})());
+	}
+	async peek() {
+		this.peeked ??= this.source.next();
+		const result = await this.peeked;
+		if (result.done) return None;
+		return Some(result.value);
+	}
+	async collectResult() {
+		const out = [];
+		for await (const item of this) {
+			if (item.isErr()) return Err(item.error);
+			out.push(item.value);
+		}
+		return Ok(out);
+	}
+	async forEach(fn) {
+		for await (const value of this) await fn(value);
+	}
+	async collect() {
+		const result = [];
+		for await (const value of this) result.push(value);
+		return result;
+	}
+	[Symbol.asyncIterator]() {
+		return this;
+	}
+	next() {
+		if (this.peeked) {
+			const promise = this.peeked;
+			this.peeked = null;
+			return promise;
+		}
+		return this.source.next();
+	}
+};
+/**
+* Create an AsyncIter from an async iterator or async iterable source.
+*
+* @example
+* const items = asyncIter(fetchPages());
+* const processed = await items.map(processPage).collect();
+*/
+function asyncIter(source) {
+	if (Symbol.asyncIterator in source) return new AsyncIterImpl(source[Symbol.asyncIterator]());
+	return new AsyncIterImpl(source);
+}
+/**
+* Create an AsyncIter from a sync iterable.
+* Useful for lifting sync data into async pipelines.
+*
+* @example
+* const items = asyncIterFromIterable([1, 2, 3]);
+*/
+function asyncIterFromIterable(source) {
+	return new AsyncIterImpl((async function* () {
+		for (const value of source) yield value;
+	})());
+}
+/**
+* Create an AsyncIter from an array.
+* Convenience function for the common case.
+*
+* @example
+* const items = asyncIterFromArray(['a', 'b', 'c']);
+*/
+function asyncIterFromArray(arr) {
+	return asyncIterFromIterable(arr);
+}
+/**
+* Create an AsyncIter from an async generator function.
+* Useful for creating custom lazy async sequences.
+*
+* @example
+* const pages = asyncIterFromGenerator(async function* () {
+*   let page = 1;
+*   while (true) {
+*     const data = await fetchPage(page++);
+*     if (data.length === 0) break;
+*     yield data;
+*   }
+* });
+*/
+function asyncIterFromGenerator(gen) {
+	return new AsyncIterImpl(gen());
+}
+const AsyncIter = {
+	from: asyncIter,
+	fromIterable: asyncIterFromIterable,
+	fromArray: asyncIterFromArray,
+	fromGenerator: asyncIterFromGenerator,
+	empty: () => new AsyncIterImpl((async function* () {})()),
+	once: (value) => new AsyncIterImpl((async function* () {
+		yield value;
+	})()),
+	repeat: (value, n) => new AsyncIterImpl((async function* () {
+		for (let i = 0; i < n; i++) yield value;
+	})()),
+	range: (start, end, step = 1) => new AsyncIterImpl((async function* () {
+		if (step === 0) throw new Error("AsyncIter.range: step must be non-zero");
+		for (let i = start; step > 0 ? i < end : i > end; i += step) yield i;
+	})()),
+	sum: (iterator) => iterator.fold(0, (acc, x) => acc + x),
+	product: (iterator) => iterator.fold(1, (acc, x) => acc * x),
+	min: (iterator) => iterator.reduce((a, b) => a <= b ? a : b),
+	max: (iterator) => iterator.reduce((a, b) => a >= b ? a : b)
+};
+
+//#endregion
+export { isNone as _, asyncIterFromIterable as a, toPanicString as b, iterFromArray as c, None as d, Ok as f, isErr as g, Some as h, asyncIterFromGenerator as i, iterFromGenerator as l, Result as m, asyncIter as n, Iter as o, Option as p, asyncIterFromArray as r, iter as s, AsyncIter as t, Err as u, isOk as v, isSome as y };
+//# sourceMappingURL=async-iter-aLdg-qp2.mjs.map