@effect-app/vue-components 4.0.0-beta.22 → 4.0.0-beta.221

package/dist/vue-components37.es.js

@@ -0,0 +1,688 @@
+import { pipeArguments as e } from "./vue-components12.es.js";
+import { constVoid as t, dual as n, identity as r } from "./vue-components13.es.js";
+import { hasProperty as i } from "./vue-components15.es.js";
+import { combine as a, random as o, string as s, symbol as c } from "./vue-components16.es.js";
+import { equals as l, symbol as u } from "./vue-components17.es.js";
+import { currentFiberTypeId as d } from "./vue-components20.es.js";
+import { formatJson as f } from "./vue-components21.es.js";
+import { internalCall as p } from "./vue-components23.es.js";
+import { CauseImpl as m, ExitTypeId as h, InterruptorStackTrace as g, NoSuchElementError as ee, ReasonBase as te, StackTraceKey as _, TaggedError as v, Yield as y, args as b, causeAnnotate as ne, causeFromReasons as x, constEmptyAnnotations as re, contA as S, contAll as C, contE as w, evaluate as T, exitDie as E, exitFail as D, exitFailCause as O, exitSucceed as k, isEffect as ie, isFailReason as ae, isInterruptReason as oe, makePrimitive as A, makePrimitiveProto as j, withFiber as M } from "./vue-components24.es.js";
+import { none as N, some as se } from "./vue-components28.es.js";
+import { fail as ce, isFailure as P, succeed as le } from "./vue-components29.es.js";
+import { fromIterable as ue, union as de } from "./vue-components30.es.js";
+import { add as fe, empty as pe, getReferenceUnsafe as me, make as he, makeUnsafe as ge, merge as _e } from "./vue-components32.es.js";
+import { MaxOpsBeforeYield as ve, MixedScheduler as ye, PreventSchedulerYield as be, Scheduler as xe } from "./vue-components33.es.js";
+import { ParentSpanKey as Se, TracerKey as Ce } from "./vue-components34.es.js";
+import { FiberRuntimeMetricsKey as we } from "./vue-components35.es.js";
+import { CurrentConcurrency as Te, CurrentLogLevel as Ee, CurrentStackFrame as De, MinimumLogLevel as Oe } from "./vue-components36.es.js";
+//#region ../../node_modules/.pnpm/effect@4.0.0-beta.62/node_modules/effect/dist/internal/effect.js
+var ke = class extends te {
+	fiberId;
+	constructor(e, t = re) {
+		super("Interrupt", t, "Interrupted"), this.fiberId = e;
+	}
+	toString() {
+		return `Interrupt(${this.fiberId})`;
+	}
+	toJSON() {
+		return {
+			_tag: "Interrupt",
+			fiberId: this.fiberId
+		};
+	}
+	[u](e) {
+		return oe(e) && this.fiberId === e.fiberId && this.annotations === e.annotations;
+	}
+	[c]() {
+		return a(s(`${this._tag}:${this.fiberId}`))(o(this.annotations));
+	}
+}, Ae = (e) => new m([new ke(e)]), F = (e) => {
+	for (let t = 0; t < e.reasons.length; t++) {
+		let n = e.reasons[t];
+		if (n._tag === "Fail") return le(n.error);
+	}
+	return ce(e);
+}, je = (e) => e.reasons.some(oe), Me = /* @__PURE__ */ n(2, (e, t) => {
+	if (e.reasons.length === 0) return t;
+	if (t.reasons.length === 0) return e;
+	let n = new m(de(e.reasons, t.reasons));
+	return l(e, n) ? e : n;
+}), Ne = (e) => {
+	let t = {
+		Fail: [],
+		Die: [],
+		Interrupt: []
+	};
+	for (let n = 0; n < e.reasons.length; n++) t[e.reasons[n]._tag].push(e.reasons[n]);
+	return t;
+}, Pe = (e) => {
+	let t = Ne(e);
+	return t.Fail.length > 0 ? t.Fail[0].error : t.Die.length > 0 ? t.Die[0].defect : t.Interrupt.length > 0 ? new globalThis.Error("All fibers interrupted without error") : new globalThis.Error("Empty cause");
+}, Fe = (e) => {
+	let t = [], n = [];
+	if (e.reasons.length === 0) return t;
+	let r = Error.stackTraceLimit;
+	Error.stackTraceLimit = 1;
+	for (let r of e.reasons) {
+		if (r._tag === "Interrupt") {
+			n.push(r);
+			continue;
+		}
+		t.push(I(r._tag === "Die" ? r.defect : r.error, r.annotations));
+	}
+	if (t.length === 0) {
+		let e = /* @__PURE__ */ Error("The fiber was interrupted by:");
+		e.name = "InterruptCause", e.stack = Be(e, n);
+		let r = new globalThis.Error("All fibers interrupted without error", { cause: e });
+		r.name = "InterruptError", r.stack = `${r.name}: ${r.message}`, t.push(I(r, n[0].annotations));
+	}
+	return Error.stackTraceLimit = r, t;
+}, I = (e, t) => {
+	let n = typeof e, r;
+	if (e && n === "object") {
+		if (r = new globalThis.Error(Ie(e), { cause: e.cause ? I(e.cause) : void 0 }), typeof e.name == "string" && (r.name = e.name), typeof e.stack == "string") r.stack = Re(e.stack, r, t);
+		else {
+			let e = `${r.name}: ${r.message}`;
+			r.stack = t ? ze(e, t) : e;
+		}
+		for (let t of Object.keys(e)) t in r || (r[t] = e[t]);
+	} else r = new globalThis.Error(e ? n === "string" ? e : f(e) : `Unknown error: ${e}`);
+	return r;
+}, Ie = (e) => {
+	if (typeof e.message == "string") return e.message;
+	if (typeof e.toString == "function" && e.toString !== Object.prototype.toString && e.toString !== Array.prototype.toString) try {
+		return e.toString();
+	} catch {}
+	return f(e);
+}, Le = /\((.*)\)/g, Re = (e, t, n) => {
+	let r = `${t.name}: ${t.message}`, i = (e.startsWith(r) ? e.slice(r.length) : e).split("\n"), a = [r];
+	for (let e = 1; e < i.length && !/(?:Generator\.next|~effect\/Effect)/.test(i[e]); e++) a.push(i[e]);
+	return n ? ze(a.join("\n"), n) : a.join("\n");
+}, ze = (e, t) => {
+	let n = t?.get(_.key);
+	return n && (e = `${e}\n${Ve(n)}`), e;
+}, Be = (e, t) => {
+	let n = [`${e.name}: ${e.message}`];
+	for (let e of t) {
+		let t = e.fiberId === void 0 ? "unknown" : `#${e.fiberId}`, r = e.annotations.get(g.key);
+		n.push(`    at fiber (${t})`), r && n.push(Ve(r));
+	}
+	return n.join("\n");
+}, Ve = (e) => {
+	let t = [], n = e, r = 0;
+	for (; n && r < 10;) {
+		let e = n.stack();
+		if (e) {
+			let r = e.matchAll(Le), i = !1;
+			for (let [, e] of r) i = !0, t.push(`    at ${n.name} (${e})`);
+			i || t.push(`    at ${n.name} (${e.replace(/^at /, "")})`);
+		} else t.push(`    at ${n.name}`);
+		n = n.parent, r++;
+	}
+	return t.join("\n");
+}, He = (e) => Fe(e).map((e) => e.cause ? `${e.stack} {\n${Ue(e.cause, "  ")}\n}` : e.stack).join("\n"), Ue = (e, t) => {
+	let n = e.stack.split("\n"), r = `${t}[cause]: ${n[0]}`;
+	for (let e = 1, i = n.length; e < i; e++) r += `\n${t}${n[e]}`;
+	return e.cause && (r += ` {\n${Ue(e.cause, `${t}  `)}\n${t}}`), r;
+}, L = "~effect/Fiber/dev", We = {
+	_A: r,
+	_E: r
+}, Ge = { id: 0 }, Ke = () => globalThis[d], qe = class {
+	constructor(e, t = !0) {
+		this[L] = We, this.setContext(e), this.id = ++Ge.id, this.currentOpCount = 0, this.currentLoopCount = 0, this.interruptible = t, this._stack = [], this._observers = [], this._exit = void 0, this._children = void 0, this._interruptedCause = void 0, this._yielded = void 0, this.runtimeMetrics?.recordFiberStart(this.context);
+	}
+	[L];
+	id;
+	interruptible;
+	currentOpCount;
+	currentLoopCount;
+	_stack;
+	_observers;
+	_exit;
+	_currentExit;
+	_children;
+	_interruptedCause;
+	_yielded;
+	context;
+	currentScheduler;
+	currentTracerContext;
+	currentSpan;
+	currentLogLevel;
+	minimumLogLevel;
+	currentStackFrame;
+	runtimeMetrics;
+	maxOpsBeforeYield;
+	currentPreventYield;
+	_dispatcher = void 0;
+	get currentDispatcher() {
+		return this._dispatcher ??= this.currentScheduler.makeDispatcher();
+	}
+	getRef(e) {
+		return me(this.context, e);
+	}
+	addObserver(e) {
+		return this._exit ? (e(this._exit), t) : (this._observers.push(e), () => {
+			let t = this._observers.indexOf(e);
+			t >= 0 && this._observers.splice(t, 1);
+		});
+	}
+	interruptUnsafe(e, t) {
+		if (this._exit) return;
+		let n = Ae(e);
+		this.currentStackFrame && (n = ne(n, he(_, this.currentStackFrame))), t && (n = ne(n, t)), this._interruptedCause = this._interruptedCause ? Me(this._interruptedCause, n) : n, this.interruptible && this.evaluate(B(this._interruptedCause));
+	}
+	pollUnsafe() {
+		return this._exit;
+	}
+	evaluate(e) {
+		if (this._exit) return;
+		if (this._yielded !== void 0) {
+			let e = this._yielded;
+			this._yielded = void 0, e();
+		}
+		let t = this.runLoop(e);
+		if (t === y) return;
+		let n = Je.interruptChildren && Je.interruptChildren(this);
+		if (n !== void 0) return this.evaluate(J(n, () => t));
+		this._exit = t, this.runtimeMetrics?.recordFiberEnd(this.context, this._exit);
+		for (let e = 0; e < this._observers.length; e++) this._observers[e](t);
+		this._observers.length = 0;
+	}
+	runLoop(e) {
+		let t = globalThis[d];
+		globalThis[d] = this;
+		let n = !1, r = e;
+		this.currentOpCount = 0;
+		let a = ++this.currentLoopCount;
+		try {
+			for (;;) {
+				if (this.currentOpCount++, !n && !this.currentPreventYield && this.currentScheduler.shouldYield(this)) {
+					n = !0;
+					let e = r;
+					r = J(et, () => e);
+				}
+				if (r = this.currentTracerContext ? this.currentTracerContext(r, this) : r[T](this), a !== this.currentLoopCount) return y;
+				if (r === y) {
+					let e = this._yielded;
+					return h in e ? (this._yielded = void 0, e) : y;
+				}
+			}
+		} catch (e) {
+			return i(r, T) ? this.runLoop(E(e)) : E(`Fiber.runLoop: Not a valid effect: ${String(r)}`);
+		} finally {
+			globalThis[d] = t;
+		}
+	}
+	getCont(e) {
+		for (;;) {
+			let t = this._stack.pop();
+			if (!t) return;
+			let n = t[C] && t[C](this);
+			if (n) return n[e] = n, n;
+			if (t[e]) return t;
+		}
+	}
+	yieldWith(e) {
+		return this._yielded = e, y;
+	}
+	children() {
+		return this._children ??= /* @__PURE__ */ new Set();
+	}
+	pipe() {
+		return e(this, arguments);
+	}
+	setContext(e) {
+		this.context = e;
+		let t = this.getRef(xe);
+		t !== this.currentScheduler && (this.currentScheduler = t, this._dispatcher = void 0), this.currentSpan = e.mapUnsafe.get(Se), this.currentLogLevel = this.getRef(Ee), this.minimumLogLevel = this.getRef(Oe), this.currentStackFrame = e.mapUnsafe.get(De.key), this.maxOpsBeforeYield = this.getRef(ve), this.currentPreventYield = this.getRef(be), this.runtimeMetrics = e.mapUnsafe.get(we);
+		let n = e.mapUnsafe.get(Ce);
+		this.currentTracerContext = n ? n.context : void 0;
+	}
+	get currentSpanLocal() {
+		return this.currentSpan?._tag === "Span" ? this.currentSpan : void 0;
+	}
+}, Je = { interruptChildren: void 0 }, R = (e) => {
+	if (!e.currentStackFrame) return;
+	let t = /* @__PURE__ */ new Map();
+	return t.set(_.key, e.currentStackFrame), ge(t);
+}, Ye = (e) => {
+	let t = e;
+	return t._exit ? z(t._exit) : K((n) => t._exit ? n(z(t._exit)) : H(e.addObserver((e) => n(z(e)))));
+}, Xe = (e) => K((t) => {
+	let n = e[Symbol.iterator](), r = [], i;
+	function a() {
+		let e = n.next();
+		for (; !e.done;) {
+			if (e.value._exit) {
+				r.push(e.value._exit), e = n.next();
+				continue;
+			}
+			i = e.value.addObserver((e) => {
+				r.push(e), a();
+			});
+			return;
+		}
+		t(z(r));
+	}
+	return a(), H(() => i?.());
+}), Ze = (e) => M((t) => Qe(e, t.id)), Qe = /* @__PURE__ */ n((e) => i(e[0], L), (e, t, n) => M((r) => {
+	let i = R(r);
+	return i = i && n ? _e(i, n) : i ?? n, e.interruptUnsafe(t, i), ht(Ye(e));
+})), $e = (e) => M((t) => {
+	let n = R(t);
+	for (let r of e) r.interruptUnsafe(t.id, n);
+	return ht(Xe(e));
+}), z = k, B = O, V = D, H = /* @__PURE__ */ A({
+	op: "Sync",
+	[T](e) {
+		let t = this[b](), n = e.getCont(S);
+		return n ? n[S](t, e) : e.yieldWith(k(t));
+	}
+}), U = /* @__PURE__ */ A({
+	op: "Suspend",
+	[T](e) {
+		return this[b]();
+	}
+}), et = /* @__PURE__ */ (/* @__PURE__ */ A({
+	op: "Yield",
+	[T](e) {
+		let t = !1;
+		return e.currentDispatcher.scheduleTask(() => {
+			t || e.evaluate(X);
+		}, this[b] ?? 0), e.yieldWith(() => {
+			t = !0;
+		});
+	}
+}))(0), tt = (e) => z(se(e)), nt = /* @__PURE__ */ z(/* @__PURE__ */ N()), rt = (e) => E(e), it = (e) => U(() => V(p(e))), W = /* @__PURE__ */ z(void 0), at = (e) => U(() => {
+	try {
+		return z(p(e.try));
+	} catch (t) {
+		return V(p(() => e.catch(t)));
+	}
+}), ot = (e) => G(function(t, n) {
+	p(() => e(n)).then((e) => t(z(e)), (e) => t(rt(e)));
+}, e.length !== 0), st = (e) => {
+	let t = typeof e == "function" ? e : e.try, n = typeof e == "function" ? (e) => new En(e, "An error occurred in Effect.tryPromise") : e.catch;
+	return G(function(e, r) {
+		try {
+			p(() => t(r)).then((t) => e(z(t)), (t) => e(V(p(() => n(t)))));
+		} catch (t) {
+			e(V(p(() => n(t))));
+		}
+	}, eval.length !== 0);
+}, G = /* @__PURE__ */ A({
+	op: "Async",
+	single: !1,
+	[T](e) {
+		let t = p(() => this[b][0].bind(e.currentScheduler)), n = !1, r = !1, i = this[b][1] ? new AbortController() : void 0, a = t((t) => {
+			n || (n = !0, r ? e.evaluate(t) : r = t);
+		}, i?.signal);
+		return r === !1 ? (r = !0, e._yielded = () => {
+			n = !0;
+		}, i === void 0 && a === void 0 || e._stack.push(ct(() => (n = !0, i?.abort(), a ?? X))), y) : r;
+	}
+}), ct = /* @__PURE__ */ A({
+	op: "AsyncFinalizer",
+	[C](e) {
+		e.interruptible && (e.interruptible = !1, e._stack.push(sn));
+	},
+	[w](e, t) {
+		return je(e) ? J(this[b](), () => B(e)) : B(e);
+	}
+}), K = (e) => G(e, e.length >= 2), lt = (e, ...t) => {
+	let n = t.length === 0 ? function() {
+		return U(() => q(e.apply(this, arguments)));
+	} : function() {
+		let n = U(() => q(e.apply(this, arguments)));
+		for (let e = 0; e < t.length; e++) n = t[e](n, ...arguments);
+		return n;
+	};
+	return ut(e.length, n);
+}, ut = (e, t) => Object.defineProperty(t, "length", {
+	value: e,
+	configurable: !0
+}), dt = (e, ...t) => ut(e.length, t.length === 0 ? function() {
+	return ft(() => e.apply(this, arguments));
+} : function() {
+	let n = ft(() => e.apply(this, arguments));
+	for (let e of t) n = e(n);
+	return n;
+}), ft = (e) => {
+	try {
+		let t = e(), n;
+		for (;;) {
+			let r = t.next(n);
+			if (r.done) return z(r.value);
+			let i = r.value.asEffect(), a = i;
+			if (a && a._tag === "Success") {
+				n = a.value;
+				continue;
+			} else if (a && a._tag === "Failure") return i;
+			else {
+				let n = !0;
+				return U(() => n ? (n = !1, J(i, (e) => q(t, e))) : U(() => q(e())));
+			}
+		}
+	} catch (e) {
+		return rt(e);
+	}
+}, q = /* @__PURE__ */ A({
+	op: "Iterator",
+	single: !1,
+	[S](e, t) {
+		let n = this[b][0];
+		for (;;) {
+			let r = n.next(e);
+			if (r.done) return z(r.value);
+			let i = r.value.asEffect();
+			if (!Y(i)) return t._stack.push(this), i;
+			if (i._tag === "Failure") return i;
+			e = i.value;
+		}
+	},
+	[T](e) {
+		return this[S](this[b][1], e);
+	}
+}), pt = /* @__PURE__ */ n(2, (e, t) => {
+	let n = z(t);
+	return J(e, (e) => n);
+}), mt = /* @__PURE__ */ n(2, (e, t) => J(e, (e) => ie(t) ? t : p(() => t(e)))), ht = (e) => J(e, (e) => X), J = /* @__PURE__ */ n(2, (e, t) => {
+	let n = Object.create(gt);
+	return n[b] = e, n[S] = t.length === 1 ? t : (e) => t(e), n;
+}), gt = /* @__PURE__ */ j({
+	op: "OnSuccess",
+	[T](e) {
+		return e._stack.push(this), this[b];
+	}
+}), Y = (e) => h in e, _t = /* @__PURE__ */ n(2, (e, t) => Y(e) ? e._tag === "Success" ? t(e.value) : e : J(e, t)), vt = /* @__PURE__ */ n(2, (e, t) => J(e, (e) => z(p(() => t(e))))), yt = /* @__PURE__ */ n(2, (e, t) => Y(e) ? wt(e, t) : vt(e, t)), bt = /* @__PURE__ */ n(2, (e, t) => Y(e) ? Tt(e, t) : Rt(e, t)), xt = /* @__PURE__ */ n(2, (e, t) => Y(e) ? Et(e, t) : zt(e, t)), St = /* @__PURE__ */ n(2, (e, t) => {
+	if (Y(e)) {
+		if (e._tag === "Success") return e;
+		let n = F(e.cause);
+		return P(n) ? e : t(n.success);
+	}
+	return Z(e, t);
+}), Ct = (e) => e._tag === "Success", X = /* @__PURE__ */ k(void 0), wt = /* @__PURE__ */ n(2, (e, t) => e._tag === "Success" ? k(t(e.value)) : e), Tt = /* @__PURE__ */ n(2, (e, t) => {
+	if (e._tag === "Success") return e;
+	let n = F(e.cause);
+	return P(n) ? e : D(t(n.success));
+}), Et = /* @__PURE__ */ n(2, (e, t) => {
+	if (e._tag === "Success") return k(t.onSuccess(e.value));
+	let n = F(e.cause);
+	return P(n) ? e : D(t.onFailure(n.success));
+}), Dt = (e) => {
+	let t = [];
+	for (let n of e) n._tag === "Failure" && t.push(...n.cause.reasons);
+	return t.length === 0 ? X : O(x(t));
+}, Ot = (e) => Ct(e) ? se(e.value) : N(), kt = /* @__PURE__ */ n(2, (e, t) => M((n) => {
+	let r = n.context, i = t(r);
+	return r === i ? e : (n.setContext(i), an(e, () => {
+		n.setContext(r);
+	}));
+})), At = () => jt, jt = /* @__PURE__ */ M((e) => z(e.context)), Mt = /* @__PURE__ */ n(2, (e, t) => Y(e) ? e : kt(e, _e(t))), Nt = function() {
+	return arguments.length === 1 ? n(2, (e, t) => Pt(e, arguments[0], t)) : n(3, (e, t, n) => Pt(e, t, n)).apply(this, arguments);
+}, Pt = (e, t, n) => kt(e, (e) => e.mapUnsafe.get(t.key) === n ? e : fe(e, t, n)), Ft = /* @__PURE__ */ n(2, (e, t) => {
+	let n = Object.create(It);
+	return n[b] = e, n[w] = t.length === 1 ? t : (e) => t(e), n;
+}), It = /* @__PURE__ */ j({
+	op: "OnFailure",
+	[T](e) {
+		return e._stack.push(this), this[b];
+	}
+}), Lt = /* @__PURE__ */ n(3, (e, t, n) => Ft(e, (e) => {
+	let r = t(e);
+	return P(r) ? B(r.failure) : p(() => n(r.success, e));
+})), Z = /* @__PURE__ */ n(2, (e, t) => Lt(e, F, (e) => t(e))), Rt = /* @__PURE__ */ n(2, (e, t) => Z(e, (e) => it(() => t(e)))), zt = /* @__PURE__ */ n(2, (e, t) => Ut(e, {
+	onFailure: (e) => it(() => t.onFailure(e)),
+	onSuccess: (e) => H(() => t.onSuccess(e))
+})), Bt = (e) => Wt(e, {
+	onFailure: N,
+	onSuccess: se
+}), Vt = /* @__PURE__ */ n(2, (e, t) => {
+	let n = Object.create(Ht);
+	return n[b] = e, n[S] = t.onSuccess.length === 1 ? t.onSuccess : (e) => t.onSuccess(e), n[w] = t.onFailure.length === 1 ? t.onFailure : (e) => t.onFailure(e), n;
+}), Ht = /* @__PURE__ */ j({
+	op: "OnSuccessAndFailure",
+	[T](e) {
+		return e._stack.push(this), this[b];
+	}
+}), Ut = /* @__PURE__ */ n(2, (e, t) => Vt(e, {
+	onFailure: (e) => {
+		let n = e.reasons.find(ae);
+		return n ? p(() => t.onFailure(n.error)) : B(e);
+	},
+	onSuccess: t.onSuccess
+})), Wt = /* @__PURE__ */ n(2, (e, t) => Ut(e, {
+	onFailure: (e) => H(() => t.onFailure(e)),
+	onSuccess: (e) => H(() => t.onSuccess(e))
+})), Q = (e) => Y(e) ? k(e) : Gt(e), Gt = /* @__PURE__ */ A({
+	op: "Exit",
+	[T](e) {
+		return e._stack.push(this), this[b];
+	},
+	[S](e, t, n) {
+		return z(n ?? k(e));
+	},
+	[w](e, t, n) {
+		return z(n ?? O(e));
+	}
+}), Kt = "~effect/Scope", qt = "~effect/Scope/Closeable", Jt = (e, t) => U(() => Yt(e, t) ?? W), Yt = (e, t) => {
+	if (e.state._tag === "Closed") return;
+	let n = {
+		_tag: "Closed",
+		exit: t
+	};
+	if (e.state._tag === "Empty") {
+		e.state = n;
+		return;
+	}
+	let { finalizers: r } = e.state;
+	if (e.state = n, r.size !== 0) return r.size === 1 ? r.values().next().value(t) : Xt(e, r, t);
+}, Xt = /* @__PURE__ */ lt(function* (e, t, n) {
+	let r = [], i = [], a = Array.from(t.values()), o = Ke();
+	for (let t = a.length - 1; t >= 0; t--) {
+		let s = a[t];
+		e.strategy === "sequential" ? r.push(yield* Q(s(n))) : i.push(mn(o, s(n), !0, !0, "inherit"));
+	}
+	return i.length > 0 && (r = yield* Xe(i)), yield* Dt(r);
+}), Zt = (e, t) => {
+	let n = tn(t);
+	if (e.state._tag === "Closed") return n.state = e.state, n;
+	let r = {};
+	return $t(e, r, (e) => Jt(n, e)), $t(n, r, (t) => H(() => en(e, r))), n;
+}, Qt = (e, t) => U(() => e.state._tag === "Closed" ? t(e.state.exit) : ($t(e, {}, t), W)), $t = (e, t, n) => {
+	e.state._tag === "Empty" ? e.state = {
+		_tag: "Open",
+		finalizers: new Map([[t, n]])
+	} : e.state._tag === "Open" && e.state.finalizers.set(t, n);
+}, en = (e, t) => {
+	e.state._tag === "Open" && e.state.finalizers.delete(t);
+}, tn = (e = "sequential") => ({
+	[qt]: qt,
+	[Kt]: Kt,
+	strategy: e,
+	state: nn
+}), nn = { _tag: "Empty" }, rn = (e) => U(() => {
+	let t = tn();
+	return on(e(t), (e) => U(() => Yt(t, e) ?? W));
+}), an = /* @__PURE__ */ A({
+	op: "OnExit",
+	single: !1,
+	[T](e) {
+		return e._stack.push(this), this[b][0];
+	},
+	[C](e) {
+		e.interruptible && this[b][2] !== !0 && (e._stack.push(sn), e.interruptible = !1);
+	},
+	[S](e, t, n) {
+		n ??= k(e);
+		let r = this[b][1](n);
+		return r ? J(r, (e) => n) : n;
+	},
+	[w](e, t, n) {
+		n ??= O(e);
+		let r = this[b][1](n);
+		return r ? J(r, (e) => n) : n;
+	}
+}), on = /* @__PURE__ */ n(2, an), sn = /* @__PURE__ */ (/* @__PURE__ */ A({
+	op: "SetInterruptible",
+	[C](e) {
+		if (e.interruptible = this[b], e._interruptedCause && e.interruptible) return () => B(e._interruptedCause);
+	}
+}))(!0), cn = /* @__PURE__ */ A({
+	op: "While",
+	[S](e, t) {
+		return this[b].step(e), this[b].while() ? (t._stack.push(this), this[b].body()) : X;
+	},
+	[T](e) {
+		return this[b].while() ? (e._stack.push(this), this[b].body()) : X;
+	}
+}), ln = /* @__PURE__ */ n((e) => typeof e[1] == "function", (e, t, n) => M((r) => {
+	let i = n?.concurrency === "inherit" ? r.getRef(Te) : n?.concurrency ?? 1, a = i === "unbounded" ? Infinity : Math.max(1, i);
+	if (a === 1) return un(e, t, n);
+	let o = ue(e), s = o.length;
+	if (s === 0) return n?.discard ? W : z([]);
+	let c = n?.discard ? void 0 : Array(s), l = pn({
+		f: t,
+		out: c
+	}, o, { concurrency: a });
+	return l ? pt(l, c) : z(c);
+})), un = (e, t, n) => U(() => {
+	let r = n?.discard ? void 0 : [], i = e[Symbol.iterator](), a = i.next(), o = 0;
+	return pt(cn({
+		while: () => !a.done,
+		body: () => t(a.value, o++),
+		step: (e) => {
+			r && r.push(e), a = i.next();
+		}
+	}), r);
+}), dn = (e) => {
+	let t = e.onItem, n = e.step;
+	return (e, r, i) => {
+		let a = i?.start ?? 0, o = i?.end ?? r.length, s = i?.concurrency ?? 1, c = !1, l, u, d, f = !1, p, m, h = () => {
+			let i = !1;
+			for (; !p && a < o; a++) {
+				let o = r[a], g = m ?? t(e, o, a);
+				if (Y(g)) {
+					if (p = n(e, o, g, a), p) break;
+				} else if (s === 1) return J(Q(g), (t) => (p = n(e, o, t, a), a++, p ?? h() ?? W));
+				else if (l) {
+					m = void 0;
+					let t = mn(l, g, !0, !0, "inherit");
+					if (t._exit) {
+						if (p = n(e, o, t._exit, a), p) break;
+						continue;
+					}
+					u ? u.add(t) : u = new Set([t]);
+					let r = a;
+					if (t.addObserver((a) => {
+						if (u.delete(t), p) {
+							if (!f && a._tag === "Failure") for (let e of a.cause.reasons) if (e._tag === "Interrupt") continue;
+							else p._tag === "Failure" ? p.cause.reasons.push(e) : p = O(x([e]));
+						} else {
+							let t = n(e, o, a, r);
+							t && (p = t._tag === "Failure" ? O(x(t.cause.reasons.slice())) : t, h());
+						}
+						if (i) {
+							let e = h();
+							e && d(e);
+						} else c && u.size === 0 && d(p ?? W);
+					}), u.size < s) continue;
+					i = !0, a++;
+					return;
+				} else return K((e) => {
+					l = Ke(), m = g, d = e;
+					let t = h();
+					return t ? e(t) : U(() => (p = X, f = !0, u ? $e(u) : W));
+				});
+			}
+			if (c = !0, p) {
+				if (u && u.size > 0) {
+					let e = R(l);
+					u.forEach((t) => t.interruptUnsafe(l.id, e));
+					return;
+				}
+				if (d || p._tag === "Failure") return p;
+			} else if (d) if (u) u.size === 0 && d(W);
+			else return X;
+		};
+		return h();
+	};
+}, fn = () => dn, pn = /* @__PURE__ */ dn({
+	onItem(e, t, n) {
+		return e.f(t, n);
+	},
+	step(e, t, n, r) {
+		if (n._tag === "Failure") return n;
+		e.out && (e.out[r] = n.value);
+	}
+}), mn = (e, t, n = !1, r = !1, i = !1) => {
+	let a = i === "inherit" ? e.interruptible : !i, o = new qe(e.context, a);
+	return n ? o.evaluate(t) : e.currentDispatcher.scheduleTask(() => o.evaluate(t), 0), !r && !o._exit && (e.children().add(o), o.addObserver(() => e._children.delete(o))), o;
+}, hn = (e) => (t, n) => {
+	let r = new qe(n?.scheduler ? fe(e, xe, n.scheduler) : e, n?.uninterruptible !== !0);
+	if (r.evaluate(t), r._exit) return r;
+	if (n?.signal) if (n.signal.aborted) r.interruptUnsafe();
+	else {
+		let e = () => r.interruptUnsafe();
+		n.signal.addEventListener("abort", e, { once: !0 }), r.addObserver(() => n.signal.removeEventListener("abort", e));
+	}
+	return n?.onFiberStart && n.onFiberStart(r), r;
+}, gn = /* @__PURE__ */ hn(/* @__PURE__ */ pe()), _n = (e) => {
+	let t = hn(e);
+	return (e) => {
+		if (Y(e)) return e;
+		let n = t(e, { scheduler: new ye("sync") });
+		return n.currentDispatcher?.flush(), n._exit ?? E(new wn(n));
+	};
+}, vn = /* @__PURE__ */ _n(/* @__PURE__ */ pe()), yn = /* @__PURE__ */ ((e) => {
+	let t = _n(e);
+	return (e) => {
+		let n = t(e);
+		if (n._tag === "Failure") throw Pe(n.cause);
+		return n.value;
+	};
+})(/* @__PURE__ */ pe()), bn = /* @__PURE__ */ M((e) => {
+	let t = e.currentSpanLocal;
+	return t ? z(t) : V(new ee());
+});
+v("TimeoutError");
+var xn = "~effect/Cause/IllegalArgumentError", Sn = class extends v("IllegalArgumentError") {
+	[xn] = xn;
+	constructor(e) {
+		super({ message: e });
+	}
+};
+v("ExceededCapacityError");
+var Cn = "~effect/Cause/AsyncFiberError", wn = class extends v("AsyncFiberError") {
+	[Cn] = Cn;
+	constructor(e) {
+		super({
+			message: "An asynchronous Effect was executed with Effect.runSync",
+			fiber: e
+		});
+	}
+}, Tn = "~effect/Cause/UnknownError", En = class extends v("UnknownError") {
+	[Tn] = Tn;
+	constructor(e, t) {
+		super({
+			message: t,
+			cause: e
+		});
+	}
+}, $ = {
+	bold: "1",
+	red: "31",
+	green: "32",
+	yellow: "33",
+	blue: "34",
+	cyan: "36",
+	white: "37",
+	gray: "90",
+	black: "30",
+	bgBrightRed: "101"
+};
+$.gray, $.blue, $.green, $.yellow, $.red, $.bgBrightRed, $.black;
+var Dn = typeof process == "object" && process !== null && typeof process.stdout == "object" && process.stdout !== null;
+Dn && process.stdout.isTTY, Dn || "Deno" in globalThis;
+//#endregion
+export { L as FiberTypeId, Sn as IllegalArgumentError, mt as andThen, K as callback, St as catchEager, Z as catch_, He as causePretty, Pe as causeSquash, At as context, bn as currentSpan, Y as effectIsExit, Q as exit, Ot as exitGetSuccess, Ct as exitIsSuccess, X as exitVoid, V as fail, Ze as fiberInterrupt, F as findError, J as flatMap, _t as flatMapEager, lt as fnUntraced, dt as fnUntracedEager, ln as forEach, fn as iterateEager, vt as map, xt as mapBothEager, yt as mapEager, bt as mapErrorEager, Wt as match, on as onExit, Bt as option, ot as promise, Mt as provideContext, Nt as provideService, gn as runFork, yn as runSync, vn as runSyncExit, Qt as scopeAddFinalizerExit, Jt as scopeClose, Zt as scopeForkUnsafe, tn as scopeMakeUnsafe, rn as scopedWith, z as succeed, nt as succeedNone, tt as succeedSome, U as suspend, H as sync, st as tryPromise, at as try_, W as void_ };

package/dist/vue-components38.es.js

@@ -0,0 +1,7 @@
+import { Service as e } from "./vue-components32.es.js";
+import { IllegalArgumentError as t, causePretty as n, causeSquash as r, findError as i } from "./vue-components37.es.js";
+//#region ../../node_modules/.pnpm/effect@4.0.0-beta.62/node_modules/effect/dist/Cause.js
+var a = r, o = i, s = n, c = t;
+e()("effect/Cause/StackTrace"), e()("effect/Cause/InterruptorStackTrace");
+//#endregion
+export { c as IllegalArgumentError, o as findError, s as pretty, a as squash };

package/dist/vue-components39.es.js

@@ -0,0 +1,5 @@
+import "./vue-components12.es.js";
+import { TaggedError as e } from "./vue-components24.es.js";
+var t = e;
+//#endregion
+export { t as TaggedError };