@effect-app/vue-components 4.0.0-beta.2 → 4.0.0-beta.3

package/dist/vue-components.es40.js

@@ -1,66 +1,563 @@
-import { symbol as r, equals as c } from "./vue-components.es76.js";
-import { format as m } from "./vue-components.es60.js";
-import { symbol as n, hash as o, combine as u } from "./vue-components.es77.js";
-import { toJson as l } from "./vue-components.es86.js";
-import { hasProperty as p } from "./vue-components.es38.js";
-import { YieldableProto as _, PipeInspectableProto as f, exitFail as g, NoSuchElementError as b, exitSucceed as O } from "./vue-components.es36.js";
-const s = "~effect/data/Option", a = {
-  [s]: {
-    _A: (t) => t
-  },
-  ...f,
-  ..._
-}, S = /* @__PURE__ */ Object.assign(/* @__PURE__ */ Object.create(a), {
-  _tag: "Some",
-  _op: "Some",
-  [r](t) {
-    return i(t) && P(t) && c(this.value, t.value);
-  },
-  [n]() {
-    return u(o(this._tag))(o(this.value));
-  },
+import { union as ie } from "./vue-components.es36.js";
+import { equals as oe, symbol as ce } from "./vue-components.es64.js";
+import { formatJson as Y } from "./vue-components.es38.js";
+import { dual as u, identity as j, constVoid as ue } from "./vue-components.es39.js";
+import { symbol as ae, combine as le, string as he, random as fe } from "./vue-components.es65.js";
+import { some as w, none as L } from "./vue-components.es23.js";
+import { pipeArguments as de } from "./vue-components.es41.js";
+import { hasProperty as pe } from "./vue-components.es42.js";
+import { currentFiberTypeId as I } from "./vue-components.es69.js";
+import { CurrentLogLevel as me, MinimumLogLevel as ge, CurrentStackFrame as Se } from "./vue-components.es70.js";
+import { isFailure as T, succeed as _e, fail as ye } from "./vue-components.es43.js";
+import { Scheduler as C, MixedScheduler as N, MaxOpsBeforeYield as be } from "./vue-components.es49.js";
+import { add as ke, getReferenceUnsafe as ve, make as Ee, empty as F } from "./vue-components.es71.js";
+import { ParentSpanKey as Fe, TracerKey as xe } from "./vue-components.es72.js";
+import { internalCall as g } from "./vue-components.es67.js";
+import { withFiber as Ie, makePrimitive as h, exitSucceed as S, exitFail as D, NoSuchElementError as Ce, args as c, contA as d, makePrimitiveProto as O, exitDie as k, evaluate as a, Yield as f, ExitTypeId as B, isFailReason as $e, exitFailCause as K, contE as x, contAll as v, CauseImpl as V, causeAnnotate as U, StackTraceKey as q, isInterruptReason as z, InterruptorStackTrace as we, ReasonBase as Le, constEmptyAnnotations as Te } from "./vue-components.es52.js";
+import { FiberRuntimeMetricsKey as Oe } from "./vue-components.es73.js";
+import { version as Pe } from "./vue-components.es74.js";
+class Ae extends Le {
+  fiberId;
+  constructor(t, r = Te) {
+    super("Interrupt", r, "Interrupted"), this.fiberId = t;
+  }
   toString() {
-    return `some(${m(this.value)})`;
-  },
+    return `Interrupt(${this.fiberId})`;
+  }
   toJSON() {
     return {
-      _id: "Option",
-      _tag: this._tag,
-      value: l(this.value)
+      _tag: "Interrupt",
+      fiberId: this.fiberId
     };
+  }
+  [ce](t) {
+    return z(t) && this.fiberId === t.fiberId && this.annotations === t.annotations;
+  }
+  [ae]() {
+    return le(he(`${this._tag}:${this.fiberId}`))(fe(this.annotations));
+  }
+}
+const je = (e) => new V([new Ae(e)]), P = (e) => {
+  for (let t = 0; t < e.reasons.length; t++) {
+    const r = e.reasons[t];
+    if (r._tag === "Fail")
+      return _e(r.error);
+  }
+  return ye(e);
+}, Ue = (e) => e.reasons.some(z), Me = /* @__PURE__ */ u(2, (e, t) => {
+  if (e.reasons.length === 0)
+    return t;
+  if (t.reasons.length === 0)
+    return e;
+  const r = new V(ie(e.reasons, t.reasons));
+  return oe(e, r) ? e : r;
+}), Re = (e) => {
+  const t = {
+    Fail: [],
+    Die: [],
+    Interrupt: []
+  };
+  for (let r = 0; r < e.reasons.length; r++)
+    t[e.reasons[r]._tag].push(e.reasons[r]);
+  return t;
+}, G = (e) => {
+  const t = Re(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");
+}, We = (e) => {
+  const t = [], r = [];
+  if (e.reasons.length === 0) return t;
+  const n = Error.stackTraceLimit;
+  Error.stackTraceLimit = 1;
+  for (const s of e.reasons) {
+    if (s._tag === "Interrupt") {
+      r.push(s);
+      continue;
+    }
+    t.push($(s._tag === "Die" ? s.defect : s.error, s.annotations));
+  }
+  if (t.length === 0) {
+    const s = new Error("The fiber was interrupted by:");
+    s.name = "InterruptCause", s.stack = Be(s, r);
+    const i = new globalThis.Error("All fibers interrupted without error", {
+      cause: s
+    });
+    i.name = "InterruptError", i.stack = `${i.name}: ${i.message}`, t.push($(i, r[0].annotations));
+  }
+  return Error.stackTraceLimit = n, t;
+}, $ = (e, t) => {
+  const r = typeof e;
+  let n;
+  if (e && r === "object") {
+    if (n = new globalThis.Error(Ye(e), {
+      cause: e.cause ? $(e.cause) : void 0
+    }), typeof e.name == "string" && (n.name = e.name), typeof e.stack == "string")
+      n.stack = De(e.stack, n, t);
+    else {
+      const s = `${n.name}: ${n.message}`;
+      n.stack = t ? J(s, t) : s;
+    }
+    for (const s of Object.keys(e))
+      s in n || (n[s] = e[s]);
+  } else
+    n = new globalThis.Error(e ? r === "string" ? e : Y(e) : `Unknown error: ${e}`);
+  return n;
+}, Ye = (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 Y(e);
+}, Ne = /\((.*)\)/g, De = (e, t, r) => {
+  const n = `${t.name}: ${t.message}`, s = (e.startsWith(n) ? e.slice(n.length) : e).split(`
+`), i = [n];
+  for (let o = 1; o < s.length && !/(?:Generator\.next|~effect\/Effect)/.test(s[o]); o++)
+    i.push(s[o]);
+  return r ? J(i.join(`
+`), r) : i.join(`
+`);
+}, J = (e, t) => {
+  const r = t?.get(q.key);
+  return r && (e = `${e}
+${H(r)}`), e;
+}, Be = (e, t) => {
+  const r = [`${e.name}: ${e.message}`];
+  for (const n of t) {
+    const s = n.fiberId !== void 0 ? `#${n.fiberId}` : "unknown", i = n.annotations.get(we.key);
+    r.push(`    at fiber (${s})`), i && r.push(H(i));
+  }
+  return r.join(`
+`);
+}, H = (e) => {
+  const t = [];
+  let r = e, n = 0;
+  for (; r && n < 10; ) {
+    const s = r.stack();
+    if (s) {
+      const i = s.matchAll(Ne);
+      let o = !1;
+      for (const [, b] of i)
+        o = !0, t.push(`    at ${r.name} (${b})`);
+      o || t.push(`    at ${r.name} (${s.replace(/^at /, "")})`);
+    } else
+      t.push(`    at ${r.name}`);
+    r = r.parent, n++;
+  }
+  return t.join(`
+`);
+}, Ut = (e) => We(e).map((t) => t.cause ? `${t.stack} {
+${Q(t.cause, "  ")}
+}` : t.stack).join(`
+`), Q = (e, t) => {
+  const r = e.stack.split(`
+`);
+  let n = `${t}[cause]: ${r[0]}`;
+  for (let s = 1, i = r.length; s < i; s++)
+    n += `
+${t}${r[s]}`;
+  return e.cause && (n += ` {
+${Q(e.cause, `${t}  `)}
+${t}}`), n;
+}, M = `~effect/Fiber/${Pe}`, Ke = {
+  _A: j,
+  _E: j
+}, Ve = {
+  id: 0
+};
+class qe {
+  constructor(t, r = !0) {
+    this[M] = Ke, this.setServices(t), this.id = ++Ve.id, this.currentOpCount = 0, this.currentLoopCount = 0, this.interruptible = r, this._stack = [], this._observers = [], this._exit = void 0, this._children = void 0, this._interruptedCause = void 0, this._yielded = void 0;
+  }
+  [M];
+  id;
+  interruptible;
+  currentOpCount;
+  currentLoopCount;
+  _stack;
+  _observers;
+  _exit;
+  _currentExit;
+  _children;
+  _interruptedCause;
+  _yielded;
+  // set in setServices
+  services;
+  currentScheduler;
+  currentTracerContext;
+  currentSpan;
+  currentLogLevel;
+  minimumLogLevel;
+  currentStackFrame;
+  runtimeMetrics;
+  maxOpsBeforeYield;
+  getRef(t) {
+    return ve(this.services, t);
+  }
+  addObserver(t) {
+    return this._exit ? (t(this._exit), ue) : (this._observers.push(t), () => {
+      const r = this._observers.indexOf(t);
+      r >= 0 && this._observers.splice(r, 1);
+    });
+  }
+  interruptUnsafe(t, r) {
+    if (this._exit)
+      return;
+    let n = je(t);
+    this.currentStackFrame && (n = U(n, Ee(q, this.currentStackFrame))), r && (n = U(n, r)), this._interruptedCause = this._interruptedCause ? Me(this._interruptedCause, n) : n, this.interruptible && this.evaluate(m(this._interruptedCause));
+  }
+  pollUnsafe() {
+    return this._exit;
+  }
+  evaluate(t) {
+    if (this.runtimeMetrics?.recordFiberStart(this.services), this._exit)
+      return;
+    if (this._yielded !== void 0) {
+      const n = this._yielded;
+      this._yielded = void 0, n();
+    }
+    const r = this.runLoop(t);
+    if (r !== f) {
+      this._exit = r, this.runtimeMetrics?.recordFiberEnd(this.services, this._exit);
+      for (let n = 0; n < this._observers.length; n++)
+        this._observers[n](r);
+      this._observers.length = 0;
+    }
+  }
+  runLoop(t) {
+    const r = globalThis[I];
+    globalThis[I] = this;
+    let n = !1, s = t;
+    this.currentOpCount = 0;
+    const i = ++this.currentLoopCount;
+    try {
+      for (; ; ) {
+        if (this.currentOpCount++, !n && this.currentScheduler.shouldYield(this)) {
+          n = !0;
+          const o = s;
+          s = y(Ge, () => o);
+        }
+        if (s = this.currentTracerContext ? this.currentTracerContext(s, this) : s[a](this), i !== this.currentLoopCount)
+          return f;
+        if (s === f) {
+          const o = this._yielded;
+          return B in o ? (this._yielded = void 0, o) : f;
+        }
+      }
+    } catch (o) {
+      return pe(s, a) ? this.runLoop(k(o)) : k(`Fiber.runLoop: Not a valid effect: ${String(s)}`);
+    } finally {
+      globalThis[I] = r;
+    }
+  }
+  getCont(t) {
+    for (; ; ) {
+      const r = this._stack.pop();
+      if (!r) return;
+      const n = r[v] && r[v](this);
+      if (n)
+        return n[t] = n, n;
+      if (r[t]) return r;
+    }
+  }
+  yieldWith(t) {
+    return this._yielded = t, f;
+  }
+  children() {
+    return this._children ??= /* @__PURE__ */ new Set();
+  }
+  pipe() {
+    return de(this, arguments);
+  }
+  setServices(t) {
+    this.services = t, this.currentScheduler = this.getRef(C), this.currentSpan = t.mapUnsafe.get(Fe), this.currentLogLevel = this.getRef(me), this.minimumLogLevel = this.getRef(ge), this.currentStackFrame = t.mapUnsafe.get(Se.key), this.maxOpsBeforeYield = this.getRef(be), this.runtimeMetrics = t.mapUnsafe.get(Oe);
+    const r = t.mapUnsafe.get(xe);
+    this.currentTracerContext = r ? r.context : void 0;
+  }
+  get currentSpanLocal() {
+    return this.currentSpan?._tag === "Span" ? this.currentSpan : void 0;
+  }
+}
+const l = S, m = K, X = D, R = /* @__PURE__ */ h({
+  op: "Sync",
+  [a](e) {
+    const t = this[c](), r = e.getCont(d);
+    return r ? r[d](t, e) : e.yieldWith(S(t));
+  }
+}), _ = /* @__PURE__ */ h({
+  op: "Suspend",
+  [a](e) {
+    return this[c]();
+  }
+}), ze = /* @__PURE__ */ h({
+  op: "Yield",
+  [a](e) {
+    let t = !1;
+    return e.currentScheduler.scheduleTask(() => {
+      t || e.evaluate(te);
+    }, this[c] ?? 0), e.yieldWith(() => {
+      t = !0;
+    });
+  }
+}), Ge = /* @__PURE__ */ ze(0), Mt = (e) => l(w(e)), Rt = /* @__PURE__ */ l(/* @__PURE__ */ L()), Z = (e) => k(e), Je = (e) => _(() => X(g(e))), Wt = (e) => He(function(t, r) {
+  g(() => e(r)).then((n) => t(l(n)), (n) => t(Z(n)));
+}, e.length !== 0), He = /* @__PURE__ */ h({
+  op: "Async",
+  single: !1,
+  [a](e) {
+    const t = g(() => this[c][0].bind(e.currentScheduler));
+    let r = !1, n = !1;
+    const s = this[c][1] ? new AbortController() : void 0, i = t((o) => {
+      r || (r = !0, n ? e.evaluate(o) : n = o);
+    }, s?.signal);
+    return n !== !1 ? n : (n = !0, e._yielded = () => {
+      r = !0;
+    }, s === void 0 && i === void 0 ? f : (e._stack.push(Qe(() => (r = !0, s?.abort(), i ?? te))), f));
+  }
+}), Qe = /* @__PURE__ */ h({
+  op: "AsyncFinalizer",
+  [v](e) {
+    e.interruptible && (e.interruptible = !1, e._stack.push(dt));
   },
-  asEffect() {
-    return O(this.value);
-  }
-}), h = /* @__PURE__ */ o("None"), N = /* @__PURE__ */ Object.assign(/* @__PURE__ */ Object.create(a), {
-  _tag: "None",
-  _op: "None",
-  [r](t) {
-    return i(t) && v(t);
+  [x](e, t) {
+    return Ue(e) ? y(this[c](), () => m(e)) : m(e);
+  }
+}), Yt = (e, ...t) => {
+  const r = t.length === 0 ? function() {
+    return _(() => E(e.apply(this, arguments)));
+  } : function() {
+    let n = _(() => E(e.apply(this, arguments)));
+    for (let s = 0; s < t.length; s++)
+      n = t[s](n, ...arguments);
+    return n;
+  };
+  return ee(e.length, r);
+}, ee = (e, t) => Object.defineProperty(t, "length", {
+  value: e,
+  configurable: !0
+}), Nt = (e, ...t) => ee(e.length, t.length === 0 ? function() {
+  return W(() => e.apply(this, arguments));
+} : function() {
+  let r = W(() => e.apply(this, arguments));
+  for (const n of t)
+    r = n(r);
+  return r;
+}), W = (e) => {
+  try {
+    const t = e();
+    let r;
+    for (; ; ) {
+      const n = t.next(r);
+      if (n.done)
+        return l(n.value);
+      const i = n.value.asEffect(), o = i;
+      if (o && o._tag === "Success") {
+        r = o.value;
+        continue;
+      } else {
+        if (o && o._tag === "Failure")
+          return i;
+        {
+          let b = !0;
+          return _(() => b ? (b = !1, y(i, (se) => E(t, se))) : _(() => E(e())));
+        }
+      }
+    }
+  } catch (t) {
+    return Z(t);
+  }
+}, E = /* @__PURE__ */ h({
+  op: "Iterator",
+  single: !1,
+  [d](e, t) {
+    const r = this[c][0];
+    for (; ; ) {
+      const n = r.next(e);
+      if (n.done) return l(n.value);
+      const s = n.value.asEffect();
+      if (p(s)) {
+        if (s._tag === "Failure")
+          return s;
+      } else return t._stack.push(this), s;
+      e = s.value;
+    }
   },
-  [n]() {
-    return h;
+  [a](e) {
+    return this[d](this[c][1], e);
+  }
+}), y = /* @__PURE__ */ u(2, (e, t) => {
+  const r = Object.create(Xe);
+  return r[c] = e, r[d] = t.length !== 1 ? (n) => t(n) : t, r;
+}), Xe = /* @__PURE__ */ O({
+  op: "OnSuccess",
+  [a](e) {
+    return e._stack.push(this), this[c];
+  }
+}), p = (e) => B in e, Dt = /* @__PURE__ */ u(2, (e, t) => p(e) ? e._tag === "Success" ? t(e.value) : e : y(e, t)), Ze = /* @__PURE__ */ u(2, (e, t) => y(e, (r) => l(g(() => t(r))))), Bt = /* @__PURE__ */ u(2, (e, t) => p(e) ? tt(e, t) : Ze(e, t)), Kt = /* @__PURE__ */ u(2, (e, t) => p(e) ? rt(e, t) : ot(e, t)), Vt = /* @__PURE__ */ u(2, (e, t) => {
+  if (p(e)) {
+    if (e._tag === "Success") return e;
+    const r = P(e.cause);
+    return T(r) ? e : t(r.success);
+  }
+  return re(e, t);
+}), et = (e) => e._tag === "Success", te = /* @__PURE__ */ S(void 0), tt = /* @__PURE__ */ u(2, (e, t) => e._tag === "Success" ? S(t(e.value)) : e), rt = /* @__PURE__ */ u(2, (e, t) => {
+  if (e._tag === "Success") return e;
+  const r = P(e.cause);
+  return T(r) ? e : D(t(r.success));
+}), qt = (e) => et(e) ? w(e.value) : L(), nt = /* @__PURE__ */ u(2, (e, t) => {
+  const r = Object.create(st);
+  return r[c] = e, r[x] = t.length !== 1 ? (n) => t(n) : t, r;
+}), st = /* @__PURE__ */ O({
+  op: "OnFailure",
+  [a](e) {
+    return e._stack.push(this), this[c];
+  }
+}), it = /* @__PURE__ */ u(3, (e, t, r) => nt(e, (n) => {
+  const s = t(n);
+  return T(s) ? m(s.failure) : g(() => r(s.success, n));
+})), re = /* @__PURE__ */ u(2, (e, t) => it(e, P, (r) => t(r))), ot = /* @__PURE__ */ u(2, (e, t) => re(e, (r) => Je(() => t(r)))), zt = (e) => lt(e, {
+  onFailure: L,
+  onSuccess: w
+}), ct = /* @__PURE__ */ u(2, (e, t) => {
+  const r = Object.create(ut);
+  return r[c] = e, r[d] = t.onSuccess.length !== 1 ? (n) => t.onSuccess(n) : t.onSuccess, r[x] = t.onFailure.length !== 1 ? (n) => t.onFailure(n) : t.onFailure, r;
+}), ut = /* @__PURE__ */ O({
+  op: "OnSuccessAndFailure",
+  [a](e) {
+    return e._stack.push(this), this[c];
+  }
+}), at = /* @__PURE__ */ u(2, (e, t) => ct(e, {
+  onFailure: (r) => {
+    const n = r.reasons.find($e);
+    return n ? g(() => t.onFailure(n.error)) : m(r);
   },
-  toString() {
-    return "none()";
+  onSuccess: t.onSuccess
+})), lt = /* @__PURE__ */ u(2, (e, t) => at(e, {
+  onFailure: (r) => R(() => t.onFailure(r)),
+  onSuccess: (r) => R(() => t.onSuccess(r))
+})), Gt = (e) => p(e) ? S(e) : ht(e), ht = /* @__PURE__ */ h({
+  op: "Exit",
+  [a](e) {
+    return e._stack.push(this), this[c];
   },
-  toJSON() {
-    return {
-      _id: "Option",
-      _tag: this._tag
-    };
+  [d](e, t, r) {
+    return l(r ?? S(e));
   },
-  asEffect() {
-    return g(new b());
+  [x](e, t, r) {
+    return l(r ?? K(e));
   }
-}), i = (t) => p(t, s), v = (t) => t._tag === "None", P = (t) => t._tag === "Some", I = /* @__PURE__ */ Object.create(N), $ = (t) => {
-  const e = Object.create(S);
-  return e.value = t, e;
-};
+}), ft = /* @__PURE__ */ h({
+  op: "SetInterruptible",
+  [v](e) {
+    if (e.interruptible = this[c], e._interruptedCause && e.interruptible)
+      return () => m(e._interruptedCause);
+  }
+}), dt = /* @__PURE__ */ ft(!0), A = (e) => (t, r) => {
+  const n = r?.scheduler || !e.mapUnsafe.has(C.key) && new N(), s = new qe(n ? ke(e, C, n) : e, r?.uninterruptible !== !0);
+  if (s.evaluate(t), s._exit) return s;
+  if (r?.signal)
+    if (r.signal.aborted)
+      s.interruptUnsafe();
+    else {
+      const i = () => s.interruptUnsafe();
+      r.signal.addEventListener("abort", i, {
+        once: !0
+      }), s.addObserver(() => r.signal.removeEventListener("abort", i));
+    }
+  return s;
+}, Jt = /* @__PURE__ */ A(/* @__PURE__ */ F()), pt = (e) => {
+  const t = A(e);
+  return (r, n) => {
+    const s = t(r, n);
+    return new Promise((i) => {
+      s.addObserver((o) => i(o));
+    });
+  };
+}, mt = (e) => {
+  const t = pt(e);
+  return (r, n) => t(r, n).then((s) => {
+    if (s._tag === "Failure")
+      throw G(s.cause);
+    return s.value;
+  });
+}, Ht = /* @__PURE__ */ mt(/* @__PURE__ */ F()), ne = (e) => {
+  const t = A(e);
+  return (r) => {
+    if (p(r)) return r;
+    const n = new N("sync"), s = t(r, {
+      scheduler: n
+    });
+    return n.flush(), s._exit ?? k(s);
+  };
+}, Qt = /* @__PURE__ */ ne(/* @__PURE__ */ F()), gt = (e) => {
+  const t = ne(e);
+  return (r) => {
+    const n = t(r);
+    if (n._tag === "Failure") throw G(n.cause);
+    return n.value;
+  };
+}, Xt = /* @__PURE__ */ gt(/* @__PURE__ */ F()), Zt = /* @__PURE__ */ Ie((e) => {
+  const t = e.currentSpanLocal;
+  return t ? l(t) : X(new Ce());
+}), St = typeof process == "object" && process !== null && typeof process.stdout == "object" && process.stdout !== null;
+St && process.stdout.isTTY;
 export {
-  v as isNone,
-  i as isOption,
-  P as isSome,
-  I as none,
-  $ as some
+  qe as FiberImpl,
+  M as FiberTypeId,
+  Ae as Interrupt,
+  nt as catchCause,
+  it as catchCauseFilter,
+  Vt as catchEager,
+  re as catch_,
+  Me as causeCombine,
+  je as causeInterrupt,
+  Re as causePartition,
+  Ut as causePretty,
+  $ as causePrettyError,
+  We as causePrettyErrors,
+  G as causeSquash,
+  Zt as currentSpan,
+  Z as die,
+  p as effectIsExit,
+  Gt as exit,
+  qt as exitGetSuccess,
+  et as exitIsSuccess,
+  tt as exitMap,
+  rt as exitMapError,
+  te as exitVoid,
+  X as fail,
+  m as failCause,
+  Je as failSync,
+  P as findError,
+  y as flatMap,
+  Dt as flatMapEager,
+  Yt as fnUntraced,
+  Nt as fnUntracedEager,
+  Ue as hasInterrupts,
+  Ze as map,
+  Bt as mapEager,
+  ot as mapError,
+  Kt as mapErrorEager,
+  lt as match,
+  ct as matchCauseEffect,
+  at as matchEffect,
+  zt as option,
+  Wt as promise,
+  Jt as runFork,
+  A as runForkWith,
+  Ht as runPromise,
+  pt as runPromiseExitWith,
+  mt as runPromiseWith,
+  Xt as runSync,
+  Qt as runSyncExit,
+  ne as runSyncExitWith,
+  gt as runSyncWith,
+  l as succeed,
+  Rt as succeedNone,
+  Mt as succeedSome,
+  _ as suspend,
+  R as sync,
+  Ge as yieldNow,
+  ze as yieldNowWith
 };

package/dist/vue-components.es41.js

@@ -1,6 +1,43 @@
-import { causePretty as r, findError as o } from "./vue-components.es37.js";
-const n = o, e = r;
+const o = (e, t) => {
+  switch (t.length) {
+    case 0:
+      return e;
+    case 1:
+      return t[0](e);
+    case 2:
+      return t[1](t[0](e));
+    case 3:
+      return t[2](t[1](t[0](e)));
+    case 4:
+      return t[3](t[2](t[1](t[0](e))));
+    case 5:
+      return t[4](t[3](t[2](t[1](t[0](e)))));
+    case 6:
+      return t[5](t[4](t[3](t[2](t[1](t[0](e))))));
+    case 7:
+      return t[6](t[5](t[4](t[3](t[2](t[1](t[0](e)))))));
+    case 8:
+      return t[7](t[6](t[5](t[4](t[3](t[2](t[1](t[0](e))))))));
+    case 9:
+      return t[8](t[7](t[6](t[5](t[4](t[3](t[2](t[1](t[0](e)))))))));
+    default: {
+      let n = e;
+      for (let u = 0, c = t.length; u < c; u++)
+        n = t[u](n);
+      return n;
+    }
+  }
+}, p = {
+  pipe() {
+    return o(this, arguments);
+  }
+}, i = /* @__PURE__ */ (function() {
+  function e() {
+  }
+  return e.prototype = p, e;
+})();
 export {
-  n as findError,
-  e as pretty
+  i as Class,
+  p as Prototype,
+  o as pipeArguments
 };

package/dist/vue-components.es42.js

@@ -1,6 +1,29 @@
-import { exitGetSuccess as s, exitIsSuccess as c } from "./vue-components.es37.js";
-const t = c, o = s;
+import { dual as o } from "./vue-components.es39.js";
+function i(n) {
+  return typeof n == "string";
+}
+function f(n) {
+  return typeof n == "number";
+}
+function c(n) {
+  return typeof n == "boolean";
+}
+function r(n) {
+  return typeof n == "function";
+}
+function s(n) {
+  return !0;
+}
+function e(n) {
+  return typeof n == "object" && n !== null || r(n);
+}
+const y = /* @__PURE__ */ o(2, (n, t) => e(n) && t in n);
 export {
-  o as getSuccess,
-  t as isSuccess
+  y as hasProperty,
+  c as isBoolean,
+  r as isFunction,
+  f as isNumber,
+  e as isObjectKeyword,
+  i as isString,
+  s as isUnknown
 };