@mirei/ts-collections/dist/index.mjs

A collection of wrappers for common data structures in TypeScript

//#region src/shared/Comparators.ts
var e = class {
	/* istanbul ignore next */
	constructor() {}
	static equalityComparator = (e, t) => Object.is(e, t);
	static orderComparator = (e, t) => e === t ? 0 : e > t ? 1 : -1;
	static reverseOrderComparator = (e, t) => e === t ? 0 : e > t ? -1 : 1;
}, t = class {
	key;
	value;
	constructor(e, t) {
		this.key = e, this.value = t;
	}
	equals(t, n, r) {
		return n ??= e.equalityComparator, r ??= e.equalityComparator, n(this.key, t.key) && r(this.value, t.value);
	}
}, n = class extends Error {
	constructor(e = "Dimensions do not match.") {
		super(e);
	}
}, r = class extends Error {
	constructor(e = "Index is out of bounds.") {
		super(typeof e == "number" ? `Index ${e} is out of bounds.` : e);
	}
}, i = class extends Error {
	constructor(e = "Sequence contains insufficient elements.") {
		super(e);
	}
}, a = class extends Error {
	constructor(e, t) {
		t && (e = `Invalid argument: ${t}. ${e}`), super(e);
	}
}, o = class extends Error {
	constructor(e = "Sequence contains more than one element.") {
		super(e);
	}
}, s = class extends Error {
	constructor(e = "Sequence contains more than one matching element.") {
		super(e);
	}
}, c = class extends Error {
	constructor(e = "Sequence contains no elements.") {
		super(e);
	}
}, l = class extends Error {
	constructor(e = "Sequence contains no matching element.") {
		super(e);
	}
}, u = class extends Number {
	static [Symbol.hasInstance] = (e) => typeof e == "number";
}, ee = class extends String {
	static [Symbol.hasInstance] = (e) => typeof e == "string";
}, te = class extends Boolean {
	static [Symbol.hasInstance] = (e) => typeof e == "boolean";
}, ne = class extends Object {
	static [Symbol.hasInstance] = (e) => typeof e == "object";
}, re = class {
	static [Symbol.hasInstance] = (e) => typeof e == "bigint";
}, ie = class {
	static [Symbol.hasInstance] = (e) => typeof e == "symbol";
}, ae = (e) => {
	let t = e.name;
	return t === "Number" ? u : t === "String" ? ee : t === "Boolean" ? te : t === "BigInt" ? re : t === "Object" ? ne : t === "Symbol" ? ie : e;
}, d = (e, t, n) => {
	let i = e instanceof Array ? e.length : e.size();
	if (t < 0 || t >= i) throw new r(t);
	if (n < 0 || n >= i) throw new r(n);
	if (e instanceof Array) {
		[e[t], e[n]] = [e[n], e[t]];
		return;
	}
	let a = e.get(t);
	e.set(t, e.get(n)), e.set(n, a);
}, oe = (e) => {
	let t = e instanceof Array ? e.length : e.size(), n = (e, t) => Math.floor(Math.random() * (t - e)) + e;
	for (let r = t; r > 1; --r) d(e, r - 1, n(0, r));
}, se = (e, t, n) => {
	for (let r of e) if (n(r.key, t)) return r.group;
	let r = [];
	return e.push({
		key: t,
		group: r
	}), r;
}, ce = (e, t, n) => {
	for (let r of e) if (n(r.key, t)) return r.group;
	return null;
}, le = (e, t, n, r) => {
	let i = n(e), a = !1;
	for (let n of t) if (r(i, n.key)) {
		n.elements.push(e), a = !0;
		break;
	}
	a || t.push({
		key: i,
		elements: [e]
	});
}, ue = (e, t, n) => {
	let r = [];
	if (!e) return r;
	for (let i of e) le(i, r, t, n);
	return r;
}, de = async (e, t, n) => {
	let r = [];
	if (!e) return r;
	for await (let i of e) le(i, r, t, n);
	return r;
}, fe = function* (e, t, n, r, i, a) {
	let o = !1;
	for (let a of n) if (r(t, a.key)) for (let t of a.elements) yield i(e, t), o = !0;
	a && !o && (yield i(e, null));
};
//#endregion
//#region src/enumerator/helpers/medianHelpers.ts
function pe(e, t = "interpolate") {
	if (e.length < 1) return NaN;
	if (e.length & 1) return f(e, e.length >> 1);
	let n = (e.length >> 1) - 1, r = n + 1, i = f(e, n), a = f(e, r);
	switch (t) {
		case "low": return i;
		case "high": return a;
		default: return (i + a) / 2;
	}
}
function f(e, t) {
	let n = 0, r = e.length - 1;
	for (; n <= r;) {
		let i = n + r >>> 1, a = me(e, n, i, r), o = e[a];
		d(e, a, r);
		let s = n;
		for (let t = n; t < r; t++) e[t] < o && d(e, t, s++);
		if (d(e, s, r), s === t) return e[s];
		s < t ? n = s + 1 : r = s - 1;
	}
	return NaN;
}
function me(e, t, n, r) {
	let i = e[t], a = e[n], o = e[r];
	return i < a ? a < o ? n : i < o ? r : t : i < o ? t : a < o ? r : n;
}
//#endregion
//#region src/enumerator/helpers/percentileHelpers.ts
function he(e, t, n = "linear") {
	if (e.length === 0) return NaN;
	if (e.length === 1) return e[0];
	if (t <= 0) return f(e, 0);
	if (t >= 1) return f(e, e.length - 1);
	let r = (e.length - 1) * t;
	switch (n) {
		case "nearest": return f(e, Math.round(r));
		case "low": return f(e, Math.floor(r));
		case "high": return f(e, Math.ceil(r));
		case "midpoint": {
			let t = Math.floor(r), n = Math.ceil(r);
			return (f(e, t) + f(e, n)) / 2;
		}
		default: {
			let t = Math.floor(r), n = t + 1;
			if (n >= e.length) return f(e, t);
			let i = f(e, t), a = f(e, n);
			return i + (r - t) * (a - i);
		}
	}
}
//#endregion
//#region src/enumerator/functions/empty.ts
var ge = () => y.empty(), _e = function* (e, t) {
	let n = e.length, r = t ?? n;
	if (r < 0 || r > n) throw new a("Invalid permutation size.", "size");
	if (r === 0 || n === 0) return yield ge();
	let i = Array(n).fill(!1), o = Array(r);
	function* s(t) {
		if (t === r) return yield b(o);
		for (let r = 0; r < n; r++) i[r] || (i[r] = !0, o[t] = e[r], yield* s(t + 1), i[r] = !1);
	}
	yield* s(0);
}, ve = (e) => e, p = (e) => e ?? ve, ye = () => {
	let e = {
		count: 0,
		sumSqX: 0,
		sumSqY: 0,
		sumSqXY: 0
	}, t = 0, n = 0;
	return {
		stats: e,
		add(r, i) {
			e.count += 1;
			let a = r - t;
			t += a / e.count;
			let o = i - n;
			n += o / e.count, e.sumSqX += a * (r - t), e.sumSqY += o * (i - n), e.sumSqXY += a * (i - n);
		}
	};
}, be = () => {
	let e = {
		count: 0,
		sumSq: 0
	}, t = 0;
	return {
		stats: e,
		add(n) {
			e.count += 1;
			let r = n - t;
			t += r / e.count, e.sumSq += r * (n - t);
		}
	};
}, xe = (e, t, n, r, i) => {
	let a = e[Symbol.iterator](), o = t[Symbol.iterator](), s = ye();
	for (;;) {
		let e = a.next(), t = o.next();
		if (e.done && t.done) break;
		if (e.done !== t.done) throw i;
		s.add(n(e.value), r(t.value));
	}
	return s.stats;
}, Se = (e, t, n) => {
	let r = ye();
	for (let i of e) r.add(t(i), n(i));
	return r.stats;
}, Ce = (e, t) => {
	let n = be();
	for (let r of e) n.add(t(r));
	return n.stats;
}, we = async (e, t, n, r, i) => {
	let a = e[Symbol.asyncIterator](), o = t[Symbol.asyncIterator](), s = ye();
	for (;;) {
		let [e, t] = await Promise.all([a.next(), o.next()]);
		if (e.done && t.done) break;
		if (e.done !== t.done) throw i;
		s.add(n(e.value), r(t.value));
	}
	return s.stats;
}, Te = async (e, t, n) => {
	let r = ye();
	for await (let i of e) r.add(t(i), n(i));
	return r.stats;
}, Ee = async (e, t) => {
	let n = be();
	for await (let r of e) n.add(t(r));
	return n.stats;
}, De = (e) => {
	if (e.count < 2) throw new i("Correlation requires at least two pairs of elements.");
	let t = Math.max(e.sumSqX, 0), n = Math.max(e.sumSqY, 0), r = Math.sqrt(t * n);
	if (r === 0) throw Error("Correlation is undefined when the standard deviation of either variable is zero.");
	return e.sumSqXY / r;
}, m = class u {
	#e = Symbol("-0");
	#t = (e) => Object.is(e, -0) ? this.#e : e;
	static DIMENSION_MISMATCH_EXCEPTION = new n();
	static MORE_THAN_ONE_ELEMENT_EXCEPTION = new o();
	static MORE_THAN_ONE_MATCHING_ELEMENT_EXCEPTION = new s();
	static NO_ELEMENTS_EXCEPTION = new c();
	static NO_MATCHING_ELEMENT_EXCEPTION = new l();
	constructor(e) {
		this.iterable = e;
	}
	*[Symbol.iterator]() {
		yield* this.iterable();
	}
	aggregate(e, t, n) {
		let r;
		if (t == null) {
			let t = this[Symbol.iterator](), n = t.next();
			if (n.done) throw u.NO_ELEMENTS_EXCEPTION;
			r = n.value;
			let i = t.next();
			for (; !i.done;) r = e(r, i.value), i = t.next();
		} else {
			r = t;
			for (let t of this) r = e(r, t);
		}
		return n ? n(r) : r;
	}
	aggregateBy(n, r, i, a) {
		return a ??= e.equalityComparator, this.groupBy(n, a).select((e) => new t(e.key, e.source.aggregate(i, r instanceof Function ? r(e.key) : r)));
	}
	all(e) {
		for (let t of this) if (!e(t)) return !1;
		return !0;
	}
	any(e) {
		if (!e) return !this[Symbol.iterator]().next().done;
		for (let t of this) if (e(t)) return !0;
		return !1;
	}
	append(e) {
		return new u(() => this.appendGenerator(e));
	}
	atLeast(e, t) {
		if (e < 0) throw new a("Count must be greater than or equal to 0.", "count");
		let n = 0;
		for (let r of this) if ((t == null || t(r)) && n++, n >= e) return !0;
		return n >= e;
	}
	atMost(e, t) {
		if (e < 0) throw new a("Count must be greater than or equal to 0.", "count");
		let n = 0;
		for (let r of this) if ((t == null || t(r)) && n++, n > e) return !1;
		return !0;
	}
	average(e) {
		let t = 0, n = 0;
		for (let r of this) t += e?.(r) ?? r, n++;
		if (n === 0) throw u.NO_ELEMENTS_EXCEPTION;
		return t / n;
	}
	cartesian(e) {
		return new u(() => this.cartesianGenerator(e));
	}
	cast() {
		return new u(() => this.castGenerator());
	}
	chunk(e) {
		if (e < 1) throw new a("Size must be greater than 0.", "size");
		return new u(() => this.chunkGenerator(e));
	}
	combinations(e) {
		if (e != null && e < 0) throw new a("Size must be greater than or equal to 0.", "size");
		return new u(() => this.combinationsGenerator(e));
	}
	compact() {
		return new u(() => this.compactGenerator());
	}
	concat(e) {
		return new u(() => this.concatGenerator(e));
	}
	contains(t, n) {
		n ??= e.equalityComparator;
		for (let e of this) if (n(e, t)) return !0;
		return !1;
	}
	correlation(e, t, n) {
		let r = p(t), i = p(n);
		return De(xe(this, e, r, i, u.DIMENSION_MISMATCH_EXCEPTION));
	}
	correlationBy(e, t) {
		return De(Se(this, e, t));
	}
	count(e) {
		let t = 0;
		if (!e) {
			for (let e of this) ++t;
			return t;
		}
		for (let n of this) e(n) && ++t;
		return t;
	}
	countBy(n, r) {
		return r ??= e.equalityComparator, this.groupBy(n, r).select((e) => new t(e.key, e.source.count()));
	}
	covariance(e, t, n, r = !0) {
		let a = p(t), o = p(n), s = xe(this, e, a, o, u.DIMENSION_MISMATCH_EXCEPTION);
		if (s.count < 2) throw new i("Covariance requires at least two pairs of elements.");
		return r ? s.sumSqXY / (s.count - 1) : s.sumSqXY / s.count;
	}
	covarianceBy(e, t, n = !0) {
		let r = Se(this, e, t);
		if (r.count < 2) throw new i("Covariance requires at least two pairs of elements.");
		return n ? r.sumSqXY / (r.count - 1) : r.sumSqXY / r.count;
	}
	cycle(e) {
		return new u(() => this.cycleGenerator(e));
	}
	defaultIfEmpty(e) {
		return new u(() => this.defaultIfEmptyGenerator(e));
	}
	disjoint(t, n) {
		if (n ??= e.equalityComparator, n === e.equalityComparator) {
			let e = new Set(this);
			if (e.size === 0) return !0;
			for (let n of t) if (e.has(n)) return !1;
			return !0;
		}
		let r = Array.from(this);
		if (r.length === 0) return !0;
		for (let e of t) for (let t of r) if (n(t, e)) return !1;
		return !0;
	}
	disjointBy(t, n, r, i) {
		let a = i ?? e.equalityComparator;
		if (a === e.equalityComparator) {
			let e = /* @__PURE__ */ new Set();
			for (let t of this) e.add(n(t));
			if (e.size === 0) return !0;
			let i = y.from(t).select(r);
			for (let t of i) if (e.has(t)) return !1;
			return !0;
		}
		let o = y.from(this).select(n).toArray(), s = y.from(t).select(r).toArray(), [c, l] = o.length < s.length ? [o, s] : [s, o];
		for (let e of c) for (let t of l) if (a(e, t)) return !1;
		return !0;
	}
	distinct(t) {
		let n = t ?? e.equalityComparator;
		return new u(() => this.unionGenerator(y.empty(), n));
	}
	distinctBy(t, n) {
		let r = n ?? e.equalityComparator;
		return new u(() => this.unionByGenerator(y.empty(), t, r));
	}
	distinctUntilChanged(t) {
		let n = t ?? e.equalityComparator;
		return new u(() => this.distinctUntilChangedGenerator((e) => e, n));
	}
	distinctUntilChangedBy(t, n) {
		let r = n ?? e.equalityComparator;
		return new u(() => this.distinctUntilChangedGenerator(t, r));
	}
	elementAt(e) {
		if (e < 0) throw new r(e);
		let t = 0;
		for (let n of this) {
			if (e === t) return n;
			++t;
		}
		throw new r(e);
	}
	elementAtOrDefault(e) {
		let t = 0;
		for (let n of this) {
			if (e === t) return n;
			++t;
		}
		return null;
	}
	exactly(e, t) {
		if (e < 0) throw new a("Count must be greater than or equal to 0.", "count");
		let n = 0;
		for (let r of this) if ((t == null || t(r)) && n++, n > e) return !1;
		return n === e;
	}
	except(t, n) {
		return n ??= e.equalityComparator, new u(() => this.exceptGenerator(t, n));
	}
	exceptBy(t, n, r) {
		return r ??= e.equalityComparator, new u(() => this.exceptByGenerator(t, n, r));
	}
	first(e) {
		for (let t of this) if (!e || e(t)) return t;
		throw e ? u.NO_MATCHING_ELEMENT_EXCEPTION : u.NO_ELEMENTS_EXCEPTION;
	}
	firstOrDefault(e) {
		for (let t of this) if (!e || e(t)) return t;
		return null;
	}
	forEach(e) {
		let t = 0;
		for (let n of this) e(n, t++);
	}
	groupBy(e, t, n) {
		return new u(() => this.groupByGenerator(e, t, n));
	}
	groupJoin(t, n, r, i, a) {
		return a ??= e.equalityComparator, new u(() => this.groupJoinGenerator(t, n, r, i, a));
	}
	index() {
		return new u(() => this.indexGenerator());
	}
	interleave(e) {
		return new u(() => this.interleaveGenerator(e));
	}
	intersect(t, n) {
		return n ??= e.equalityComparator, new u(() => this.intersectGenerator(t, n));
	}
	intersectBy(t, n, r) {
		return r ??= e.equalityComparator, new u(() => this.intersectByGenerator(t, n, r));
	}
	intersperse(e) {
		return new u(() => this.intersperseGenerator(e));
	}
	join(t, n, r, i, a) {
		return a ??= e.equalityComparator, new u(() => this.joinGenerator(t, n, r, i, a, !1));
	}
	last(e) {
		let t = !1, n = null;
		for (let r of this) (!e || e(r)) && (n = r, t = !0);
		if (!t) throw e ? u.NO_MATCHING_ELEMENT_EXCEPTION : u.NO_ELEMENTS_EXCEPTION;
		return n;
	}
	lastOrDefault(e) {
		let t = null;
		for (let n of this) (!e || e(n)) && (t = n);
		return t;
	}
	leftJoin(t, n, r, i, a) {
		return a ??= e.equalityComparator, new u(() => this.joinGenerator(t, n, r, i, a, !0));
	}
	max(e) {
		let t = null;
		if (e) {
			for (let n of this) t = Math.max(t ?? -Infinity, e(n));
			if (t == null) throw u.NO_ELEMENTS_EXCEPTION;
			return t;
		} else {
			for (let e of this) t = Math.max(t ?? -Infinity, e);
			if (t == null) throw u.NO_ELEMENTS_EXCEPTION;
			return t;
		}
	}
	maxBy(t, n) {
		let r = null, i = null;
		for (let a of this) {
			let o = t(a);
			(i == null || (n ?? e.orderComparator)(o, i) > 0) && (r = a, i = o);
		}
		if (r == null) throw u.NO_ELEMENTS_EXCEPTION;
		return r;
	}
	median(e, t) {
		let n = e ?? ((e) => e);
		return pe(this.select(n).toArray(), t);
	}
	min(e) {
		let t = null;
		if (e) {
			for (let n of this) t = Math.min(t ?? Infinity, e(n));
			if (t == null) throw u.NO_ELEMENTS_EXCEPTION;
			return t;
		} else {
			for (let e of this) t = Math.min(t ?? Infinity, e);
			if (t == null) throw u.NO_ELEMENTS_EXCEPTION;
			return t;
		}
	}
	minBy(t, n) {
		let r = null, i = null;
		for (let a of this) {
			let o = t(a);
			(i == null || (n ?? e.orderComparator)(o, i) < 0) && (r = a, i = o);
		}
		if (r == null) throw u.NO_ELEMENTS_EXCEPTION;
		return r;
	}
	mode(e) {
		let t = this.multimode(e);
		if (t.none()) throw u.NO_ELEMENTS_EXCEPTION;
		return t.first();
	}
	modeOrDefault(e) {
		return this.multimode(e).firstOrDefault();
	}
	multimode(e) {
		let t = e ?? ((e) => e);
		return new u(() => this.multimodeGenerator(t));
	}
	none(e) {
		if (!e) return !!this[Symbol.iterator]().next().done;
		for (let t of this) if (e(t)) return !1;
		return !0;
	}
	ofType(e) {
		return new u(() => this.ofTypeGenerator(e));
	}
	order(e) {
		if (!_) throw Error("OrderedEnumerable factory is not registered.");
		return _(this, (e) => e, !0, !1, e);
	}
	orderBy(e, t) {
		if (!_) throw Error("OrderedEnumerable factory is not registered.");
		return _(this, e, !0, !1, t);
	}
	orderByDescending(e, t) {
		if (!_) throw Error("OrderedEnumerable factory is not registered.");
		return _(this, e, !1, !1, t);
	}
	orderDescending(e) {
		if (!_) throw Error("OrderedEnumerable factory is not registered.");
		return _(this, (e) => e, !1, !1, e);
	}
	pairwise(e) {
		return new u(() => this.pairwiseGenerator(e ??= (e, t) => [e, t]));
	}
	partition(e) {
		if (!g) throw Error("List factory is not registered.");
		let t = g(), n = g();
		for (let r of this) e(r) ? t.add(r) : n.add(r);
		return [new y(t), new y(n)];
	}
	percentile(e, t, n) {
		let r = typeof t == "function" ? t : void 0, i = typeof t == "function" ? n : t ?? n, a = r ?? ((e) => e);
		return he(this.select(a).toArray(), e, i);
	}
	permutations(e) {
		if (e != null && e < 1) throw new a("Size must be greater than 0.", "size");
		return new u(() => this.permutationsGenerator(e));
	}
	pipe(e) {
		return e(this);
	}
	prepend(e) {
		return new u(() => this.prependGenerator(e));
	}
	product(e) {
		let t = 1, n = !1;
		for (let r of this) t *= e?.(r) ?? r, n = !0;
		if (!n) throw u.NO_ELEMENTS_EXCEPTION;
		return t;
	}
	reverse() {
		return new u(() => this.reverseGenerator());
	}
	rightJoin(t, n, r, i, a) {
		return a ??= e.equalityComparator, new u(() => this.rightJoinGenerator(t, n, r, i, a));
	}
	rotate(e) {
		return new u(() => this.rotateGenerator(e));
	}
	scan(e, t) {
		return new u(() => this.scanGenerator(e, t));
	}
	select(e) {
		return new u(() => this.selectGenerator(e));
	}
	selectMany(e) {
		return new u(() => this.selectManyGenerator(e));
	}
	sequenceEqual(t, n) {
		n ??= e.equalityComparator;
		let r = this[Symbol.iterator](), i = t[Symbol.iterator](), a = r.next(), o = i.next();
		if (a.done && o.done) return !0;
		for (; !a.done && !o.done;) {
			if (!n(a.value, o.value)) return !1;
			if (a = r.next(), o = i.next(), a.done && o.done) return !0;
		}
		return !1;
	}
	shuffle() {
		return new u(() => this.shuffleGenerator());
	}
	single(e) {
		let t = null, n = !1, r = !1;
		for (let i of this) if (r = !0, !e || e(i)) {
			if (n) throw e ? u.MORE_THAN_ONE_MATCHING_ELEMENT_EXCEPTION : u.MORE_THAN_ONE_ELEMENT_EXCEPTION;
			t = i, n = !0;
		}
		if (!n) throw r ? u.NO_MATCHING_ELEMENT_EXCEPTION : u.NO_ELEMENTS_EXCEPTION;
		return t;
	}
	singleOrDefault(e) {
		let t = null, n = !1;
		for (let r of this) if (!e || e(r)) {
			if (n) throw e ? u.MORE_THAN_ONE_MATCHING_ELEMENT_EXCEPTION : u.MORE_THAN_ONE_ELEMENT_EXCEPTION;
			t = r, n = !0;
		}
		return t;
	}
	skip(e) {
		return new u(() => this.skipGenerator(e));
	}
	skipLast(e) {
		return new u(() => this.skipLastGenerator(e));
	}
	skipUntil(e) {
		return new u(() => this.skipUntilGenerator(e));
	}
	skipWhile(e) {
		return new u(() => this.skipWhileGenerator(e));
	}
	span(e) {
		if (!g) throw Error("List factory is not registered.");
		let t = g(), n = g(), r = !1;
		for (let i of this) r ? n.add(i) : e(i) ? t.add(i) : (r = !0, n.add(i));
		return [new y(t), new y(n)];
	}
	standardDeviation(e, t) {
		let n = this.variance(e, t);
		return Number.isNaN(n) ? n : Math.sqrt(n);
	}
	step(e) {
		if (e < 1) throw new a("Step must be greater than 0.", "step");
		return new u(() => this.stepGenerator(e));
	}
	sum(e) {
		let t = 0, n = !1;
		for (let r of this) t += e?.(r) ?? r, n = !0;
		if (!n) throw u.NO_ELEMENTS_EXCEPTION;
		return t;
	}
	take(e) {
		return new u(() => this.takeGenerator(e));
	}
	takeLast(e) {
		return new u(() => this.takeLastGenerator(e));
	}
	takeUntil(e) {
		return new u(() => this.takeUntilGenerator(e));
	}
	takeWhile(e) {
		return new u(() => this.takeWhileGenerator(e));
	}
	tap(e) {
		return new u(() => this.tapGenerator(e));
	}
	thenBy(e, t) {
		if (!_) throw Error("OrderedEnumerable factory is not registered.");
		return _(this, e, !0, !0, t);
	}
	thenByDescending(e, t) {
		if (!_) throw Error("OrderedEnumerable factory is not registered.");
		return _(this, e, !1, !0, t);
	}
	toArray() {
		return Array.from(this);
	}
	toCircularLinkedList(e) {
		if (!Oe) throw Error("CircularLinkedList factory is not registered.");
		return Oe(this, e);
	}
	toCircularQueue(e, t) {
		if (!ke) throw Error("CircularQueue factory is not registered.");
		return ke(this, e, t);
	}
	toDictionary(e, n, r) {
		if (!Ae) throw Error("Dictionary factory is not registered.");
		let i = Ae(y.empty(), r);
		for (let r of this) {
			let a = r instanceof t ? e?.(r) ?? r.key : e(r), o = r instanceof t ? n?.(r) ?? r.value : n(r);
			i.add(a, o);
		}
		return i;
	}
	toEnumerableSet() {
		if (!je) throw Error("EnumerableSet factory is not registered.");
		return je(this);
	}
	toImmutableCircularQueue(e, t) {
		if (!Me) throw Error("ImmutableCircularQueue factory is not registered.");
		return Me(this, e, t);
	}
	toImmutableDictionary(e, t, n) {
		let r = this.toDictionary(e, t, n);
		if (!Ne) throw Error("ImmutableDictionary factory is not registered.");
		return Ne(r);
	}
	toImmutableList(e) {
		if (!Pe) throw Error("ImmutableList factory is not registered.");
		return Pe(this, e);
	}
	toImmutablePriorityQueue(e) {
		if (!Fe) throw Error("ImmutablePriorityQueue factory is not registered.");
		return Fe(this, e);
	}
	toImmutableQueue(e) {
		if (!Ie) throw Error("ImmutableQueue factory is not registered.");
		return Ie(this, e);
	}
	toImmutableSet() {
		if (!Le) throw Error("ImmutableSet factory is not registered.");
		return Le(this);
	}
	toImmutableSortedDictionary(e, t, n, r) {
		let i = this.toSortedDictionary(e, t, n, r);
		if (!Re) throw Error("ImmutableSortedDictionary factory is not registered.");
		return Re(i);
	}
	toImmutableSortedSet(e) {
		if (!ze) throw Error("ImmutableSortedSet factory is not registered.");
		return ze(this, e);
	}
	toImmutableStack(e) {
		if (!Be) throw Error("ImmutableStack factory is not registered.");
		return Be(this, e);
	}
	toLinkedList(e) {
		if (!Ve) throw Error("LinkedList factory is not registered.");
		return Ve(this, e);
	}
	toList(e) {
		if (!g) throw Error("List factory is not registered.");
		return g(this, e);
	}
	toLookup(e, t, n) {
		if (!He) throw Error("Lookup factory is not registered.");
		return He(this, e, t, n);
	}
	toMap(e, n) {
		let r = /* @__PURE__ */ new Map();
		for (let i of this) {
			let a = i instanceof t ? e?.(i) ?? i.key : e(i), o = i instanceof t ? n?.(i) ?? i.value : n(i);
			r.set(a, o);
		}
		return r;
	}
	toObject(e, n) {
		let r = {};
		for (let i of this) {
			let a = i instanceof t ? e?.(i) ?? i.key : e(i);
			r[a] = i instanceof t ? n?.(i) ?? i.value : n(i);
		}
		return r;
	}
	toPriorityQueue(e) {
		if (!Ue) throw Error("PriorityQueue factory is not registered.");
		return Ue(this, e);
	}
	toQueue(e) {
		if (!We) throw Error("Queue factory is not registered.");
		return We(this, e);
	}
	toSet() {
		return new Set(this);
	}
	toSortedDictionary(e, n, r, i) {
		if (!Ge) throw Error("SortedDictionary factory is not registered.");
		let a = Ge([], r, i);
		for (let r of this) {
			let i = r instanceof t ? e?.(r) ?? r.key : e(r), o = r instanceof t ? n?.(r) ?? r.value : n(r);
			a.add(i, o);
		}
		return a;
	}
	toSortedSet(e) {
		if (!v) throw Error("SortedSet factory is not registered.");
		return v(this, e);
	}
	toStack(e) {
		if (!Ke) throw Error("Stack factory is not registered.");
		return Ke(this, e);
	}
	union(t, n) {
		return n ??= e.equalityComparator, new u(() => this.unionGenerator(t, n));
	}
	unionBy(t, n, r) {
		return r ??= e.equalityComparator, new u(() => this.unionByGenerator(t, n, r));
	}
	variance(e, t = !0) {
		let n = p(e), r = Ce(this, n);
		return r.count === 0 || t && r.count < 2 ? NaN : t ? r.sumSq / (r.count - 1) : r.sumSq / r.count;
	}
	where(e) {
		return new u(() => this.whereGenerator(e));
	}
	windows(e) {
		if (e < 1) throw new a("Size must be greater than 0.", "size");
		return new u(() => this.windowsGenerator(e));
	}
	zip(e, t) {
		return new u(() => this.zipGenerator(e, t));
	}
	zipMany(...e) {
		let t = e[e.length - 1];
		if (e.length > 0 && typeof t == "function") {
			let n = e.slice(0, -1), r = t;
			return new u(() => this.zipManyWithZipperGenerator(n, r));
		}
		let n = e;
		return new u(() => this.zipManyWithoutZipperGenerator(n));
	}
	*appendGenerator(e) {
		yield* this, yield e;
	}
	*cartesianGenerator(e) {
		let t = Array.isArray(e) ? e : [...e];
		if (t.length !== 0) for (let e of this) for (let n = 0; n < t.length; n++) yield [e, t[n]];
	}
	*castGenerator() {
		for (let e of this) yield e;
	}
	*chunkGenerator(e) {
		let t = this[Symbol.iterator](), n = t.next();
		for (; !n.done;) {
			if (!g) throw Error("List factory is not registered.");
			let r = g();
			for (let i = 0; i < e && !n.done; ++i) r.add(n.value), n = t.next();
			yield r;
		}
	}
	*combinationsGenerator(e) {
		let t = this[Symbol.iterator](), n = t.next();
		if (n.done) return yield* [];
		if (!g) throw Error("List factory is not registered.");
		let r = g();
		for (; !n.done;) r.add(n.value), n = t.next();
		let i = 1 << r.length, a = /* @__PURE__ */ new Set();
		for (let t = 0; t < i; ++t) {
			let n = g();
			for (let e = 0; e < r.length; ++e) t & 1 << e && n.add(r.elementAt(e));
			if (e == null || n.length === e) {
				let e = n.aggregate((e, t) => e + t, ",");
				a.has(e) || (a.add(e), yield n);
			}
		}
	}
	*compactGenerator() {
		for (let e of this) e != null && (yield e);
	}
	*concatGenerator(e) {
		yield* this, yield* e;
	}
	*cycleGenerator(e) {
		if (this.none()) throw u.NO_ELEMENTS_EXCEPTION;
		if (e == null) for (;;) yield* this;
		else for (let t = 0; t < e; ++t) yield* this;
	}
	*defaultIfEmptyGenerator(e) {
		let t = this[Symbol.iterator](), n = t.next();
		n.done ? yield e ?? null : (yield n.value, yield* t);
	}
	*distinctUntilChangedGenerator(e, t) {
		let n = this[Symbol.iterator](), r = n.next();
		if (r.done) return yield* [];
		let i = r.value;
		for (yield i; !r.done;) {
			if (r = n.next(), r.done) return;
			t(e(i), e(r.value)) || (yield r.value, i = r.value);
		}
	}
	*exceptByGenerator(t, n, r) {
		if (r === e.equalityComparator) {
			let e = /* @__PURE__ */ new Set();
			for (let r of t) e.add(this.#t(n(r)));
			for (let t of this) {
				let r = this.#t(n(t));
				e.has(r) || (e.add(r), yield t);
			}
			return;
		}
		if (!v) throw Error("SortedSet factory is not registered.");
		let i = v([], r);
		if (!g) throw Error("List factory is not registered.");
		let a = g([], r), { value: o, done: s } = new u(() => t)[Symbol.iterator]().next();
		if (s) {
			let { value: e, done: t } = new u(() => this)[Symbol.iterator]().next();
			if (t) return yield* this;
			let o = n(e), s = typeof r(o, o) == "number" ? i : a;
			for (let e of this) {
				let t = n(e);
				s.contains(t) || (s.add(t), yield e);
			}
			return;
		}
		let c = n(o), l = typeof r(c, c) == "number" ? i : a;
		for (let e of t) {
			let t = n(e);
			l.contains(t) || l.add(t);
		}
		for (let e of this) {
			let t = n(e);
			l.contains(t) || (l.add(t), yield e);
		}
	}
	*exceptGenerator(e, t) {
		return yield* this.exceptByGenerator(e, (e) => e, t);
	}
	*groupByGenerator(e, t, n) {
		let r = g;
		if (!r) throw Error("List factory is not registered.");
		if (!h) throw Error("Group factory is not registered.");
		if (!t) {
			let t = /* @__PURE__ */ new Map();
			for (let n of this) {
				let i = e(n), a = t.get(i);
				if (a) a.source.add(n);
				else {
					let e = r([n]), a = h(i, e);
					t.set(i, a);
				}
			}
			yield* t.values();
		} else if (n) {
			let i = /* @__PURE__ */ new Map(), a = [];
			for (let o of this) {
				let s = e(o), c = n(o), l = i.get(c), u;
				if (l ? u = l.find((e) => t(e.canonicalKey, s)) : (l = [], i.set(c, l)), u) u.group.source.add(o);
				else {
					let e = r([o]), t = h(s, e);
					l.push({
						canonicalKey: s,
						group: t
					}), a.push(t);
				}
			}
			yield* a;
		} else {
			let n = /* @__PURE__ */ new Map(), i = (e) => {
				for (let r of n.keys()) if (t(r, e)) return r;
			};
			for (let t of this) {
				let a = e(t), o = i(a);
				if (o !== void 0) n.get(o).source.add(t);
				else {
					let e = r([t]), i = h(a, e);
					n.set(a, i);
				}
			}
			yield* n.values();
		}
	}
	*groupJoinGenerator(t, n, r, i, a) {
		let o = a ?? e.equalityComparator, s = [];
		for (let e of t) se(s, r(e), o).push(e);
		for (let e of this) {
			let t = ce(s, n(e), o);
			yield i(e, y.from(t ?? []));
		}
	}
	*indexGenerator() {
		let e = 0;
		for (let t of this) yield [e++, t];
	}
	*interleaveGenerator(e) {
		let t = this[Symbol.iterator](), n = e[Symbol.iterator](), r = t.next(), i = n.next();
		for (; !r.done || !i.done;) r.done || (yield r.value, r = t.next()), i.done || (yield i.value, i = n.next());
	}
	*intersectByGenerator(t, n, r) {
		if (r === e.equalityComparator) {
			let e = /* @__PURE__ */ new Set();
			for (let r of t) e.add(this.#t(n(r)));
			if (e.size === 0) return;
			for (let t of this) {
				let r = this.#t(n(t));
				e.delete(r) && (yield t);
			}
			return;
		}
		if (!v) throw Error("SortedSet factory is not registered.");
		let i = v([], r);
		if (!g) throw Error("List factory is not registered.");
		let a = g([], r), { value: o, done: s } = new u(() => t)[Symbol.iterator]().next();
		if (s) return yield* y.empty();
		let c = n(o), l = typeof r(c, c) == "number" ? i : a;
		for (let e of t) {
			let t = n(e);
			l.contains(t) || l.add(t);
		}
		for (let e of this) {
			let t = n(e);
			l.remove(t) && (yield e);
		}
	}
	*intersectGenerator(e, t) {
		return yield* this.intersectByGenerator(e, (e) => e, t);
	}
	*intersperseGenerator(e) {
		let t = 0;
		for (let n of this) t !== 0 && (yield e), yield n, ++t;
	}
	*joinGenerator(t, n, r, i, a, o) {
		let s = a ?? e.equalityComparator, c = o ?? !1, l = ue(t, r, s);
		for (let e of this) yield* fe(e, n(e), l, s, i, c);
	}
	*multimodeGenerator(e) {
		let t = /* @__PURE__ */ new Map(), n = /* @__PURE__ */ new Map(), r = 0;
		for (let i of this) {
			let a = e(i);
			n.has(a) || n.set(a, i);
			let o = (t.get(a) ?? 0) + 1;
			t.set(a, o), o > r && (r = o);
		}
		if (r !== 0) for (let [e, i] of t) i === r && (yield n.get(e));
	}
	*ofTypeGenerator(e) {
		let t = typeof e == "string" ? ((t) => typeof t === e) : (t) => t instanceof ae(e);
		for (let e of this) t(e) && (yield e);
	}
	*pairwiseGenerator(e) {
		let t = this[Symbol.iterator](), n = t.next();
		for (; !n.done;) {
			let r = n;
			n = t.next(), n.done || (yield e(r.value, n.value));
		}
	}
	*permutationsGenerator(e) {
		yield* _e(Array.from(this.distinct()), e);
	}
	*prependGenerator(e) {
		yield e, yield* this;
	}
	*reverseGenerator() {
		yield* Array.from(this).reverse();
	}
	*rightJoinGenerator(e, t, n, r, i) {
		let a = ue(this, t, i);
		for (let t of e) {
			let e = n(t), o = !1;
			for (let n of a) if (i(e, n.key)) for (let e of n.elements) yield r(e, t), o = !0;
			o || (yield r(null, t));
		}
	}
	*rotateGenerator(e) {
		return e === 0 ? yield* this : e > 0 ? yield* this.rotateLeftGenerator(e) : yield* this.rotateRightGenerator(e);
	}
	*rotateLeftGenerator(e) {
		let t = this[Symbol.iterator](), n = [], r = 0;
		for (; r < e;) {
			let i = t.next();
			if (i.done) {
				if (n.length === 0) return;
				let t = e % n.length;
				for (let e = t; e < n.length; ++e) yield n[e];
				for (let e = 0; e < t; ++e) yield n[e];
				return;
			}
			n.push(i.value), r++;
		}
		for (let e = t.next(); !e.done; e = t.next()) yield e.value;
		return yield* n;
	}
	*rotateRightGenerator(e) {
		let t = [];
		for (let e of this) t.push(e);
		if (t.length === 0) return;
		let n = -e % t.length, r = (t.length - n) % t.length;
		for (let e = 0; e < t.length; ++e) yield t[(e + r) % t.length];
	}
	*scanGenerator(e, t) {
		let n;
		if (t == null) {
			let t = this[Symbol.iterator](), r = t.next();
			if (r.done) throw u.NO_ELEMENTS_EXCEPTION;
			n = r.value, yield n;
			let i = t.next();
			for (; !i.done;) n = e(n, i.value), yield n, i = t.next();
		} else {
			n = t;
			for (let t of this) n = e(n, t), yield n;
		}
	}
	*selectGenerator(e) {
		let t = 0;
		for (let n of this) yield e(n, t++);
	}
	*selectManyGenerator(e) {
		let t = 0;
		for (let n of this) yield* e(n, t), ++t;
	}
	*shuffleGenerator() {
		let e = Array.from(this);
		oe(e), yield* e;
	}
	*skipGenerator(e) {
		let t = 0;
		for (let n of this) t >= e && (yield n), ++t;
	}
	*skipLastGenerator(e) {
		if (e <= 0) {
			yield* this;
			return;
		}
		let t = Array(e), n = 0, r = 0;
		for (let i of this) n === e && (yield t[r]), t[r] = i, r = (r + 1) % e, n < e && n++;
	}
	*skipUntilGenerator(e) {
		let t = 0, n = !0;
		for (let r of this) n && e(r, t) && (n = !1), n || (yield r), t++;
	}
	*skipWhileGenerator(e) {
		let t = 0, n = !1;
		for (let r of this) n ? yield r : e(r, t) ? t++ : (n = !0, yield r);
	}
	*stepGenerator(e) {
		let t = 0;
		for (let n of this) t % e === 0 && (yield n), ++t;
	}
	*takeGenerator(e) {
		let t = 0;
		for (let n of this) if (t < e) yield n, t++;
		else break;
	}
	*takeLastGenerator(e) {
		if (e <= 0) return;
		let t = Array(e), n = 0, r = 0;
		for (let i of this) {
			let a = (r + n) % e;
			t[a] = i, n < e ? n++ : r = (r + 1) % e;
		}
		for (let i = 0; i < n; i++) yield t[(r + i) % e];
	}
	*takeUntilGenerator(e) {
		let t = 0;
		for (let n of this) {
			if (e(n, t)) break;
			yield n, t++;
		}
	}
	*takeWhileGenerator(e) {
		let t = 0, n = !1;
		for (let r of this) if (!n) e(r, t) ? (yield r, ++t) : n = !0;
		else break;
	}
	*tapGenerator(e) {
		let t = 0;
		for (let n of this) e(n, t++), yield n;
	}
	*unionByGenerator(t, n, r) {
		if (r === e.equalityComparator) {
			let e = /* @__PURE__ */ new Set();
			for (let r of [this, t]) for (let t of r) {
				let r = n(t);
				e.has(r) || (e.add(r), yield t);
			}
		} else {
			let e = /* @__PURE__ */ new Map(), i = (t) => {
				for (let n of e.keys()) if (r(t, n)) return n;
			};
			for (let r of [this, t]) for (let t of r) {
				let r = n(t);
				i(r) === void 0 && (e.set(r, !0), yield t);
			}
		}
	}
	*unionGenerator(t, n) {
		return yield* this.unionByGenerator(t, (e) => e, n ?? e.equalityComparator);
	}
	*whereGenerator(e) {
		let t = 0;
		for (let n of this) e(n, t) && (yield n), ++t;
	}
	*windowsGenerator(e) {
		let t = this[Symbol.iterator](), n = Array(e), r = 0, i = 0;
		for (let a = t.next(); !a.done; a = t.next()) if (r < e) n[r] = a.value, r++, r === e && (yield new y(n.slice(0, e)));
		else {
			n[i] = a.value, i = (i + 1) % e;
			let t = Array(e);
			for (let r = 0; r < e; r++) t[r] = n[(i + r) % e];
			yield new y(t);
		}
	}
	*zipGenerator(e, t) {
		let n = this[Symbol.iterator](), r = e[Symbol.iterator]();
		for (;;) {
			let e = n.next(), i = r.next();
			if (e.done || i.done) break;
			yield t?.(e.value, i.value) ?? [e.value, i.value];
		}
	}
	*zipManyWithZipperGenerator(e, t) {
		for (let n of this.zipManyWithoutZipperGenerator(e)) yield t(n);
	}
	*zipManyWithoutZipperGenerator(e) {
		let t = [this, ...e].map((e) => e[Symbol.iterator]());
		for (;;) {
			let e = t.map((e) => e.next());
			if (e.some((e) => e.done)) break;
			yield e.map((e) => e.value);
		}
	}
}, Oe, ke, Ae, je, h, Me, Ne, Pe, Fe, Ie, Le, Re, ze, Be, Ve, g, He, _, Ue, We, Ge, v, Ke, qe = (e) => {
	Oe = e;
}, Je = (e) => {
	ke = e;
}, Ye = (e) => {
	Ae = e;
}, Xe = (e) => {
	je = e;
}, Ze = (e) => {
	h = e;
}, Qe = (e) => {
	Me = e;
}, $e = (e) => {
	Ne = e;
}, et = (e) => {
	Pe = e;
}, tt = (e) => {
	Fe = e;
}, nt = (e) => {
	Ie = e;
}, rt = (e) => {
	Le = e;
}, it = (e) => {
	Re = e;
}, at = (e) => {
	ze = e;
}, ot = (e) => {
	Be = e;
}, st = (e) => {
	Ve = e;
}, ct = (e) => {
	g = e;
}, lt = (e) => {
	He = e;
}, ut = (e) => {
	_ = e;
}, dt = (e) => {
	Ue = e;
}, ft = (e) => {
	We = e;
}, pt = (e) => {
	Ge = e;
}, mt = (e) => {
	v = e;
}, ht = (e) => {
	Ke = e;
}, gt = (e, t, n) => {
	if (isNaN(e)) throw new a("start cannot be NaN");
	if (isNaN(t)) throw new a("end cannot be NaN");
	if (isNaN(n)) throw new a("step cannot be NaN");
	if (n > 0 && t < e) throw new a("step cannot be greater than zero when end is less than start");
	if (n < 0 && t > e) throw new a("step cannot be less than zero when end is greater than start");
	if (n === 0 && t !== e) throw new a("step cannot be zero when end is not equal to start");
}, y = class e {
	#e;
	constructor(e) {
		this.iterable = e, this.#e = new m(() => e);
	}
	static empty() {
		return new e([]);
	}
	static from(t) {
		return new e(t);
	}
	static infiniteSequence(e, t) {
		return new m(function* () {
			let n = e;
			for (;;) yield n, n += t;
		});
	}
	static range(e, t) {
		return new m(function* () {
			for (let n = 0; n < t; ++n) yield e + n;
		});
	}
	static repeat(e, t) {
		return new m(function* () {
			for (let n = 0; n < t; ++n) yield e;
		});
	}
	static sequence(e, t, n) {
		return gt(e, t, n), new m(function* () {
			if (e < t) for (let r = e; r <= t; r += n) yield r;
			else if (e > t) for (let r = e; r >= t; r += n) yield r;
			else yield e;
		});
	}
	*[Symbol.iterator]() {
		yield* this.iterable;
	}
	aggregate(e, t, n) {
		return n === void 0 ? t === void 0 ? this.#e.aggregate(e) : this.#e.aggregate(e, t) : this.#e.aggregate(e, t, n);
	}
	aggregateBy(e, t, n, r) {
		return this.#e.aggregateBy(e, t, n, r);
	}
	all(e) {
		return this.#e.all(e);
	}
	any(e) {
		return this.#e.any(e);
	}
	append(e) {
		return this.#e.append(e);
	}
	atLeast(e, t) {
		return this.#e.atLeast(e, t);
	}
	atMost(e, t) {
		return this.#e.atMost(e, t);
	}
	average(e) {
		return e == null ? this.#e.average() : this.#e.average(e);
	}
	cartesian(e) {
		return this.#e.cartesian(e);
	}
	cast() {
		return this.#e.cast();
	}
	chunk(e) {
		return this.#e.chunk(e);
	}
	combinations(e) {
		return this.#e.combinations(e);
	}
	compact() {
		return this.#e.compact();
	}
	concat(e) {
		return this.#e.concat(e);
	}
	contains(e, t) {
		return this.#e.contains(e, t);
	}
	correlation(e, t, n) {
		return this.#e.correlation(e, t, n);
	}
	correlationBy(e, t) {
		return this.#e.correlationBy(e, t);
	}
	count(e) {
		return this.#e.count(e);
	}
	countBy(e, t) {
		return this.#e.countBy(e, t);
	}
	covariance(e, t, n, r) {
		return this.#e.covariance(e, t, n, r);
	}
	covarianceBy(e, t, n) {
		return this.#e.covarianceBy(e, t, n);
	}
	cycle(e) {
		return this.#e.cycle(e);
	}
	defaultIfEmpty(e) {
		return this.#e.defaultIfEmpty(e);
	}
	disjoint(e, t) {
		return this.#e.disjoint(e, t);
	}
	disjointBy(e, t, n, r) {
		return this.#e.disjointBy(e, t, n, r);
	}
	distinct(e) {
		return this.#e.distinct(e);
	}
	distinctBy(e, t) {
		return this.#e.distinctBy(e, t);
	}
	distinctUntilChanged(e) {
		return this.#e.distinctUntilChanged(e);
	}
	distinctUntilChangedBy(e, t) {
		return this.#e.distinctUntilChangedBy(e, t);
	}
	elementAt(e) {
		return this.#e.elementAt(e);
	}
	elementAtOrDefault(e) {
		return this.#e.elementAtOrDefault(e);
	}
	exactly(e, t) {
		return this.#e.exactly(e, t);
	}
	except(e, t) {
		return this.#e.except(e, t);
	}
	exceptBy(e, t, n) {
		return this.#e.exceptBy(e, t, n);
	}
	first(e) {
		return this.#e.first(e);
	}
	firstOrDefault(e) {
		return this.#e.firstOrDefault(e);
	}
	forEach(e) {
		this.#e.forEach(e);
	}
	groupBy(e, t, n) {
		return this.#e.groupBy(e, t, n);
	}
	groupJoin(e, t, n, r, i) {
		return this.#e.groupJoin(e, t, n, r, i);
	}
	index() {
		return this.#e.index();
	}
	interleave(e) {
		return this.#e.interleave(e);
	}
	intersect(e, t) {
		return this.#e.intersect(e, t);
	}
	intersectBy(e, t, n) {
		return this.#e.intersectBy(e, t, n);
	}
	intersperse(e) {
		return this.#e.intersperse(e);
	}
	join(e, t, n, r, i) {
		return this.#e.join(e, t, n, r, i);
	}
	last(e) {
		return this.#e.last(e);
	}
	lastOrDefault(e) {
		return this.#e.lastOrDefault(e);
	}
	leftJoin(e, t, n, r, i) {
		return this.#e.leftJoin(e, t, n, r, i);
	}
	max(e) {
		return e == null ? this.#e.max() : this.#e.max(e);
	}
	maxBy(e, t) {
		return this.#e.maxBy(e, t);
	}
	median(e, t) {
		return this.#e.median(e, t);
	}
	min(e) {
		return e == null ? this.#e.min() : this.#e.min(e);
	}
	minBy(e, t) {
		return this.#e.minBy(e, t);
	}
	mode(e) {
		return this.#e.mode(e);
	}
	modeOrDefault(e) {
		return this.#e.modeOrDefault(e);
	}
	multimode(e) {
		return this.#e.multimode(e);
	}
	none(e) {
		return this.#e.none(e);
	}
	ofType(e) {
		return this.#e.ofType(e);
	}
	order(e) {
		return this.#e.order(e);
	}
	orderBy(e, t) {
		return this.#e.orderBy(e, t);
	}
	orderByDescending(e, t) {
		return this.#e.orderByDescending(e, t);
	}
	orderDescending(e) {
		return this.#e.orderDescending(e);
	}
	pairwise(e) {
		return this.#e.pairwise(e);
	}
	partition(e) {
		return this.#e.partition(e);
	}
	percentile(e, t, n) {
		return typeof t == "function" ? this.#e.percentile(e, t, n) : this.#e.percentile(e, t ?? n);
	}
	permutations(e) {
		return this.#e.permutations(e);
	}
	pipe(e) {
		return this.#e.pipe(e);
	}
	prepend(e) {
		return this.#e.prepend(e);
	}
	product(e) {
		return e == null ? this.#e.product() : this.#e.product(e);
	}
	reverse() {
		return this.#e.reverse();
	}
	rightJoin(e, t, n, r, i) {
		return this.#e.rightJoin(e, t, n, r, i);
	}
	rotate(e) {
		return this.#e.rotate(e);
	}
	scan(e, t) {
		return t === void 0 ? this.#e.scan(e) : this.#e.scan(e, t);
	}
	select(e) {
		return this.#e.select(e);
	}
	selectMany(e) {
		return this.#e.selectMany(e);
	}
	sequenceEqual(e, t) {
		return this.#e.sequenceEqual(e, t);
	}
	shuffle() {
		return this.#e.shuffle();
	}
	single(e) {
		return this.#e.single(e);
	}
	singleOrDefault(e) {
		return this.#e.singleOrDefault(e);
	}
	skip(e) {
		return this.#e.skip(e);
	}
	skipLast(e) {
		return this.#e.skipLast(e);
	}
	skipUntil(e) {
		return this.#e.skipUntil(e);
	}
	skipWhile(e) {
		return this.#e.skipWhile(e);
	}
	span(e) {
		return this.#e.span(e);
	}
	standardDeviation(e, t) {
		return this.#e.standardDeviation(e, t);
	}
	step(e) {
		return this.#e.step(e);
	}
	sum(e) {
		return e == null ? this.#e.sum() : this.#e.sum(e);
	}
	take(e) {
		return this.#e.take(e);
	}
	takeLast(e) {
		return this.#e.takeLast(e);
	}
	takeUntil(e) {
		return this.#e.takeUntil(e);
	}
	takeWhile(e) {
		return this.#e.takeWhile(e);
	}
	tap(e) {
		return this.#e.tap(e);
	}
	toArray() {
		return this.#e.toArray();
	}
	toCircularLinkedList(e) {
		return this.#e.toCircularLinkedList(e);
	}
	toCircularQueue(e, t) {
		return typeof e == "number" ? this.#e.toCircularQueue(e, t) : this.#e.toCircularQueue(e);
	}
	toDictionary(e, t, n) {
		return this.#e.toDictionary(e, t, n);
	}
	toEnumerableSet() {
		return this.#e.toEnumerableSet();
	}
	toImmutableCircularQueue(e, t) {
		return typeof e == "number" ? this.#e.toImmutableCircularQueue(e, t) : this.#e.toImmutableCircularQueue(e);
	}
	toImmutableDictionary(e, t, n) {
		return this.#e.toImmutableDictionary(e, t, n);
	}
	toImmutableList(e) {
		return this.#e.toImmutableList(e);
	}
	toImmutablePriorityQueue(e) {
		return this.#e.toImmutablePriorityQueue(e);
	}
	toImmutableQueue(e) {
		return this.#e.toImmutableQueue(e);
	}
	toImmutableSet() {
		return this.#e.toImmutableSet();
	}
	toImmutableSortedDictionary(e, t, n, r) {
		return this.#e.toImmutableSortedDictionary(e, t, n, r);
	}
	toImmutableSortedSet(e) {
		return this.#e.toImmutableSortedSet(e);
	}
	toImmutableStack(e) {
		return this.#e.toImmutableStack(e);
	}
	toLinkedList(e) {
		return this.#e.toLinkedList(e);
	}
	toList(e) {
		return this.#e.toList(e);
	}
	toLookup(e, t, n) {
		return this.#e.toLookup(e, t, n);
	}
	toMap(e, t) {
		return this.#e.toMap(e, t);
	}
	toObject(e, t) {
		return this.#e.toObject(e, t);
	}
	toPriorityQueue(e) {
		return this.#e.toPriorityQueue(e);
	}
	toQueue(e) {
		return this.#e.toQueue(e);
	}
	toSet() {
		return this.#e.toSet();
	}
	toSortedDictionary(e, t, n, r) {
		return this.#e.toSortedDictionary(e, t, n, r);
	}
	toSortedSet(e) {
		return this.#e.toSortedSet(e);
	}
	toStack(e) {
		return this.#e.toStack(e);
	}
	union(e, t) {
		return this.#e.union(e, t);
	}
	unionBy(e, t, n) {
		return this.#e.unionBy(e, t, n);
	}
	variance(e, t) {
		return this.#e.variance(e, t);
	}
	where(e) {
		return this.#e.where(e);
	}
	windows(e) {
		return this.#e.windows(e);
	}
	zip(e, t) {
		return this.#e.zip(e, t);
	}
	zipMany(...e) {
		let t = e[e.length - 1];
		if (e.length > 0 && typeof t == "function") {
			let n = e.slice(0, -1), r = t;
			return this.#e.zipMany(...n, r);
		}
		let n = e;
		return this.#e.zipMany(...n);
	}
}, b = (e) => y.from(e);
//#endregion
//#region src/enumerator/functions/aggregate.ts
function x(e, t, n, r) {
	let i = b(e);
	return r === void 0 ? n === void 0 ? i.aggregate(t) : i.aggregate(t, n) : i.aggregate(t, n, r);
}
//#endregion
//#region src/enumerator/functions/aggregateBy.ts
var _t = (e, t, n, r, i) => b(e).aggregateBy(t, n, r, i), vt = (e, t) => b(e).all(t), yt = (e, t) => b(e).any(t), bt = (e, t) => b(e).append(t), xt = (e, t, n) => b(e).atLeast(t, n), St = (e, t, n) => b(e).atMost(t, n);
//#endregion
//#region src/enumerator/functions/average.ts
function S(e, t) {
	return t == null ? b(e).average() : b(e).average(t);
}
//#endregion
//#region src/enumerator/functions/cartesian.ts
var Ct = (e, t) => b(e).cartesian(t), wt = (e) => b(e).cast(), Tt = (e, t) => b(e).chunk(t), Et = (e, t) => b(e).combinations(t), Dt = (e) => b(e).compact(), Ot = (e, t) => b(e).concat(b(t)), C = (e, t, n) => b(e).contains(t, n), kt = (e, t, n, r) => b(e).correlation(t, n, r), At = (e, t, n) => b(e).correlationBy(t, n), jt = (e, t) => {
	if (!t) {
		if (Array.isArray(e)) return e.length;
		if (e instanceof Set || e instanceof Map) return e.size;
	}
	return b(e).count(t);
}, Mt = (e, t, n) => b(e).countBy(t, n), Nt = (e, t, n, r, i) => b(e).covariance(t, n, r, i), Pt = (e, t, n, r) => b(e).covarianceBy(t, n, r), Ft = (e, t) => b(e).cycle(t), It = (e, t) => b(e).defaultIfEmpty(t), Lt = (e, t, n) => b(e).disjoint(t, n), Rt = (e, t, n, r, i) => b(e).disjointBy(t, n, r, i), zt = (e, t) => b(e).distinct(t), Bt = (e, t, n) => b(e).distinctBy(t, n), Vt = (e, t) => b(e).distinctUntilChanged(t), Ht = (e, t, n) => b(e).distinctUntilChangedBy(t, n), Ut = (e, t) => b(e).elementAt(t), Wt = (e, t) => b(e).elementAtOrDefault(t), Gt = (e, t, n) => b(e).exactly(t, n), Kt = (e, t, n) => b(e).except(t, n), qt = (e, t, n, r) => b(e).exceptBy(t, n, r);
//#endregion
//#region src/enumerator/functions/first.ts
function Jt(e, t) {
	return b(e).first(t);
}
//#endregion
//#region src/enumerator/functions/firstOrDefault.ts
function Yt(e, t) {
	return b(e).firstOrDefault(t);
}
//#endregion
//#region src/enumerator/functions/groupBy.ts
var Xt = (e, t, n, r) => b(e).groupBy(t, n, r), Zt = (e, t, n, r, i, a) => b(e).groupJoin(b(t), n, r, i, a), Qt = (e) => b(e).index(), $t = (e, t) => b(e).interleave(t), en = (e, t, n) => b(e).intersect(t, n), tn = (e, t, n, r) => b(e).intersectBy(t, n, r), nn = (e, t) => b(e).intersperse(t), rn = (e, t, n, r, i, a) => b(e).join(b(t), n, r, i, a);
//#endregion
//#region src/enumerator/functions/last.ts
function an(e, t) {
	return b(e).last(t);
}
//#endregion
//#region src/enumerator/functions/lastOrDefault.ts
function on(e, t) {
	return b(e).lastOrDefault(t);
}
//#endregion
//#region src/enumerator/functions/leftJoin.ts
var sn = (e, t, n, r, i, a) => b(e).leftJoin(b(t), n, r, i, a);
//#endregion
//#region src/enumerator/functions/max.ts
function w(e, t) {
	return t == null ? b(e).max() : b(e).max(t);
}
//#endregion
//#region src/enumerator/functions/maxBy.ts
var cn = (e, t, n) => b(e).maxBy(t, n), ln = (e, t, n) => b(e).median(t, n);
//#endregion
//#region src/enumerator/functions/min.ts
function un(e, t) {
	return t == null ? b(e).min() : b(e).min(t);
}
//#endregion
//#region src/enumerator/functions/minBy.ts
var dn = (e, t, n) => b(e).minBy(t, n), fn = (e, t) => b(e).mode(t), pn = (e, t) => b(e).modeOrDefault(t), mn = (e, t) => b(e).multimode(t), hn = (e, t) => b(e).none(t), gn = (e, t) => b(e).ofType(t), _n = (e, t) => b(e).order(t), vn = (e, t, n) => b(e).orderBy(t, n), yn = (e, t, n) => b(e).orderByDescending(t, n), bn = (e, t) => b(e).orderDescending(t), xn = (e, t) => b(e).pairwise(t);
//#endregion
//#region src/enumerator/functions/partition.ts
function Sn(e, t) {
	return b(e).partition(t);
}
//#endregion
//#region src/enumerator/functions/percentile.ts
function T(e, t, n, r) {
	return typeof n == "function" ? b(e).percentile(t, n, r) : b(e).percentile(t, n ?? r);
}
//#endregion
//#region src/enumerator/functions/permutations.ts
var Cn = (e, t) => b(e).permutations(t), wn = (e, t) => b(e).pipe(t), Tn = (e, t) => b(e).prepend(t);
//#endregion
//#region src/enumerator/functions/product.ts
function E(e, t) {
	return t == null ? b(e).product() : b(e).product(t);
}
//#endregion
//#region src/enumerator/functions/reverse.ts
var En = (e) => b(e).reverse(), Dn = (e, t, n, r, i, a) => b(e).rightJoin(b(t), n, r, i, a), On = (e, t) => b(e).rotate(t);
//#endregion
//#region src/enumerator/functions/scan.ts
function D(e, t, n) {
	return n === void 0 ? b(e).scan(t) : b(e).scan(t, n);
}
//#endregion
//#region src/enumerator/functions/select.ts
var kn = (e, t) => b(e).select(t), An = (e, t) => b(e).selectMany(t), jn = (e, t, n) => b(e).sequenceEqual(t, n), Mn = (e) => b(e).shuffle();
//#endregion
//#region src/enumerator/functions/single.ts
function Nn(e, t) {
	return b(e).single(t);
}
//#endregion
//#region src/enumerator/functions/singleOrDefault.ts
function Pn(e, t) {
	return b(e).singleOrDefault(t);
}
//#endregion
//#region src/enumerator/functions/skip.ts
var Fn = (e, t) => b(e).skip(t), In = (e, t) => b(e).skipLast(t);
//#endregion
//#region src/enumerator/functions/skipUntil.ts
function Ln(e, t) {
	return b(e).skipUntil(t);
}
//#endregion
//#region src/enumerator/functions/skipWhile.ts
var Rn = (e, t) => b(e).skipWhile(t);
//#endregion
//#region src/enumerator/functions/span.ts
function zn(e, t) {
	return b(e).span(t);
}
//#endregion
//#region src/enumerator/functions/standardDeviation.ts
var Bn = (e, t, n) => b(e).standardDeviation(t, n), Vn = (e, t) => b(e).step(t);
//#endregion
//#region src/enumerator/functions/sum.ts
function O(e, t) {
	return t == null ? b(e).sum() : b(e).sum(t);
}
//#endregion
//#region src/enumerator/functions/take.ts
var Hn = (e, t) => b(e).take(t), Un = (e, t) => b(e).takeLast(t);
//#endregion
//#region src/enumerator/functions/takeUntil.ts
function Wn(e, t) {
	return b(e).takeUntil(t);
}
//#endregion
//#region src/enumerator/functions/takeWhile.ts
function Gn(e, t) {
	return b(e).takeWhile(t);
}
//#endregion
//#region src/enumerator/functions/tap.ts
var Kn = (e, t) => b(e).tap(t), qn = (e) => b(e).toArray(), Jn = (e, t) => b(e).toCircularLinkedList(t);
//#endregion
//#region src/enumerator/functions/toCircular