@dayme/alien-utils 0.1.0

package/dist/index.js

@@ -0,0 +1,1068 @@
+var Some = class e {
+	_tag = "Some";
+	constructor(e) {
+		this.value = e;
+	}
+	static of(t) {
+		return new e(t);
+	}
+	static collect(n) {
+		let r = [];
+		for (let e of n) {
+			if (e.isNone()) return None.instance();
+			r.push(e.unwrap());
+		}
+		return new e(r);
+	}
+	static partition(e) {
+		let n = [], r = [];
+		for (let i of e) i.isSome() ? n.push(i) : r.push(None.instance());
+		return [n, r];
+	}
+	isSome() {
+		return !0;
+	}
+	isNone() {
+		return !1;
+	}
+	unwrap() {
+		return this.value;
+	}
+	unwrapOr(e) {
+		return this.value;
+	}
+	unwrapOrElse(e) {
+		return this.value;
+	}
+	map(t) {
+		return new e(t(this.value));
+	}
+	andThen(e) {
+		return e(this.value);
+	}
+	match(e) {
+		return e.Some(this.value);
+	}
+	or(e) {
+		return this;
+	}
+	orElse(e) {
+		return this;
+	}
+	filter(e) {
+		return e(this.value) ? this : None.instance();
+	}
+	toString() {
+		return `Some(${String(this.value)})`;
+	}
+	toJSON() {
+		return {
+			some: !0,
+			value: this.value
+		};
+	}
+}, None = class e {
+	_tag = "None";
+	static _instance = null;
+	constructor() {}
+	static instance() {
+		return e._instance === null && (e._instance = new e()), e._instance;
+	}
+	static of() {
+		return e.instance();
+	}
+	isSome() {
+		return !1;
+	}
+	isNone() {
+		return !0;
+	}
+	unwrap() {
+		throw Error("Called unwrap() on None");
+	}
+	unwrapOr(e) {
+		return e;
+	}
+	unwrapOrElse(e) {
+		return e();
+	}
+	andThen(t) {
+		return e.instance();
+	}
+	map(t) {
+		return e.instance();
+	}
+	match(e) {
+		return e.None;
+	}
+	or(e) {
+		return e;
+	}
+	orElse(e) {
+		return e();
+	}
+	filter(t) {
+		return e.instance();
+	}
+	toString() {
+		return "None";
+	}
+	toJSON() {
+		return { none: !0 };
+	}
+}, Ok = class n {
+	_tag = "Ok";
+	constructor(e) {
+		this.value = e;
+	}
+	static of(e) {
+		return new n(e);
+	}
+	static collect(e) {
+		let t = [];
+		for (let n of e) {
+			if (n.isErr()) return n;
+			t.push(n.unwrap());
+		}
+		return new n(t);
+	}
+	static partition(e) {
+		let t = [], n = [];
+		for (let r of e) r.isOk() ? t.push(r) : n.push(r);
+		return [t, n];
+	}
+	isOk() {
+		return !0;
+	}
+	isErr() {
+		return !1;
+	}
+	unwrap() {
+		return this.value;
+	}
+	unwrapErr() {
+		throw Error("Called unwrapErr() on Ok");
+	}
+	unwrapOr(e) {
+		return this.value;
+	}
+	unwrapOrElse(e) {
+		return this.value;
+	}
+	map(e) {
+		return new n(e(this.value));
+	}
+	mapErr(e) {
+		return new n(this.value);
+	}
+	andThen(e) {
+		return e(this.value);
+	}
+	match(e) {
+		return e.Ok(this.value);
+	}
+	inspect(e) {
+		return e(this.value), this;
+	}
+	inspectErr(e) {
+		return this;
+	}
+	expect(e) {
+		return this.value;
+	}
+	expectErr(e) {
+		throw Error(e);
+	}
+	or(e) {
+		return this;
+	}
+	orElse(e) {
+		return this;
+	}
+	ok() {
+		return new Some(this.value);
+	}
+	err() {
+		return None.instance();
+	}
+	toString() {
+		return `Ok(${String(this.value)})`;
+	}
+	toJSON() {
+		return {
+			ok: !0,
+			value: this.value
+		};
+	}
+}, Err = class n {
+	_tag = "Err";
+	constructor(e) {
+		this.error = e;
+	}
+	static of(e) {
+		return new n(e);
+	}
+	isOk() {
+		return !1;
+	}
+	isErr() {
+		return !0;
+	}
+	unwrap() {
+		throw Error("Called unwrap() on Err");
+	}
+	unwrapErr() {
+		return this.error;
+	}
+	unwrapOr(e) {
+		return e;
+	}
+	unwrapOrElse(e) {
+		return e(this.error);
+	}
+	map(e) {
+		return new n(this.error);
+	}
+	mapErr(e) {
+		return new n(e(this.error));
+	}
+	andThen(e) {
+		return new n(this.error);
+	}
+	match(e) {
+		return e.Err(this.error);
+	}
+	inspect(e) {
+		return this;
+	}
+	inspectErr(e) {
+		return e(this.error), this;
+	}
+	expect(e) {
+		throw Error(e);
+	}
+	expectErr(e) {
+		return this.error;
+	}
+	or(e) {
+		return e;
+	}
+	orElse(e) {
+		return e(this.error);
+	}
+	ok() {
+		return None.instance();
+	}
+	err() {
+		return new Some(this.error);
+	}
+	toString() {
+		return `Err(${String(this.error)})`;
+	}
+	toJSON() {
+		return {
+			ok: !1,
+			error: this.error
+		};
+	}
+}, IterOp = /* @__PURE__ */ function(e) {
+	return e[e.Map = 1] = "Map", e[e.Filter = 2] = "Filter", e[e.FlatMap = 4] = "FlatMap", e[e.Flatten = 8] = "Flatten", e[e.Take = 16] = "Take", e[e.TakeWhile = 32] = "TakeWhile", e[e.Skip = 64] = "Skip", e[e.SkipWhile = 128] = "SkipWhile", e[e.Enumerate = 256] = "Enumerate", e[e.Zip = 512] = "Zip", e[e.Chain = 1024] = "Chain", e[e.StepBy = 2048] = "StepBy", e[e.Inspect = 4096] = "Inspect", e[e.Unique = 8192] = "Unique", e[e.UniqueBy = 16384] = "UniqueBy", e;
+}(IterOp || {}), Iter = class n {
+	source;
+	ops;
+	opsMask;
+	constructor(e, t = [], n = 0) {
+		this.source = e, this.ops = t, this.opsMask = n;
+	}
+	get isArray() {
+		return Array.isArray(this.source);
+	}
+	get isTypedArray() {
+		return this.source instanceof Int8Array || this.source instanceof Uint8Array || this.source instanceof Uint8ClampedArray || this.source instanceof Int16Array || this.source instanceof Uint16Array || this.source instanceof Int32Array || this.source instanceof Uint32Array || this.source instanceof Float32Array || this.source instanceof Float64Array;
+	}
+	static from(e) {
+		return new n(e);
+	}
+	static range(e, t, r = 1) {
+		return new n({ *[Symbol.iterator]() {
+			if (r > 0) for (let n = e; n < t; n += r) yield n;
+			else if (r < 0) for (let n = e; n > t; n += r) yield n;
+		} });
+	}
+	static repeat(e) {
+		return new n({ *[Symbol.iterator]() {
+			for (;;) yield e;
+		} });
+	}
+	static generate(e) {
+		return new n({ *[Symbol.iterator]() {
+			for (;;) yield e();
+		} });
+	}
+	static empty() {
+		return new n({ *[Symbol.iterator]() {} });
+	}
+	static once(e) {
+		return new n({ *[Symbol.iterator]() {
+			yield e;
+		} });
+	}
+	[Symbol.iterator]() {
+		return this.ops.length === 0 ? this.source[Symbol.iterator]() : this.executePipeline();
+	}
+	*executePipeline() {
+		let e = (this.opsMask & IterOp.Filter) !== 0, t = (this.opsMask & IterOp.Take) !== 0, n = (this.opsMask & IterOp.TakeWhile) !== 0, r = (this.opsMask & IterOp.Skip) !== 0, a = (this.opsMask & IterOp.SkipWhile) !== 0, o = (this.opsMask & IterOp.StepBy) !== 0, s = (this.opsMask & IterOp.Inspect) !== 0, c = (this.opsMask & IterOp.Unique) !== 0, l = (this.opsMask & IterOp.UniqueBy) !== 0, u = (this.opsMask & IterOp.Map) !== 0, d = (this.opsMask & IterOp.FlatMap) !== 0, f = (this.opsMask & IterOp.Flatten) !== 0;
+		if (u && !e && !d && !f && !c && !l) {
+			yield* this.executeMapOnlyPipeline();
+			return;
+		}
+		let p = this.source[Symbol.iterator](), m = 0, h = 0, g = null, _ = 0, v = null, y = null, b = !0, x = null, S = null, C = null, w = null;
+		if (t || r || o || n || a || c || l) for (let e of this.ops) e.type === "take" && typeof e.param == "number" ? g = e.param : e.type === "skip" && typeof e.param == "number" ? v = e.param : e.type === "stepBy" && typeof e.param == "number" ? y = e.param : e.type === "takeWhile" ? S = e.fn : e.type === "skipWhile" ? x = e.fn : e.type === "unique" ? C = /* @__PURE__ */ new Set() : e.type === "uniqueBy" && (C = /* @__PURE__ */ new Set(), w = e.fn);
+		mainLoop: for (;;) {
+			let e = p.next();
+			if (e.done) break;
+			let n = e.value, i = m++;
+			if (r && v !== null && _ < v) {
+				_++;
+				continue;
+			}
+			if (a && b && x) {
+				if (x(n, i)) continue;
+				b = !1;
+			}
+			if (!(o && y !== null && i % y !== 0)) {
+				for (let e = 0; e < this.ops.length; e++) {
+					let r = this.ops[e];
+					if (d && r.type === "flatMap") {
+						let a = r.fn(n, i);
+						for (let n of a) {
+							let r = n, a = !0;
+							for (let t = e + 1; t < this.ops.length; t++) {
+								let e = this.ops[t];
+								switch (e.type) {
+									case "map":
+										r = e.fn(r, i);
+										break;
+									case "filter":
+										if (!e.fn(r, i)) {
+											a = !1;
+											break;
+										}
+										break;
+									case "inspect":
+										e.fn(r, i);
+										break;
+									case "unique":
+										if (C.has(r)) {
+											a = !1;
+											break;
+										}
+										C.add(r);
+										break;
+									case "uniqueBy":
+										if (w) {
+											let e = w(r);
+											if (C.has(e)) {
+												a = !1;
+												break;
+											}
+											C.add(e);
+										}
+										break;
+								}
+								if (!a) break;
+							}
+							if (a) {
+								if (t && g !== null) {
+									if (h >= g) break mainLoop;
+									h++;
+								}
+								yield r;
+							}
+						}
+						continue mainLoop;
+					} else if (f && r.type === "flatten") {
+						for (let r of n) {
+							let n = r, a = !0;
+							for (let t = e + 1; t < this.ops.length; t++) {
+								let e = this.ops[t];
+								switch (e.type) {
+									case "map":
+										n = e.fn(n, i);
+										break;
+									case "filter":
+										if (!e.fn(n, i)) {
+											a = !1;
+											break;
+										}
+										break;
+									case "inspect":
+										e.fn(n, i);
+										break;
+									case "unique":
+										if (C.has(n)) {
+											a = !1;
+											break;
+										}
+										C.add(n);
+										break;
+									case "uniqueBy":
+										if (w) {
+											let e = w(n);
+											if (C.has(e)) {
+												a = !1;
+												break;
+											}
+											C.add(e);
+										}
+										break;
+								}
+								if (!a) break;
+							}
+							if (a) {
+								if (t && g !== null) {
+									if (h >= g) break mainLoop;
+									h++;
+								}
+								yield n;
+							}
+						}
+						continue mainLoop;
+					}
+					switch (r.type) {
+						case "map":
+							n = r.fn(n, i);
+							break;
+						case "filter":
+							if (!r.fn(n, i)) continue mainLoop;
+							break;
+						case "take": break;
+						case "takeWhile":
+							if (S && !S(n, i)) break mainLoop;
+							break;
+						case "skip": break;
+						case "skipWhile": break;
+						case "enumerate":
+							n = [i, n];
+							break;
+						case "zip": break;
+						case "chain": break;
+						case "inspect":
+							s && r.fn(n, i);
+							break;
+						case "unique":
+							if (c && C.has(n)) continue mainLoop;
+							c && C.add(n);
+							break;
+						case "uniqueBy":
+							if (l && w) {
+								let e = w(n);
+								if (C.has(e)) continue mainLoop;
+								C.add(e);
+							}
+							break;
+					}
+				}
+				if (t && g !== null) {
+					if (h >= g) break;
+					h++;
+				}
+				yield n;
+			}
+		}
+	}
+	*executeMapOnlyPipeline() {
+		let e = this.source[Symbol.iterator](), t = 0, n = 0, r = null, i = 0, a = null, o = null, s = !0, c = null, l = null;
+		for (let e of this.ops) e.type === "take" && typeof e.param == "number" ? r = e.param : e.type === "skip" && typeof e.param == "number" ? a = e.param : e.type === "stepBy" && typeof e.param == "number" ? o = e.param : e.type === "takeWhile" ? l = e.fn : e.type === "skipWhile" && (c = e.fn);
+		mainLoop: for (;;) {
+			let u = e.next();
+			if (u.done) break;
+			let d = u.value, f = t++;
+			if (a !== null && i < a) {
+				i++;
+				continue;
+			}
+			if (s && c) {
+				if (c(d, f)) continue;
+				s = !1;
+			}
+			if (!(o !== null && f % o !== 0)) {
+				for (let e of this.ops) switch (e.type) {
+					case "map":
+						d = e.fn(d, f);
+						break;
+					case "takeWhile":
+						if (l && !l(d, f)) break mainLoop;
+						break;
+					case "enumerate":
+						d = [f, d];
+						break;
+					case "inspect":
+						e.fn(d, f);
+						break;
+				}
+				if (r !== null) {
+					if (n >= r) break;
+					n++;
+				}
+				yield d;
+			}
+		}
+	}
+	map(e) {
+		return new n(this.source, [...this.ops, {
+			type: "map",
+			fn: e
+		}], this.opsMask | IterOp.Map);
+	}
+	filter(e) {
+		return new n(this.source, [...this.ops, {
+			type: "filter",
+			fn: e
+		}], this.opsMask | IterOp.Filter);
+	}
+	flatMap(e) {
+		return new n(this.source, [...this.ops, {
+			type: "flatMap",
+			fn: e
+		}], this.opsMask | IterOp.FlatMap);
+	}
+	flatten() {
+		return new n(this.source, [...this.ops, {
+			type: "flatten",
+			fn: () => {}
+		}], this.opsMask | IterOp.Flatten);
+	}
+	take(e) {
+		return new n(this.source, [...this.ops, {
+			type: "take",
+			fn: () => {},
+			param: e
+		}], this.opsMask | IterOp.Take);
+	}
+	takeWhile(e) {
+		return new n(this.source, [...this.ops, {
+			type: "takeWhile",
+			fn: e
+		}], this.opsMask | IterOp.TakeWhile);
+	}
+	skip(e) {
+		return new n(this.source, [...this.ops, {
+			type: "skip",
+			fn: () => {},
+			param: e
+		}], this.opsMask | IterOp.Skip);
+	}
+	skipWhile(e) {
+		return new n(this.source, [...this.ops, {
+			type: "skipWhile",
+			fn: e
+		}], this.opsMask | IterOp.SkipWhile);
+	}
+	enumerate() {
+		return new n(this.source, [...this.ops, {
+			type: "enumerate",
+			fn: () => {}
+		}], this.opsMask | IterOp.Enumerate);
+	}
+	zip(e) {
+		let t = this;
+		return new n({ *[Symbol.iterator]() {
+			let n = t[Symbol.iterator](), r = e[Symbol.iterator]();
+			for (;;) {
+				let e = n.next(), t = r.next();
+				if (e.done || t.done) break;
+				yield [e.value, t.value];
+			}
+		} });
+	}
+	chain(e) {
+		let t = this;
+		return new n({ *[Symbol.iterator]() {
+			yield* t, yield* e;
+		} });
+	}
+	stepBy(e) {
+		if (e <= 0) throw Error("step must be positive");
+		return new n(this.source, [...this.ops, {
+			type: "stepBy",
+			fn: () => {},
+			param: e
+		}], this.opsMask | IterOp.StepBy);
+	}
+	inspect(e) {
+		return new n(this.source, [...this.ops, {
+			type: "inspect",
+			fn: e
+		}], this.opsMask | IterOp.Inspect);
+	}
+	unique() {
+		return new n(this.source, [...this.ops, {
+			type: "unique",
+			fn: () => {}
+		}], this.opsMask | IterOp.Unique);
+	}
+	uniqueBy(e) {
+		return new n(this.source, [...this.ops, {
+			type: "uniqueBy",
+			fn: e
+		}], this.opsMask | IterOp.UniqueBy);
+	}
+	collect() {
+		if (this.ops.length === 0 && this.isArray) return this.source.slice();
+		if (this.isTypedArray && (this.opsMask & IterOp.Map) !== 0 && (this.opsMask & ~IterOp.Map & ~IterOp.Take & ~IterOp.Skip & ~IterOp.StepBy & ~IterOp.TakeWhile & ~IterOp.SkipWhile) === 0) return this.collectTypedArrayMapOnly();
+		let e = null;
+		for (let t of this.ops) if (t.type === "take" && typeof t.param == "number") {
+			e = t.param;
+			break;
+		}
+		let t = [];
+		e !== null && e > 0 && (t.length = e);
+		let n = 0;
+		for (let r of this) e !== null && n < e ? t[n++] = r : t.push(r);
+		return e !== null && n < e && (t.length = n), t;
+	}
+	collectTypedArrayMapOnly() {
+		let e = this.source, t = e.length, n = 0, r = null, i = 0, a = null, o = null, s = 0;
+		for (let e of this.ops) e.type === "take" && typeof e.param == "number" ? r = e.param : e.type === "skip" && typeof e.param == "number" ? a = e.param : e.type === "stepBy" && typeof e.param == "number" && (o = e.param);
+		let c = [], l = 0;
+		for (; l < t; l++) {
+			if (a !== null && i < a) {
+				i++;
+				continue;
+			}
+			if (o !== null && s++ % o !== 0) continue;
+			if (r !== null && n >= r) break;
+			let t = e[l];
+			for (let e of this.ops) if (e.type === "map") {
+				let n = e.fn;
+				t = n(t, l);
+			}
+			c[n++] = t;
+		}
+		return c;
+	}
+	fold(e, t) {
+		if (this.ops.length === 0 && this.isArray) {
+			let n = this.source, r = n.length, i = e;
+			for (let e = 0; e < r; e++) i = t(i, n[e], e);
+			return i;
+		}
+		let n = e, r = 0;
+		for (let e of this) n = t(n, e, r++);
+		return n;
+	}
+	foldRight(e, t) {
+		let n = this.collect(), r = e;
+		for (let e = n.length - 1; e >= 0; e--) r = t(r, n[e], e);
+		return r;
+	}
+	reduce(n) {
+		if (this.ops.length === 0 && this.isArray) {
+			let r = this.source, i = r.length;
+			if (i === 0) return None.instance();
+			let a = r[0];
+			for (let e = 1; e < i; e++) a = n(a, r[e], e);
+			return new Some(a);
+		}
+		let r = this[Symbol.iterator](), i = r.next();
+		if (i.done) return None.instance();
+		let a = i.value, o = 1;
+		for (;;) {
+			let e = r.next();
+			if (e.done) break;
+			a = n(a, e.value, o++);
+		}
+		return new Some(a);
+	}
+	forEach(e) {
+		if (this.ops.length === 0 && this.isArray) {
+			let t = this.source, n = t.length;
+			for (let r = 0; r < n; r++) e(t[r], r);
+			return;
+		}
+		let t = 0;
+		for (let n of this) e(n, t++);
+	}
+	count() {
+		if (this.ops.length === 0 && this.isArray) return this.source.length;
+		let e = 0;
+		for (let t of this) e++;
+		return e;
+	}
+	find(n) {
+		if (this.ops.length === 0 && this.isArray) {
+			let r = this.source, i = r.length;
+			for (let t = 0; t < i; t++) if (n(r[t], t)) return new Some(r[t]);
+			return None.instance();
+		}
+		let r = 0;
+		for (let t of this) if (n(t, r++)) return new Some(t);
+		return None.instance();
+	}
+	findJS(e) {
+		let t = this.find(e);
+		return t.isSome() ? t.unwrap() : void 0;
+	}
+	position(n) {
+		if (this.ops.length === 0 && this.isArray) {
+			let r = this.source, i = r.length;
+			for (let t = 0; t < i; t++) if (n(r[t], t)) return new Some(t);
+			return None.instance();
+		}
+		let r = 0;
+		for (let t of this) {
+			if (n(t, r)) return new Some(r);
+			r++;
+		}
+		return None.instance();
+	}
+	findIndex(e) {
+		let t = this.position(e);
+		return t.isSome() ? t.unwrap() : -1;
+	}
+	all(e) {
+		if (this.ops.length === 0 && this.isArray) {
+			let t = this.source, n = t.length;
+			for (let r = 0; r < n; r++) if (!e(t[r], r)) return !1;
+			return !0;
+		}
+		let t = 0;
+		for (let n of this) if (!e(n, t++)) return !1;
+		return !0;
+	}
+	everyJS(e) {
+		return this.all(e);
+	}
+	any(e) {
+		if (this.ops.length === 0 && this.isArray) {
+			let t = this.source, n = t.length;
+			for (let r = 0; r < n; r++) if (e(t[r], r)) return !0;
+			return !1;
+		}
+		let t = 0;
+		for (let n of this) if (e(n, t++)) return !0;
+		return !1;
+	}
+	someJS(e) {
+		return this.any(e);
+	}
+	partition(e) {
+		let t = [], n = [], r = 0;
+		for (let i of this) e(i, r++) ? t.push(i) : n.push(i);
+		return [t, n];
+	}
+	first() {
+		if (this.ops.length === 0 && this.isArray) {
+			let n = this.source;
+			return n.length > 0 ? new Some(n[0]) : None.instance();
+		}
+		for (let t of this) return new Some(t);
+		return None.instance();
+	}
+	last() {
+		if (this.ops.length === 0 && this.isArray) {
+			let n = this.source, r = n.length;
+			return r > 0 ? new Some(n[r - 1]) : None.instance();
+		}
+		let n = None.instance();
+		for (let t of this) n = new Some(t);
+		return n;
+	}
+	nth(n) {
+		if (this.ops.length === 0 && this.isArray) {
+			let r = this.source;
+			return n >= 0 && n < r.length ? new Some(r[n]) : None.instance();
+		}
+		let r = 0;
+		for (let t of this) {
+			if (r === n) return new Some(t);
+			r++;
+		}
+		return None.instance();
+	}
+	includes(e, t) {
+		let n = 0;
+		for (let r of this) {
+			if (t !== void 0 && n < t) {
+				n++;
+				continue;
+			}
+			if (r === e) return !0;
+			n++;
+		}
+		return !1;
+	}
+	max() {
+		let n = None.instance();
+		for (let t of this) (n.isNone() || t > n.unwrap()) && (n = new Some(t));
+		return n;
+	}
+	min() {
+		let n = None.instance();
+		for (let t of this) (n.isNone() || t < n.unwrap()) && (n = new Some(t));
+		return n;
+	}
+	maxBy(n) {
+		let r = None.instance();
+		for (let t of this) {
+			let i = n(t);
+			if (r.isNone()) r = new Some([t, i]);
+			else {
+				let [, n] = r.unwrap();
+				i > n && (r = new Some([t, i]));
+			}
+		}
+		return r.map(([e]) => e);
+	}
+	minBy(n) {
+		let r = None.instance();
+		for (let t of this) {
+			let i = n(t);
+			if (r.isNone()) r = new Some([t, i]);
+			else {
+				let [, n] = r.unwrap();
+				i < n && (r = new Some([t, i]));
+			}
+		}
+		return r.map(([e]) => e);
+	}
+	sum() {
+		if (this.ops.length === 0 && this.isArray) {
+			let e = this.source, t = e.length, n = 0;
+			for (let r = 0; r < t; r++) n += e[r];
+			return n;
+		}
+		return this.fold(0, (e, t) => e + t);
+	}
+	product() {
+		return this.fold(1, (e, t) => e * t);
+	}
+	join(e = "") {
+		return this.collect().join(e);
+	}
+	toSet() {
+		return new Set(this);
+	}
+	toMap() {
+		return new Map(this);
+	}
+	groupBy(e) {
+		let t = /* @__PURE__ */ new Map();
+		for (let n of this) {
+			let r = e(n), i = t.get(r);
+			i ? i.push(n) : t.set(r, [n]);
+		}
+		return t;
+	}
+	sort(e) {
+		return new n(this.collect().sort(e));
+	}
+	sortBy(e) {
+		return new n(this.collect().sort((t, n) => {
+			let r = e(t), i = e(n);
+			return r < i ? -1 : r > i ? 1 : 0;
+		}));
+	}
+	reverse() {
+		return new n(this.collect().reverse());
+	}
+};
+function match(e) {
+	return function(t) {
+		let n = String(t);
+		return n in e ? e[n](t) : e._(t);
+	};
+}
+function dispatch() {
+	let e = [], t = null;
+	function n(n) {
+		for (let { guard: t, handler: r } of e) if (t(n)) return r(n);
+		if (t) return t(n);
+		throw Error(`No handler registered for value: ${n}`);
+	}
+	return n.on = function(t, r) {
+		return e.push({
+			guard: t,
+			handler: r
+		}), n;
+	}, n.default = function(e) {
+		return t = e, n;
+	}, n;
+}
+const isNumber = (e) => typeof e == "number", isString = (e) => typeof e == "string", isArray = (e) => Array.isArray(e), isBoolean = (e) => typeof e == "boolean", isNull = (e) => e === null, isUndefined = (e) => e === void 0, isObject = (e) => typeof e == "object" && !!e && !Array.isArray(e), isFunction = (e) => typeof e == "function";
+var Bimap = class e {
+	_forward;
+	_reverse;
+	constructor() {
+		this._forward = /* @__PURE__ */ new Map(), this._reverse = /* @__PURE__ */ new Map();
+	}
+	static from(t) {
+		let n = new e();
+		for (let [e, r] of t) n.set(e, r);
+		return n;
+	}
+	static of(...t) {
+		let n = new e();
+		for (let [e, r] of t) n.set(e, r);
+		return n;
+	}
+	set(e, t) {
+		let n = this._forward.get(e);
+		n !== void 0 && this._reverse.delete(n);
+		let r = this._reverse.get(t);
+		return r !== void 0 && this._forward.delete(r), this._forward.set(e, t), this._reverse.set(t, e), this;
+	}
+	get(e) {
+		return this._forward.get(e);
+	}
+	getReverse(e) {
+		return this._reverse.get(e);
+	}
+	has(e) {
+		return this._forward.has(e);
+	}
+	hasValue(e) {
+		return this._reverse.has(e);
+	}
+	delete(e) {
+		let t = this._forward.get(e);
+		return t === void 0 ? !1 : (this._forward.delete(e), this._reverse.delete(t), !0);
+	}
+	deleteValue(e) {
+		let t = this._reverse.get(e);
+		return t === void 0 ? !1 : (this._reverse.delete(e), this._forward.delete(t), !0);
+	}
+	clear() {
+		this._forward.clear(), this._reverse.clear();
+	}
+	get size() {
+		return this._forward.size;
+	}
+	keys() {
+		return Array.from(this._forward.keys());
+	}
+	values() {
+		return Array.from(this._forward.values());
+	}
+	entries() {
+		return Array.from(this._forward.entries());
+	}
+	reverseEntries() {
+		return Array.from(this._reverse.entries());
+	}
+	forEach(e) {
+		this._forward.forEach((t, n) => {
+			e(t, n, this);
+		});
+	}
+	forEachReverse(e) {
+		this._reverse.forEach((t, n) => {
+			e(t, n, this);
+		});
+	}
+	clone() {
+		let t = new e();
+		return this._forward.forEach((e, n) => {
+			t.set(n, e);
+		}), t;
+	}
+	toString() {
+		return `Bimap { ${this.entries().map(([e, t]) => `${String(e)} => ${String(t)}`).join(", ")} }`;
+	}
+	toJSON() {
+		return {
+			forward: this.entries(),
+			reverse: this.reverseEntries()
+		};
+	}
+}, Stack = class n {
+	items = [];
+	push(e) {
+		return this.items.push(e), this;
+	}
+	pop() {
+		return this.isEmpty() ? None.instance() : new Some(this.items.pop());
+	}
+	peek() {
+		return this.isEmpty() ? None.instance() : new Some(this.items[this.items.length - 1]);
+	}
+	get size() {
+		return this.items.length;
+	}
+	isEmpty() {
+		return this.items.length === 0;
+	}
+	clear() {
+		this.items = [];
+	}
+	[Symbol.iterator]() {
+		let e = this.items.length - 1;
+		return { next: () => e < 0 ? {
+			value: void 0,
+			done: !0
+		} : {
+			value: this.items[e--],
+			done: !1
+		} };
+	}
+	static from(e) {
+		let t = new n();
+		for (let n of e) t.push(n);
+		return t;
+	}
+}, Queue = class n {
+	buffer;
+	head = 0;
+	tail = 0;
+	count = 0;
+	constructor(e = 16) {
+		if (e < 1) throw Error("Initial capacity must be at least 1");
+		this.buffer = Array.from({ length: e });
+	}
+	enqueue(e) {
+		this.count === this.buffer.length && this.resize(), this.buffer[this.tail] = e, this.tail = (this.tail + 1) % this.buffer.length, this.count++;
+	}
+	dequeue() {
+		if (this.isEmpty()) return None.instance();
+		let n = this.buffer[this.head];
+		return this.buffer[this.head] = void 0, this.head = (this.head + 1) % this.buffer.length, this.count--, new Some(n);
+	}
+	peek() {
+		return this.isEmpty() ? None.instance() : new Some(this.buffer[this.head]);
+	}
+	get size() {
+		return this.count;
+	}
+	isEmpty() {
+		return this.count === 0;
+	}
+	clear() {
+		this.buffer.fill(void 0), this.head = 0, this.tail = 0, this.count = 0;
+	}
+	resize() {
+		let e = Array.from({ length: this.buffer.length * 2 });
+		for (let t = 0; t < this.count; t++) e[t] = this.buffer[(this.head + t) % this.buffer.length];
+		this.buffer = e, this.head = 0, this.tail = this.count;
+	}
+	[Symbol.iterator]() {
+		let e = 0;
+		return { next: () => {
+			if (e >= this.count) return {
+				value: void 0,
+				done: !0
+			};
+			let t = this.buffer[(this.head + e) % this.buffer.length];
+			return e++, {
+				value: t,
+				done: !1
+			};
+		} };
+	}
+	static from(e) {
+		let t = new n();
+		for (let n of e) t.enqueue(n);
+		return t;
+	}
+};
+export { Bimap, Err, Iter, None, Ok, Queue, Some, Stack, dispatch, isArray, isBoolean, isFunction, isNull, isNumber, isObject, isString, isUndefined, match };