@camstack/addon-pipeline-analytics 0.1.1

package/dist/index-xncRG7-x.mjs

@@ -0,0 +1,2713 @@
+import { i as M, _ as w, r as oe, a as ze, b as I, e as pt, c as W, s as we, d as mt, f as ht, g as We, h as xe, T as yt, j as vt } from "./getErrorShape-BPSzUA7W-TlK8ipWe.mjs";
+var bt = Object.create, Ge = Object.defineProperty, gt = Object.getOwnPropertyDescriptor, Be = Object.getOwnPropertyNames, wt = Object.getPrototypeOf, xt = Object.prototype.hasOwnProperty, T = (e, t) => function() {
+  return t || (0, e[Be(e)[0]])((t = { exports: {} }).exports, t), t.exports;
+}, St = (e, t, r, n) => {
+  if (t && typeof t == "object" || typeof t == "function") for (var o = Be(t), i = 0, c = o.length, a; i < c; i++)
+    a = o[i], !xt.call(e, a) && a !== r && Ge(e, a, {
+      get: ((s) => t[s]).bind(null, a),
+      enumerable: !(n = gt(t, a)) || n.enumerable
+    });
+  return e;
+}, S = (e, t, r) => (r = e != null ? bt(wt(e)) : {}, St(Ge(r, "default", {
+  value: e,
+  enumerable: !0
+}), e)), Fe = T({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/typeof.js"(e, t) {
+  function r(n) {
+    "@babel/helpers - typeof";
+    return t.exports = r = typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? function(o) {
+      return typeof o;
+    } : function(o) {
+      return o && typeof Symbol == "function" && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
+    }, t.exports.__esModule = !0, t.exports.default = t.exports, r(n);
+  }
+  t.exports = r, t.exports.__esModule = !0, t.exports.default = t.exports;
+} }), _t = T({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/toPrimitive.js"(e, t) {
+  var r = Fe().default;
+  function n(o, i) {
+    if (r(o) != "object" || !o) return o;
+    var c = o[Symbol.toPrimitive];
+    if (c !== void 0) {
+      var a = c.call(o, i || "default");
+      if (r(a) != "object") return a;
+      throw new TypeError("@@toPrimitive must return a primitive value.");
+    }
+    return (i === "string" ? String : Number)(o);
+  }
+  t.exports = n, t.exports.__esModule = !0, t.exports.default = t.exports;
+} }), Pt = T({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/toPropertyKey.js"(e, t) {
+  var r = Fe().default, n = _t();
+  function o(i) {
+    var c = n(i, "string");
+    return r(c) == "symbol" ? c : c + "";
+  }
+  t.exports = o, t.exports.__esModule = !0, t.exports.default = t.exports;
+} }), D = T({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/defineProperty.js"(e, t) {
+  var r = Pt();
+  function n(o, i, c) {
+    return (i = r(i)) in o ? Object.defineProperty(o, i, {
+      value: c,
+      enumerable: !0,
+      configurable: !0,
+      writable: !0
+    }) : o[i] = c, o;
+  }
+  t.exports = n, t.exports.__esModule = !0, t.exports.default = t.exports;
+} }), k = T({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/objectSpread2.js"(e, t) {
+  var r = D();
+  function n(i, c) {
+    var a = Object.keys(i);
+    if (Object.getOwnPropertySymbols) {
+      var s = Object.getOwnPropertySymbols(i);
+      c && (s = s.filter(function(u) {
+        return Object.getOwnPropertyDescriptor(i, u).enumerable;
+      })), a.push.apply(a, s);
+    }
+    return a;
+  }
+  function o(i) {
+    for (var c = 1; c < arguments.length; c++) {
+      var a = arguments[c] != null ? arguments[c] : {};
+      c % 2 ? n(Object(a), !0).forEach(function(s) {
+        r(i, s, a[s]);
+      }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(i, Object.getOwnPropertyDescriptors(a)) : n(Object(a)).forEach(function(s) {
+        Object.defineProperty(i, s, Object.getOwnPropertyDescriptor(a, s));
+      });
+    }
+    return i;
+  }
+  t.exports = o, t.exports.__esModule = !0, t.exports.default = t.exports;
+} });
+function E(e) {
+  const t = {
+    subscribe(r) {
+      let n = null, o = !1, i = !1, c = !1;
+      function a() {
+        if (n === null) {
+          c = !0;
+          return;
+        }
+        i || (i = !0, typeof n == "function" ? n() : n && n.unsubscribe());
+      }
+      return n = e({
+        next(s) {
+          var u;
+          o || (u = r.next) === null || u === void 0 || u.call(r, s);
+        },
+        error(s) {
+          var u;
+          o || (o = !0, (u = r.error) === null || u === void 0 || u.call(r, s), a());
+        },
+        complete() {
+          var s;
+          o || (o = !0, (s = r.complete) === null || s === void 0 || s.call(r), a());
+        }
+      }), c && a(), { unsubscribe: a };
+    },
+    pipe(...r) {
+      return r.reduce(Et, t);
+    }
+  };
+  return t;
+}
+function Et(e, t) {
+  return t(e);
+}
+function jt(e) {
+  const t = new AbortController();
+  return new Promise((n, o) => {
+    let i = !1;
+    function c() {
+      i || (i = !0, a.unsubscribe());
+    }
+    t.signal.addEventListener("abort", () => {
+      o(t.signal.reason);
+    });
+    const a = e.subscribe({
+      next(s) {
+        i = !0, n(s), c();
+      },
+      error(s) {
+        o(s);
+      },
+      complete() {
+        t.abort(), c();
+      }
+    });
+  });
+}
+function Ot(e) {
+  return (t) => {
+    let r = 0, n = null;
+    const o = [];
+    function i() {
+      n || (n = t.subscribe({
+        next(a) {
+          for (const u of o) {
+            var s;
+            (s = u.next) === null || s === void 0 || s.call(u, a);
+          }
+        },
+        error(a) {
+          for (const u of o) {
+            var s;
+            (s = u.error) === null || s === void 0 || s.call(u, a);
+          }
+        },
+        complete() {
+          for (const s of o) {
+            var a;
+            (a = s.complete) === null || a === void 0 || a.call(s);
+          }
+        }
+      }));
+    }
+    function c() {
+      if (r === 0 && n) {
+        const a = n;
+        n = null, a.unsubscribe();
+      }
+    }
+    return E((a) => (r++, o.push(a), i(), { unsubscribe() {
+      r--, c();
+      const s = o.findIndex((u) => u === a);
+      s > -1 && o.splice(s, 1);
+    } }));
+  };
+}
+function kt(e) {
+  return (t) => E((r) => t.subscribe({
+    next(n) {
+      var o;
+      (o = e.next) === null || o === void 0 || o.call(e, n), r.next(n);
+    },
+    error(n) {
+      var o;
+      (o = e.error) === null || o === void 0 || o.call(e, n), r.error(n);
+    },
+    complete() {
+      var n;
+      (n = e.complete) === null || n === void 0 || n.call(e), r.complete();
+    }
+  }));
+}
+function se(e) {
+  let t = e;
+  const r = [], n = (c) => {
+    t !== void 0 && c.next(t), r.push(c);
+  }, o = (c) => {
+    r.splice(r.indexOf(c), 1);
+  }, i = E((c) => (n(c), () => {
+    o(c);
+  }));
+  return i.next = (c) => {
+    if (t !== c) {
+      t = c;
+      for (const a of r) a.next(c);
+    }
+  }, i.get = () => t, i;
+}
+function He(e) {
+  return E((t) => {
+    function r(o = 0, i = e.op) {
+      const c = e.links[o];
+      if (!c) throw new Error("No more links to execute - did you forget to add an ending link?");
+      return c({
+        op: i,
+        next(s) {
+          return r(o + 1, s);
+        }
+      });
+    }
+    return r().subscribe(t);
+  });
+}
+function Se(e) {
+  return Array.isArray(e) ? e : [e];
+}
+function Xr(e) {
+  return (t) => {
+    const r = Se(e.true).map((o) => o(t)), n = Se(e.false).map((o) => o(t));
+    return (o) => E((i) => {
+      const c = e.condition(o.op) ? r : n;
+      return He({
+        op: o.op,
+        links: c
+      }).subscribe(i);
+    });
+  };
+}
+var _e = w(ze()), Rt = class extends Error {
+  constructor(e) {
+    super(Tt(e)), Object.assign(this, e);
+  }
+};
+function Tt(e) {
+  if ("message" in e) return String(e.message);
+}
+function qt(e) {
+  if (e instanceof Error) return e;
+  const t = typeof e;
+  if (!(t === "undefined" || t === "function" || e === null)) {
+    if (t !== "object") return new Error(String(e));
+    if (M(e)) return new Rt(e);
+  }
+}
+function ae(e) {
+  if (e instanceof te || e instanceof Error && e.name === "TRPCError") return e;
+  const t = new te({
+    code: "INTERNAL_SERVER_ERROR",
+    cause: e
+  });
+  return e instanceof Error && e.stack && (t.stack = e.stack), t;
+}
+var te = class extends Error {
+  constructor(e) {
+    var t, r, n;
+    const o = qt(e.cause), i = (t = (r = e.message) !== null && r !== void 0 ? r : o?.message) !== null && t !== void 0 ? t : e.code;
+    super(i, { cause: o }), (0, _e.default)(this, "cause", void 0), (0, _e.default)(this, "code", void 0), this.code = e.code, this.name = "TRPCError", (n = this.cause) !== null && n !== void 0 || (this.cause = o);
+  }
+}, K = w(oe());
+function At(e, t) {
+  if ("error" in e) {
+    const n = t.deserialize(e.error);
+    return {
+      ok: !1,
+      error: (0, K.default)((0, K.default)({}, e), {}, { error: n })
+    };
+  }
+  return {
+    ok: !0,
+    result: (0, K.default)((0, K.default)({}, e.result), (!e.result.type || e.result.type === "data") && {
+      type: "data",
+      data: t.deserialize(e.result.data)
+    })
+  };
+}
+var ce = class extends Error {
+  constructor() {
+    super("Unable to transform response from server");
+  }
+};
+function he(e, t) {
+  let r;
+  try {
+    r = At(e, t);
+  } catch {
+    throw new ce();
+  }
+  if (!r.ok && (!M(r.error.error) || typeof r.error.error.code != "number")) throw new ce();
+  if (r.ok && !M(r.result)) throw new ce();
+  return r;
+}
+w(oe());
+function Ct(e) {
+  return typeof e == "function";
+}
+async function Mt(e, t) {
+  const { _def: r } = e;
+  let n = r.procedures[t];
+  for (; !n; ) {
+    const o = Object.keys(r.lazy).find((c) => t.startsWith(c));
+    if (!o) return null;
+    await r.lazy[o].load(), n = r.procedures[t];
+  }
+  return n;
+}
+async function It(e) {
+  const { type: t, path: r } = e, n = await Mt(e.router, r);
+  if (!n || !Ct(n) || n._def.type !== t && !e.allowMethodOverride) throw new te({
+    code: "NOT_FOUND",
+    message: `No "${t}"-procedure on path "${r}"`
+  });
+  /* istanbul ignore if -- @preserve */
+  if (n._def.type !== t && e.allowMethodOverride && n._def.type === "subscription") throw new te({
+    code: "METHOD_NOT_SUPPORTED",
+    message: "Method override is not supported for subscriptions"
+  });
+  return n(e);
+}
+const Lt = Symbol();
+function Dt(e) {
+  return Array.isArray(e) && e[2] === Lt;
+}
+w(oe());
+function Pe(e) {
+  return M(e) && e.name === "AbortError";
+}
+var V = w(ze());
+let Je;
+const ue = /* @__PURE__ */ new WeakMap(), Nt = () => {
+};
+Je = Symbol.toStringTag;
+var Ye = class C {
+  constructor(t) {
+    (0, V.default)(this, "promise", void 0), (0, V.default)(this, "subscribers", []), (0, V.default)(this, "settlement", null), (0, V.default)(this, Je, "Unpromise"), typeof t == "function" ? this.promise = new Promise(t) : this.promise = t;
+    const r = this.promise.then((n) => {
+      const { subscribers: o } = this;
+      this.subscribers = null, this.settlement = {
+        status: "fulfilled",
+        value: n
+      }, o?.forEach(({ resolve: i }) => {
+        i(n);
+      });
+    });
+    "catch" in r && r.catch((n) => {
+      const { subscribers: o } = this;
+      this.subscribers = null, this.settlement = {
+        status: "rejected",
+        reason: n
+      }, o?.forEach(({ reject: i }) => {
+        i(n);
+      });
+    });
+  }
+  /** Create a promise that mitigates uncontrolled subscription to a long-lived
+  * Promise via .then() and .catch() - otherwise a source of memory leaks.
+  *
+  * The returned promise has an `unsubscribe()` method which can be called when
+  * the Promise is no longer being tracked by application logic, and which
+  * ensures that there is no reference chain from the original promise to the
+  * new one, and therefore no memory leak.
+  *
+  * If original promise has not yet settled, this adds a new unique promise
+  * that listens to then/catch events, along with an `unsubscribe()` method to
+  * detach it.
+  *
+  * If original promise has settled, then creates a new Promise.resolve() or
+  * Promise.reject() and provided unsubscribe is a noop.
+  *
+  * If you call `unsubscribe()` before the returned Promise has settled, it
+  * will never settle.
+  */
+  subscribe() {
+    let t, r;
+    const { settlement: n } = this;
+    if (n === null) {
+      if (this.subscribers === null) throw new Error("Unpromise settled but still has subscribers");
+      const o = $t();
+      this.subscribers = zt(this.subscribers, o), t = o.promise, r = () => {
+        this.subscribers !== null && (this.subscribers = Gt(this.subscribers, o));
+      };
+    } else {
+      const { status: o } = n;
+      o === "fulfilled" ? t = Promise.resolve(n.value) : t = Promise.reject(n.reason), r = Nt;
+    }
+    return Object.assign(t, { unsubscribe: r });
+  }
+  /** STANDARD PROMISE METHODS (but returning a SubscribedPromise) */
+  then(t, r) {
+    const n = this.subscribe(), { unsubscribe: o } = n;
+    return Object.assign(n.then(t, r), { unsubscribe: o });
+  }
+  catch(t) {
+    const r = this.subscribe(), { unsubscribe: n } = r;
+    return Object.assign(r.catch(t), { unsubscribe: n });
+  }
+  finally(t) {
+    const r = this.subscribe(), { unsubscribe: n } = r;
+    return Object.assign(r.finally(t), { unsubscribe: n });
+  }
+  /** Unpromise STATIC METHODS */
+  /** Create or Retrieve the proxy Unpromise (a re-used Unpromise for the VM lifetime
+  * of the provided Promise reference) */
+  static proxy(t) {
+    const r = C.getSubscribablePromise(t);
+    return typeof r < "u" ? r : C.createSubscribablePromise(t);
+  }
+  /** Create and store an Unpromise keyed by an original Promise. */
+  static createSubscribablePromise(t) {
+    const r = new C(t);
+    return ue.set(t, r), ue.set(r, r), r;
+  }
+  /** Retrieve a previously-created Unpromise keyed by an original Promise. */
+  static getSubscribablePromise(t) {
+    return ue.get(t);
+  }
+  /** Promise STATIC METHODS */
+  /** Lookup the Unpromise for this promise, and derive a SubscribedPromise from
+  * it (that can be later unsubscribed to eliminate Memory leaks) */
+  static resolve(t) {
+    const r = typeof t == "object" && t !== null && "then" in t && typeof t.then == "function" ? t : Promise.resolve(t);
+    return C.proxy(r).subscribe();
+  }
+  static async any(t) {
+    const n = (Array.isArray(t) ? t : [...t]).map(C.resolve);
+    try {
+      return await Promise.any(n);
+    } finally {
+      n.forEach(({ unsubscribe: o }) => {
+        o();
+      });
+    }
+  }
+  static async race(t) {
+    const n = (Array.isArray(t) ? t : [...t]).map(C.resolve);
+    try {
+      return await Promise.race(n);
+    } finally {
+      n.forEach(({ unsubscribe: o }) => {
+        o();
+      });
+    }
+  }
+  /** Create a race of SubscribedPromises that will fulfil to a single winning
+  * Promise (in a 1-Tuple). Eliminates memory leaks from long-lived promises
+  * accumulating .then() and .catch() subscribers. Allows simple logic to
+  * consume the result, like...
+  * ```ts
+  * const [ winner ] = await Unpromise.race([ promiseA, promiseB ]);
+  * if(winner === promiseB){
+  *   const result = await promiseB;
+  *   // do the thing
+  * }
+  * ```
+  * */
+  static async raceReferences(t) {
+    const r = t.map(Ut);
+    try {
+      return await Promise.race(r);
+    } finally {
+      for (const n of r) n.unsubscribe();
+    }
+  }
+};
+function Ut(e) {
+  return Ye.proxy(e).then(() => [e]);
+}
+function $t() {
+  let e, t;
+  return {
+    promise: new Promise((n, o) => {
+      e = n, t = o;
+    }),
+    resolve: e,
+    reject: t
+  };
+}
+function zt(e, t) {
+  return [...e, t];
+}
+function Wt(e, t) {
+  return [...e.slice(0, t), ...e.slice(t + 1)];
+}
+function Gt(e, t) {
+  const r = e.indexOf(t);
+  return r !== -1 ? Wt(e, r) : e;
+}
+var Ee, je, Oe, ke;
+(je = (Ee = Symbol).dispose) !== null && je !== void 0 || (Ee.dispose = Symbol());
+(ke = (Oe = Symbol).asyncDispose) !== null && ke !== void 0 || (Oe.asyncDispose = Symbol());
+function re(e, t) {
+  const r = e, n = r[Symbol.dispose];
+  return r[Symbol.dispose] = () => {
+    t(), n?.();
+  }, r;
+}
+function Ke(e, t) {
+  const r = e, n = r[Symbol.asyncDispose];
+  return r[Symbol.asyncDispose] = async () => {
+    await t(), await n?.();
+  }, r;
+}
+const Ve = Symbol();
+function Bt(e) {
+  let t = null;
+  return re({ start() {
+    if (t) throw new Error("Timer already started");
+    return new Promise((n) => {
+      t = setTimeout(() => n(Ve), e);
+    });
+  } }, () => {
+    t && clearTimeout(t);
+  });
+}
+var H = W({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/usingCtx.js"(e, t) {
+  function r() {
+    var n = typeof SuppressedError == "function" ? SuppressedError : function(a, s) {
+      var u = Error();
+      return u.name = "SuppressedError", u.error = a, u.suppressed = s, u;
+    }, o = {}, i = [];
+    function c(a, s) {
+      if (s != null) {
+        if (Object(s) !== s) throw new TypeError("using declarations can only be used with objects, functions, null, or undefined.");
+        if (a) var u = s[Symbol.asyncDispose || Symbol.for("Symbol.asyncDispose")];
+        if (u === void 0 && (u = s[Symbol.dispose || Symbol.for("Symbol.dispose")], a)) var l = u;
+        if (typeof u != "function") throw new TypeError("Object is not disposable.");
+        l && (u = function() {
+          try {
+            l.call(s);
+          } catch (f) {
+            return Promise.reject(f);
+          }
+        }), i.push({
+          v: s,
+          d: u,
+          a
+        });
+      } else a && i.push({
+        d: s,
+        a
+      });
+      return s;
+    }
+    return {
+      e: o,
+      u: c.bind(null, !1),
+      a: c.bind(null, !0),
+      d: function() {
+        var s, u = this.e, l = 0;
+        function d() {
+          for (; s = i.pop(); ) try {
+            if (!s.a && l === 1) return l = 0, i.push(s), Promise.resolve().then(d);
+            if (s.d) {
+              var p = s.d.call(s.v);
+              if (s.a) return l |= 2, Promise.resolve(p).then(d, f);
+            } else l |= 1;
+          } catch (h) {
+            return f(h);
+          }
+          if (l === 1) return u !== o ? Promise.reject(u) : Promise.resolve();
+          if (u !== o) throw u;
+        }
+        function f(p) {
+          return u = u !== o ? new n(p, u) : p, d();
+        }
+        return d();
+      }
+    };
+  }
+  t.exports = r, t.exports.__esModule = !0, t.exports.default = t.exports;
+} }), ye = W({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/OverloadYield.js"(e, t) {
+  function r(n, o) {
+    this.v = n, this.k = o;
+  }
+  t.exports = r, t.exports.__esModule = !0, t.exports.default = t.exports;
+} }), J = W({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/awaitAsyncGenerator.js"(e, t) {
+  var r = ye();
+  function n(o) {
+    return new r(o, 0);
+  }
+  t.exports = n, t.exports.__esModule = !0, t.exports.default = t.exports;
+} }), G = W({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/wrapAsyncGenerator.js"(e, t) {
+  var r = ye();
+  function n(i) {
+    return function() {
+      return new o(i.apply(this, arguments));
+    };
+  }
+  function o(i) {
+    var c, a;
+    function s(l, d) {
+      try {
+        var f = i[l](d), p = f.value, h = p instanceof r;
+        Promise.resolve(h ? p.v : p).then(function(m) {
+          if (h) {
+            var v = l === "return" ? "return" : "next";
+            if (!p.k || m.done) return s(v, m);
+            m = i[v](m).value;
+          }
+          u(f.done ? "return" : "normal", m);
+        }, function(m) {
+          s("throw", m);
+        });
+      } catch (m) {
+        u("throw", m);
+      }
+    }
+    function u(l, d) {
+      switch (l) {
+        case "return":
+          c.resolve({
+            value: d,
+            done: !0
+          });
+          break;
+        case "throw":
+          c.reject(d);
+          break;
+        default:
+          c.resolve({
+            value: d,
+            done: !1
+          });
+      }
+      (c = c.next) ? s(c.key, c.arg) : a = null;
+    }
+    this._invoke = function(l, d) {
+      return new Promise(function(f, p) {
+        var h = {
+          key: l,
+          arg: d,
+          resolve: f,
+          reject: p,
+          next: null
+        };
+        a ? a = a.next = h : (c = a = h, s(l, d));
+      });
+    }, typeof i.return != "function" && (this.return = void 0);
+  }
+  o.prototype[typeof Symbol == "function" && Symbol.asyncIterator || "@@asyncIterator"] = function() {
+    return this;
+  }, o.prototype.next = function(i) {
+    return this._invoke("next", i);
+  }, o.prototype.throw = function(i) {
+    return this._invoke("throw", i);
+  }, o.prototype.return = function(i) {
+    return this._invoke("return", i);
+  }, t.exports = n, t.exports.__esModule = !0, t.exports.default = t.exports;
+} });
+w(H());
+w(J());
+w(G());
+function Re(e) {
+  const t = e[Symbol.asyncIterator]();
+  return t[Symbol.asyncDispose] ? t : Ke(t, async () => {
+    var r;
+    await ((r = t.return) === null || r === void 0 ? void 0 : r.call(t));
+  });
+}
+function Ft() {
+  let e, t;
+  return {
+    promise: new Promise((n, o) => {
+      e = n, t = o;
+    }),
+    resolve: e,
+    reject: t
+  };
+}
+w(H());
+w(J());
+w(G());
+w(H());
+w(J());
+w(G());
+var Ze = W({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/asyncIterator.js"(e, t) {
+  function r(o) {
+    var i, c, a, s = 2;
+    for (typeof Symbol < "u" && (c = Symbol.asyncIterator, a = Symbol.iterator); s--; ) {
+      if (c && (i = o[c]) != null) return i.call(o);
+      if (a && (i = o[a]) != null) return new n(i.call(o));
+      c = "@@asyncIterator", a = "@@iterator";
+    }
+    throw new TypeError("Object is not async iterable");
+  }
+  function n(o) {
+    function i(c) {
+      if (Object(c) !== c) return Promise.reject(new TypeError(c + " is not an object."));
+      var a = c.done;
+      return Promise.resolve(c.value).then(function(s) {
+        return {
+          value: s,
+          done: a
+        };
+      });
+    }
+    return n = function(a) {
+      this.s = a, this.n = a.next;
+    }, n.prototype = {
+      s: null,
+      n: null,
+      next: function() {
+        return i(this.n.apply(this.s, arguments));
+      },
+      return: function(a) {
+        var s = this.s.return;
+        return s === void 0 ? Promise.resolve({
+          value: a,
+          done: !0
+        }) : i(s.apply(this.s, arguments));
+      },
+      throw: function(a) {
+        var s = this.s.return;
+        return s === void 0 ? Promise.reject(a) : i(s.apply(this.s, arguments));
+      }
+    }, new n(o);
+  }
+  t.exports = r, t.exports.__esModule = !0, t.exports.default = t.exports;
+} }), Ht = w(J()), Jt = w(G()), Te = w(H());
+w(Ze());
+const Yt = 0, Kt = 1, Vt = 0, Zt = 1, Qt = 0, Xt = 1, er = 2;
+var qe = class extends Error {
+  constructor(e) {
+    super("Received error from server"), this.data = e;
+  }
+};
+const tr = (e) => ({ getReader() {
+  return new ReadableStream({ start(r) {
+    e.on("data", (n) => {
+      r.enqueue(n);
+    }), e.on("end", () => {
+      r.close();
+    }), e.on("error", (n) => {
+      r.error(n);
+    });
+  } }).getReader();
+} });
+function rr(e) {
+  const t = "getReader" in e ? e.getReader() : tr(e).getReader();
+  let r = "";
+  return new ReadableStream({
+    async pull(n) {
+      const { done: o, value: i } = await t.read();
+      o ? n.close() : n.enqueue(i);
+    },
+    cancel() {
+      return t.cancel();
+    }
+  }).pipeThrough(new TextDecoderStream()).pipeThrough(new TransformStream({ transform(n, o) {
+    var i;
+    r += n;
+    const c = r.split(`
+`);
+    r = (i = c.pop()) !== null && i !== void 0 ? i : "";
+    for (const a of c) o.enqueue(a);
+  } }));
+}
+function nr(e) {
+  const t = rr(e);
+  let r = !1;
+  return t.pipeThrough(new TransformStream({ transform(n, o) {
+    if (r) {
+      const i = JSON.parse(n);
+      o.enqueue(i);
+    } else {
+      const i = JSON.parse(n);
+      o.enqueue(i), r = !0;
+    }
+  } }));
+}
+function or(e) {
+  const t = /* @__PURE__ */ new Map();
+  function r() {
+    return Array.from(t.values()).every((a) => a.closed);
+  }
+  function n() {
+    let a;
+    const s = new ReadableStream({ start(d) {
+      a = d;
+    } }), u = {
+      enqueue: (d) => a.enqueue(d),
+      close: () => {
+        a.close(), l(), r() && e.abort();
+      },
+      closed: !1,
+      getReaderResource: () => {
+        const d = s.getReader();
+        return re(d, () => {
+          u.close(), d.releaseLock();
+        });
+      },
+      error: (d) => {
+        a.error(d), l();
+      }
+    };
+    function l() {
+      Object.assign(u, {
+        closed: !0,
+        close: () => {
+        },
+        enqueue: () => {
+        },
+        getReaderResource: null,
+        error: () => {
+        }
+      });
+    }
+    return u;
+  }
+  function o(a) {
+    let s = t.get(a);
+    return s || (s = n(), t.set(a, s)), s;
+  }
+  function i(a) {
+    for (const s of t.values()) s.error(a);
+  }
+  function c() {
+    for (const a of t.values()) a.close();
+  }
+  return {
+    getOrCreate: o,
+    cancelAll: i,
+    closeAll: c
+  };
+}
+async function sr(e) {
+  const { deserialize: t = (u) => u } = e;
+  let r = nr(e.from);
+  t && (r = r.pipeThrough(new TransformStream({ transform(u, l) {
+    l.enqueue(t(u));
+  } })));
+  let n = Ft();
+  const o = or(e.abortController);
+  function i(u) {
+    const [l, d, f] = u, p = o.getOrCreate(f);
+    switch (d) {
+      case Yt:
+        return I(async () => {
+          try {
+            var h = (0, Te.default)();
+            const x = h.u(p.getReaderResource()), { value: g } = await x.read(), [b, j, y] = g;
+            switch (j) {
+              case Vt:
+                return c(y);
+              case Zt:
+                var m, v;
+                throw (m = (v = e.formatError) === null || v === void 0 ? void 0 : v.call(e, { error: y })) !== null && m !== void 0 ? m : new qe(y);
+            }
+          } catch (x) {
+            h.e = x;
+          } finally {
+            h.d();
+          }
+        });
+      case Kt:
+        return I((0, Jt.default)(function* () {
+          try {
+            var h = (0, Te.default)();
+            const x = h.u(p.getReaderResource());
+            for (; ; ) {
+              const { value: g } = yield (0, Ht.default)(x.read()), [b, j, y] = g;
+              switch (j) {
+                case Xt:
+                  yield c(y);
+                  break;
+                case Qt:
+                  return c(y);
+                case er:
+                  var m, v;
+                  throw (m = (v = e.formatError) === null || v === void 0 ? void 0 : v.call(e, { error: y })) !== null && m !== void 0 ? m : new qe(y);
+              }
+            }
+          } catch (x) {
+            h.e = x;
+          } finally {
+            h.d();
+          }
+        }));
+    }
+  }
+  function c(u) {
+    const [[l], ...d] = u;
+    for (const f of d) {
+      const [p] = f, h = i(f);
+      if (p === null) return h;
+      l[p] = h;
+    }
+    return l;
+  }
+  const a = () => {
+    n && (n.reject(new Error("Stream closed before head was received")), n = null), o.closeAll();
+  }, s = (u) => {
+    n?.reject(u), n = null, o.cancelAll(u);
+  };
+  return r.pipeTo(new WritableStream({
+    write(u) {
+      if (n) {
+        const p = u;
+        for (const [h, m] of Object.entries(u)) {
+          const v = c(m);
+          p[h] = v;
+        }
+        n.resolve(p), n = null;
+        return;
+      }
+      const l = u, [d] = l;
+      o.getOrCreate(d).enqueue(l);
+    },
+    close: a,
+    abort: s
+  })).catch((u) => {
+    var l;
+    (l = e.onError) === null || l === void 0 || l.call(e, { error: u }), s(u);
+  }), [await n.promise];
+}
+var ir = W({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/asyncGeneratorDelegate.js"(e, t) {
+  var r = ye();
+  function n(o) {
+    var i = {}, c = !1;
+    function a(s, u) {
+      return c = !0, u = new Promise(function(l) {
+        l(o[s](u));
+      }), {
+        done: !1,
+        value: new r(u, 1)
+      };
+    }
+    return i[typeof Symbol < "u" && Symbol.iterator || "@@iterator"] = function() {
+      return this;
+    }, i.next = function(s) {
+      return c ? (c = !1, s) : a("next", s);
+    }, typeof o.throw == "function" && (i.throw = function(s) {
+      if (c) throw c = !1, s;
+      return a("throw", s);
+    }), typeof o.return == "function" && (i.return = function(s) {
+      return c ? (c = !1, s) : a("return", s);
+    }), i;
+  }
+  t.exports = n, t.exports.__esModule = !0, t.exports.default = t.exports;
+} });
+w(Ze());
+var Ae = w(J()), ar = w(G());
+w(ir());
+var Qe = w(H());
+const cr = "ping", ur = "serialized-error", lr = "connected", dr = "return";
+async function fr(e) {
+  try {
+    var t = (0, Qe.default)();
+    const r = t.u(Bt(e.timeoutMs)), n = await Ye.race([e.promise, r.start()]);
+    return n === Ve ? await e.onTimeout() : n;
+  } catch (r) {
+    t.e = r;
+  } finally {
+    t.d();
+  }
+}
+function pr(e) {
+  const { deserialize: t = (a) => a } = e;
+  let r = pt();
+  const n = e.signal;
+  let o = null;
+  const i = () => new ReadableStream({
+    async start(a) {
+      const [s, u] = await Promise.all([e.url(), e.init()]), l = o = new e.EventSource(s, u);
+      a.enqueue({
+        type: "connecting",
+        eventSource: o,
+        event: null
+      }), l.addEventListener(lr, (f) => {
+        const h = JSON.parse(f.data);
+        r = h, a.enqueue({
+          type: "connected",
+          options: h,
+          eventSource: l
+        });
+      }), l.addEventListener(ur, (f) => {
+        const p = f;
+        a.enqueue({
+          type: "serialized-error",
+          error: t(JSON.parse(p.data)),
+          eventSource: l
+        });
+      }), l.addEventListener(cr, () => {
+        a.enqueue({
+          type: "ping",
+          eventSource: l
+        });
+      }), l.addEventListener(dr, () => {
+        l.close(), a.close(), o = null;
+      }), l.addEventListener("error", (f) => {
+        l.readyState === l.CLOSED ? a.error(f) : a.enqueue({
+          type: "connecting",
+          eventSource: l,
+          event: f
+        });
+      }), l.addEventListener("message", (f) => {
+        const p = f, m = { data: t(JSON.parse(p.data)) };
+        p.lastEventId && (m.id = p.lastEventId), a.enqueue({
+          type: "data",
+          data: m,
+          eventSource: l
+        });
+      });
+      const d = () => {
+        try {
+          l.close(), a.close();
+        } catch {
+        }
+      };
+      n.aborted ? d() : n.addEventListener("abort", d);
+    },
+    cancel() {
+      o?.close();
+    }
+  }), c = () => {
+    let a = i(), s = a.getReader();
+    async function u() {
+      await s.cancel(), o = null;
+    }
+    return Ke({
+      read() {
+        return s.read();
+      },
+      async recreate() {
+        await u(), a = i(), s = a.getReader();
+      }
+    }, u);
+  };
+  return I((0, ar.default)(function* () {
+    try {
+      var a = (0, Qe.default)();
+      const s = a.a(c());
+      for (; ; ) {
+        let u = s.read();
+        const l = r.reconnectAfterInactivityMs;
+        l && (u = fr({
+          promise: u,
+          timeoutMs: l,
+          onTimeout: async () => {
+            const f = {
+              value: {
+                type: "timeout",
+                ms: l,
+                eventSource: o
+              },
+              done: !1
+            };
+            return await s.recreate(), f;
+          }
+        }));
+        const d = yield (0, Ae.default)(u);
+        if (d.done) return d.value;
+        yield d.value;
+      }
+    } catch (s) {
+      a.e = s;
+    } finally {
+      yield (0, Ae.default)(a.d());
+    }
+  }));
+}
+w(G());
+w(oe());
+var Z = S(D()), N = S(k());
+function Xe(e) {
+  return e instanceof _;
+}
+function mr(e) {
+  return M(e) && M(e.error) && typeof e.error.code == "number" && typeof e.error.message == "string";
+}
+function hr(e, t) {
+  return typeof e == "string" ? e : M(e) && typeof e.message == "string" ? e.message : t;
+}
+var _ = class ee extends Error {
+  constructor(t, r) {
+    var n, o;
+    const i = r?.cause;
+    super(t, { cause: i }), (0, Z.default)(this, "cause", void 0), (0, Z.default)(this, "shape", void 0), (0, Z.default)(this, "data", void 0), (0, Z.default)(this, "meta", void 0), this.meta = r?.meta, this.cause = i, this.shape = r == null || (n = r.result) === null || n === void 0 ? void 0 : n.error, this.data = r == null || (o = r.result) === null || o === void 0 ? void 0 : o.error.data, this.name = "TRPCClientError", Object.setPrototypeOf(this, ee.prototype);
+  }
+  static from(t, r = {}) {
+    const n = t;
+    return Xe(n) ? (r.meta && (n.meta = (0, N.default)((0, N.default)({}, n.meta), r.meta)), n) : mr(n) ? new ee(n.error.message, (0, N.default)((0, N.default)({}, r), {}, {
+      result: n,
+      cause: r.cause
+    })) : new ee(hr(n, "Unknown error"), (0, N.default)((0, N.default)({}, r), {}, { cause: n }));
+  }
+};
+function ie(e) {
+  const t = e;
+  return t ? "input" in t ? t : {
+    input: t,
+    output: t
+  } : {
+    input: {
+      serialize: (r) => r,
+      deserialize: (r) => r
+    },
+    output: {
+      serialize: (r) => r,
+      deserialize: (r) => r
+    }
+  };
+}
+const Ce = (e) => typeof e == "function";
+function yr(e) {
+  if (e) return e;
+  if (typeof window < "u" && Ce(window.fetch)) return window.fetch;
+  if (typeof globalThis < "u" && Ce(globalThis.fetch)) return globalThis.fetch;
+  throw new Error("No fetch implementation found");
+}
+var B = S(k());
+function ve(e) {
+  return {
+    url: e.url.toString(),
+    fetch: e.fetch,
+    transformer: ie(e.transformer),
+    methodOverride: e.methodOverride
+  };
+}
+function vr(e) {
+  const t = {};
+  for (let r = 0; r < e.length; r++) {
+    const n = e[r];
+    t[r] = n;
+  }
+  return t;
+}
+const br = {
+  query: "GET",
+  mutation: "POST",
+  subscription: "PATCH"
+};
+function et(e) {
+  return "input" in e ? e.transformer.input.serialize(e.input) : vr(e.inputs.map((t) => e.transformer.input.serialize(t)));
+}
+const L = (e) => {
+  const t = e.url.split("?");
+  let n = t[0].replace(/\/$/, "") + "/" + e.path;
+  const o = [];
+  if (t[1] && o.push(t[1]), "inputs" in e && o.push("batch=1"), e.type === "query" || e.type === "subscription") {
+    const i = et(e);
+    i !== void 0 && e.methodOverride !== "POST" && o.push(`input=${encodeURIComponent(JSON.stringify(i))}`);
+  }
+  return o.length && (n += "?" + o.join("&")), n;
+}, tt = (e) => {
+  if (e.type === "query" && e.methodOverride !== "POST") return;
+  const t = et(e);
+  return t !== void 0 ? JSON.stringify(t) : void 0;
+}, rt = (e) => pe((0, B.default)((0, B.default)({}, e), {}, {
+  contentTypeHeader: "application/json",
+  getUrl: L,
+  getBody: tt
+}));
+var gr = class extends Error {
+  constructor() {
+    const e = "AbortError";
+    super(e), this.name = e, this.message = e;
+  }
+};
+const wr = (e) => {
+  var t;
+  if (e?.aborted)
+    throw (t = e.throwIfAborted) === null || t === void 0 || t.call(e), typeof DOMException < "u" ? new DOMException("AbortError", "AbortError") : new gr();
+};
+async function nt(e) {
+  var t, r;
+  wr(e.signal);
+  const n = e.getUrl(e), o = e.getBody(e), i = (t = e.methodOverride) !== null && t !== void 0 ? t : br[e.type], c = await (async () => {
+    const s = await e.headers();
+    return Symbol.iterator in s ? Object.fromEntries(s) : s;
+  })(), a = (0, B.default)((0, B.default)((0, B.default)({}, e.contentTypeHeader && i !== "GET" ? { "content-type": e.contentTypeHeader } : {}), e.trpcAcceptHeader ? { [(r = e.trpcAcceptHeaderKey) !== null && r !== void 0 ? r : "trpc-accept"]: e.trpcAcceptHeader } : void 0), c);
+  return yr(e.fetch)(n, {
+    method: i,
+    signal: e.signal,
+    body: o,
+    headers: a
+  });
+}
+async function pe(e) {
+  const t = {}, r = await nt(e);
+  t.response = r;
+  const n = await r.json();
+  return t.responseJSON = n, {
+    json: n,
+    meta: t
+  };
+}
+function ot(e) {
+  return e instanceof Uint8Array || e instanceof Blob;
+}
+function st(e) {
+  return e instanceof FormData;
+}
+function en(e) {
+  return ot(e) || st(e);
+}
+var z = S(k());
+const xr = (e) => {
+  if ("input" in e) {
+    const { input: t } = e;
+    if (st(t)) {
+      if (e.type !== "mutation" && e.methodOverride !== "POST") throw new Error("FormData is only supported for mutations");
+      return pe((0, z.default)((0, z.default)({}, e), {}, {
+        contentTypeHeader: void 0,
+        getUrl: L,
+        getBody: () => t
+      }));
+    }
+    if (ot(t)) {
+      if (e.type !== "mutation" && e.methodOverride !== "POST") throw new Error("Octet type input is only supported for mutations");
+      return pe((0, z.default)((0, z.default)({}, e), {}, {
+        contentTypeHeader: "application/octet-stream",
+        getUrl: L,
+        getBody: () => t
+      }));
+    }
+  }
+  return rt(e);
+};
+function tn(e) {
+  const t = ve(e);
+  return () => (r) => {
+    const { op: n } = r;
+    return E((o) => {
+      const { path: i, input: c, type: a } = n;
+      /* istanbul ignore if -- @preserve */
+      if (a === "subscription") throw new Error("Subscriptions are unsupported by `httpLink` - use `httpSubscriptionLink` or `wsLink`");
+      const s = xr((0, z.default)((0, z.default)({}, t), {}, {
+        type: a,
+        path: i,
+        input: c,
+        signal: n.signal,
+        headers() {
+          return e.headers ? typeof e.headers == "function" ? e.headers({ op: n }) : e.headers : {};
+        }
+      }));
+      let u;
+      return s.then((l) => {
+        u = l.meta;
+        const d = he(l.json, t.transformer.output);
+        if (!d.ok) {
+          o.error(_.from(d.error, { meta: u }));
+          return;
+        }
+        o.next({
+          context: l.meta,
+          result: d.result
+        }), o.complete();
+      }).catch((l) => {
+        o.error(_.from(l, { meta: u }));
+      }), () => {
+      };
+    });
+  };
+}
+const Me = () => {
+  throw new Error("Something went wrong. Please submit an issue at https://github.com/trpc/trpc/issues/new");
+};
+function ne(e) {
+  let t = null, r = null;
+  const n = () => {
+    clearTimeout(r), r = null, t = null;
+  };
+  function o(a) {
+    const s = [[]];
+    let u = 0;
+    for (; ; ) {
+      const f = a[u];
+      if (!f) break;
+      const p = s[s.length - 1];
+      if (f.aborted) {
+        var l;
+        (l = f.reject) === null || l === void 0 || l.call(f, new Error("Aborted")), u++;
+        continue;
+      }
+      if (e.validate(p.concat(f).map((m) => m.key))) {
+        p.push(f), u++;
+        continue;
+      }
+      if (p.length === 0) {
+        var d;
+        (d = f.reject) === null || d === void 0 || d.call(f, new Error("Input is too big for a single dispatch")), u++;
+        continue;
+      }
+      s.push([]);
+    }
+    return s;
+  }
+  function i() {
+    const a = o(t);
+    n();
+    for (const s of a) {
+      if (!s.length) continue;
+      const u = { items: s };
+      for (const d of s) d.batch = u;
+      e.fetch(u.items.map((d) => d.key)).then(async (d) => {
+        await Promise.all(d.map(async (p, h) => {
+          const m = u.items[h];
+          try {
+            var v;
+            const g = await Promise.resolve(p);
+            (v = m.resolve) === null || v === void 0 || v.call(m, g);
+          } catch (g) {
+            var x;
+            (x = m.reject) === null || x === void 0 || x.call(m, g);
+          }
+          m.batch = null, m.reject = null, m.resolve = null;
+        }));
+        for (const p of u.items) {
+          var f;
+          (f = p.reject) === null || f === void 0 || f.call(p, new Error("Missing result")), p.batch = null;
+        }
+      }).catch((d) => {
+        for (const p of u.items) {
+          var f;
+          (f = p.reject) === null || f === void 0 || f.call(p, d), p.batch = null;
+        }
+      });
+    }
+  }
+  function c(a) {
+    var s;
+    const u = {
+      aborted: !1,
+      key: a,
+      batch: null,
+      resolve: Me,
+      reject: Me
+    }, l = new Promise((d, f) => {
+      var p;
+      u.reject = f, u.resolve = d, (p = t) !== null && p !== void 0 || (t = []), t.push(u);
+    });
+    return (s = r) !== null && s !== void 0 || (r = setTimeout(i)), l;
+  }
+  return { load: c };
+}
+function it(...e) {
+  const t = new AbortController(), r = e.length;
+  let n = 0;
+  const o = () => {
+    ++n === r && t.abort();
+  };
+  for (const i of e) i?.aborted ? o() : i?.addEventListener("abort", o, { once: !0 });
+  return t.signal;
+}
+function be(...e) {
+  const t = new AbortController();
+  for (const r of e) r?.aborted ? t.abort() : r?.addEventListener("abort", () => t.abort(), { once: !0 });
+  return t.signal;
+}
+function Sr(e) {
+  return new Promise((t, r) => {
+    if (e.aborted) {
+      r(e.reason);
+      return;
+    }
+    e.addEventListener("abort", () => {
+      r(e.reason);
+    }, { once: !0 });
+  });
+}
+var Q = S(k());
+function rn(e) {
+  var t, r;
+  const n = ve(e), o = (t = e.maxURLLength) !== null && t !== void 0 ? t : 1 / 0, i = (r = e.maxItems) !== null && r !== void 0 ? r : 1 / 0;
+  return () => {
+    const c = (l) => ({
+      validate(d) {
+        if (o === 1 / 0 && i === 1 / 0) return !0;
+        if (d.length > i) return !1;
+        const f = d.map((m) => m.path).join(","), p = d.map((m) => m.input);
+        return L((0, Q.default)((0, Q.default)({}, n), {}, {
+          type: l,
+          path: f,
+          inputs: p,
+          signal: null
+        })).length <= o;
+      },
+      async fetch(d) {
+        const f = d.map((g) => g.path).join(","), p = d.map((g) => g.input), h = it(...d.map((g) => g.signal)), m = await rt((0, Q.default)((0, Q.default)({}, n), {}, {
+          path: f,
+          inputs: p,
+          type: l,
+          headers() {
+            return e.headers ? typeof e.headers == "function" ? e.headers({ opList: d }) : e.headers : {};
+          },
+          signal: h
+        }));
+        return (Array.isArray(m.json) ? m.json : d.map(() => m.json)).map((g) => ({
+          meta: m.meta,
+          json: g
+        }));
+      }
+    }), a = ne(c("query")), s = ne(c("mutation")), u = {
+      query: a,
+      mutation: s
+    };
+    return ({ op: l }) => E((d) => {
+      /* istanbul ignore if -- @preserve */
+      if (l.type === "subscription") throw new Error("Subscriptions are unsupported by `httpLink` - use `httpSubscriptionLink` or `wsLink`");
+      const p = u[l.type].load(l);
+      let h;
+      return p.then((m) => {
+        h = m;
+        const v = he(m.json, n.transformer.output);
+        if (!v.ok) {
+          d.error(_.from(v.error, { meta: m.meta }));
+          return;
+        }
+        d.next({
+          context: m.meta,
+          result: v.result
+        }), d.complete();
+      }).catch((m) => {
+        d.error(_.from(m, { meta: h?.meta }));
+      }), () => {
+      };
+    });
+  };
+}
+var O = S(k());
+function _r(e) {
+  return typeof FormData > "u" ? !1 : e instanceof FormData;
+}
+const le = {
+  css: {
+    query: ["72e3ff", "3fb0d8"],
+    mutation: ["c5a3fc", "904dfc"],
+    subscription: ["ff49e1", "d83fbe"]
+  },
+  ansi: {
+    regular: {
+      query: ["\x1B[30;46m", "\x1B[97;46m"],
+      mutation: ["\x1B[30;45m", "\x1B[97;45m"],
+      subscription: ["\x1B[30;42m", "\x1B[97;42m"]
+    },
+    bold: {
+      query: ["\x1B[1;30;46m", "\x1B[1;97;46m"],
+      mutation: ["\x1B[1;30;45m", "\x1B[1;97;45m"],
+      subscription: ["\x1B[1;30;42m", "\x1B[1;97;42m"]
+    }
+  }
+};
+function Pr(e) {
+  const { direction: t, type: r, withContext: n, path: o, id: i, input: c } = e, a = [], s = [];
+  if (e.colorMode === "none") a.push(t === "up" ? ">>" : "<<", r, `#${i}`, o);
+  else if (e.colorMode === "ansi") {
+    const [u, l] = le.ansi.regular[r], [d, f] = le.ansi.bold[r];
+    a.push(t === "up" ? u : l, t === "up" ? ">>" : "<<", r, t === "up" ? d : f, `#${i}`, o, "\x1B[0m");
+  } else {
+    const [u, l] = le.css[r], d = `
+    background-color: #${t === "up" ? u : l};
+    color: ${t === "up" ? "black" : "white"};
+    padding: 2px;
+  `;
+    a.push("%c", t === "up" ? ">>" : "<<", r, `#${i}`, `%c${o}%c`, "%O"), s.push(d, `${d}; font-weight: bold;`, `${d}; font-weight: normal;`);
+  }
+  return t === "up" ? s.push(n ? {
+    input: c,
+    context: e.context
+  } : { input: c }) : s.push((0, O.default)({
+    input: c,
+    result: e.result,
+    elapsedMs: e.elapsedMs
+  }, n && { context: e.context })), {
+    parts: a,
+    args: s
+  };
+}
+const Er = ({ c: e = console, colorMode: t = "css", withContext: r }) => (n) => {
+  const o = n.input, i = _r(o) ? Object.fromEntries(o) : o, { parts: c, args: a } = Pr((0, O.default)((0, O.default)({}, n), {}, {
+    colorMode: t,
+    input: i,
+    withContext: r
+  })), s = n.direction === "down" && n.result && (n.result instanceof Error || "error" in n.result.result && n.result.result.error) ? "error" : "log";
+  e[s].apply(null, [c.join(" ")].concat(a));
+};
+function nn(e = {}) {
+  var t, r;
+  const { enabled: n = () => !0 } = e, o = (t = e.colorMode) !== null && t !== void 0 ? t : typeof window > "u" ? "ansi" : "css", i = (r = e.withContext) !== null && r !== void 0 ? r : o === "css", { logger: c = Er({
+    c: e.console,
+    colorMode: o,
+    withContext: i
+  }) } = e;
+  return () => ({ op: a, next: s }) => E((u) => {
+    n((0, O.default)((0, O.default)({}, a), {}, { direction: "up" })) && c((0, O.default)((0, O.default)({}, a), {}, { direction: "up" }));
+    const l = Date.now();
+    function d(f) {
+      const p = Date.now() - l;
+      n((0, O.default)((0, O.default)({}, a), {}, {
+        direction: "down",
+        result: f
+      })) && c((0, O.default)((0, O.default)({}, a), {}, {
+        direction: "down",
+        elapsedMs: p,
+        result: f
+      }));
+    }
+    return s(a).pipe(kt({
+      next(f) {
+        d(f);
+      },
+      error(f) {
+        d(f);
+      }
+    })).subscribe(u);
+  });
+}
+const jr = {
+  encode: (e) => JSON.stringify(e),
+  decode: (e) => {
+    if (typeof e != "string") throw new Error("jsonEncoder received binary data. JSON uses text frames. Use a binary encoder for binary data.");
+    return JSON.parse(e);
+  }
+}, Or = {
+  enabled: !1,
+  closeMs: 0
+}, kr = {
+  enabled: !1,
+  pongTimeoutMs: 1e3,
+  intervalMs: 5e3
+}, Rr = (e) => e === 0 ? 0 : Math.min(1e3 * 2 ** e, 3e4), F = (e, ...t) => typeof e == "function" ? e(...t) : e;
+var Tr = S(D()), U = class at extends Error {
+  constructor(t) {
+    super(t.message, { cause: t.cause }), this.name = "TRPCWebSocketClosedError", Object.setPrototypeOf(this, at.prototype);
+  }
+}, qr = class {
+  constructor(e, t) {
+    this.onTimeout = e, this.timeoutMs = t, (0, Tr.default)(this, "timeout", void 0);
+  }
+  /**
+  * Resets the current timeout, restarting it with the same duration.
+  * Does nothing if no timeout is active.
+  */
+  reset() {
+    this.timeout && (clearTimeout(this.timeout), this.timeout = setTimeout(this.onTimeout, this.timeoutMs));
+  }
+  start() {
+    clearTimeout(this.timeout), this.timeout = setTimeout(this.onTimeout, this.timeoutMs);
+  }
+  stop() {
+    clearTimeout(this.timeout), this.timeout = void 0;
+  }
+};
+function ct() {
+  let e, t;
+  return {
+    promise: new Promise((n, o) => {
+      e = n, t = o;
+    }),
+    resolve: e,
+    reject: t
+  };
+}
+async function Ar(e) {
+  const t = await F(e.url);
+  if (!e.connectionParams) return t;
+  const n = `${t.includes("?") ? "&" : "?"}connectionParams=1`;
+  return t + n;
+}
+async function Cr(e, t) {
+  const r = {
+    method: "connectionParams",
+    data: await F(e)
+  };
+  return t.encode(r);
+}
+var Ie = S(D()), Mr = class {
+  constructor() {
+    (0, Ie.default)(this, "outgoingRequests", new Array()), (0, Ie.default)(this, "pendingRequests", {});
+  }
+  /**
+  * Registers a new request by adding it to the outgoing queue and setting up
+  * callbacks for lifecycle events such as completion or error.
+  *
+  * @param message - The outgoing message to be sent.
+  * @param callbacks - Callback functions to observe the request's state.
+  * @returns A cleanup function to manually remove the request.
+  */
+  register(e, t) {
+    const { promise: r, resolve: n } = ct();
+    return this.outgoingRequests.push({
+      id: String(e.id),
+      message: e,
+      end: r,
+      callbacks: {
+        next: t.next,
+        complete: () => {
+          t.complete(), n();
+        },
+        error: (o) => {
+          t.error(o), n();
+        }
+      }
+    }), () => {
+      this.delete(e.id), t.complete(), n();
+    };
+  }
+  /**
+  * Deletes a request from both the outgoing and pending collections, if it exists.
+  */
+  delete(e) {
+    e !== null && (this.outgoingRequests = this.outgoingRequests.filter(({ id: t }) => t !== String(e)), delete this.pendingRequests[String(e)]);
+  }
+  /**
+  * Moves all outgoing requests to the pending state and clears the outgoing queue.
+  *
+  * The caller is expected to handle the actual sending of the requests
+  * (e.g., sending them over the network) after this method is called.
+  *
+  * @returns The list of requests that were transitioned to the pending state.
+  */
+  flush() {
+    const e = this.outgoingRequests;
+    this.outgoingRequests = [];
+    for (const t of e) this.pendingRequests[t.id] = t;
+    return e;
+  }
+  /**
+  * Retrieves all currently pending requests, which are in flight awaiting responses
+  * or handling ongoing subscriptions.
+  */
+  getPendingRequests() {
+    return Object.values(this.pendingRequests);
+  }
+  /**
+  * Retrieves a specific pending request by its message ID.
+  */
+  getPendingRequest(e) {
+    return e === null ? null : this.pendingRequests[String(e)];
+  }
+  /**
+  * Retrieves all outgoing requests, which are waiting to be sent.
+  */
+  getOutgoingRequests() {
+    return this.outgoingRequests;
+  }
+  /**
+  * Retrieves all requests, both outgoing and pending, with their respective states.
+  *
+  * @returns An array of all requests with their state ("outgoing" or "pending").
+  */
+  getRequests() {
+    return [...this.getOutgoingRequests().map((e) => ({
+      state: "outgoing",
+      message: e.message,
+      end: e.end,
+      callbacks: e.callbacks
+    })), ...this.getPendingRequests().map((e) => ({
+      state: "pending",
+      message: e.message,
+      end: e.end,
+      callbacks: e.callbacks
+    }))];
+  }
+  /**
+  * Checks if there are any pending requests, including ongoing subscriptions.
+  */
+  hasPendingRequests() {
+    return this.getPendingRequests().length > 0;
+  }
+  /**
+  * Checks if there are any pending subscriptions
+  */
+  hasPendingSubscriptions() {
+    return this.getPendingRequests().some((e) => e.message.method === "subscription");
+  }
+  /**
+  * Checks if there are any outgoing requests waiting to be sent.
+  */
+  hasOutgoingRequests() {
+    return this.outgoingRequests.length > 0;
+  }
+}, q = S(D());
+function Ir(e) {
+  const { promise: t, resolve: r, reject: n } = ct();
+  return e.addEventListener("open", () => {
+    e.removeEventListener("error", n), r();
+  }), e.addEventListener("error", n), t;
+}
+function Lr(e, { intervalMs: t, pongTimeoutMs: r }) {
+  let n, o;
+  function i() {
+    n = setTimeout(() => {
+      e.send("PING"), o = setTimeout(() => {
+        e.close();
+      }, r);
+    }, t);
+  }
+  function c() {
+    clearTimeout(n), i();
+  }
+  function a() {
+    clearTimeout(o), c();
+  }
+  e.addEventListener("open", i), e.addEventListener("message", ({ data: s }) => {
+    clearTimeout(n), i(), s === "PONG" && a();
+  }), e.addEventListener("close", () => {
+    clearTimeout(n), clearTimeout(o);
+  });
+}
+var ut = class me {
+  constructor(t) {
+    var r;
+    if ((0, q.default)(this, "id", ++me.connectCount), (0, q.default)(this, "WebSocketPonyfill", void 0), (0, q.default)(this, "urlOptions", void 0), (0, q.default)(this, "keepAliveOpts", void 0), (0, q.default)(this, "encoder", void 0), (0, q.default)(this, "wsObservable", se(null)), (0, q.default)(this, "openPromise", null), this.WebSocketPonyfill = (r = t.WebSocketPonyfill) !== null && r !== void 0 ? r : WebSocket, !this.WebSocketPonyfill) throw new Error("No WebSocket implementation found - you probably don't want to use this on the server, but if you do you need to pass a `WebSocket`-ponyfill");
+    this.urlOptions = t.urlOptions, this.keepAliveOpts = t.keepAlive, this.encoder = t.encoder;
+  }
+  get ws() {
+    return this.wsObservable.get();
+  }
+  set ws(t) {
+    this.wsObservable.next(t);
+  }
+  /**
+  * Checks if the WebSocket connection is open and ready to communicate.
+  */
+  isOpen() {
+    return !!this.ws && this.ws.readyState === this.WebSocketPonyfill.OPEN && !this.openPromise;
+  }
+  /**
+  * Checks if the WebSocket connection is closed or in the process of closing.
+  */
+  isClosed() {
+    return !!this.ws && (this.ws.readyState === this.WebSocketPonyfill.CLOSING || this.ws.readyState === this.WebSocketPonyfill.CLOSED);
+  }
+  async open() {
+    var t = this;
+    if (t.openPromise) return t.openPromise;
+    t.id = ++me.connectCount;
+    const r = Ar(t.urlOptions).then((n) => new t.WebSocketPonyfill(n));
+    t.openPromise = r.then(async (n) => {
+      t.ws = n, n.binaryType = "arraybuffer", n.addEventListener("message", function({ data: o }) {
+        o === "PING" && this.send("PONG");
+      }), t.keepAliveOpts.enabled && Lr(n, t.keepAliveOpts), n.addEventListener("close", () => {
+        t.ws === n && (t.ws = null);
+      }), await Ir(n), t.urlOptions.connectionParams && n.send(await Cr(t.urlOptions.connectionParams, t.encoder));
+    });
+    try {
+      await t.openPromise;
+    } finally {
+      t.openPromise = null;
+    }
+  }
+  /**
+  * Closes the WebSocket connection gracefully.
+  * Waits for any ongoing open operation to complete before closing.
+  */
+  async close() {
+    var t = this;
+    try {
+      await t.openPromise;
+    } finally {
+      var r;
+      (r = t.ws) === null || r === void 0 || r.close();
+    }
+  }
+};
+(0, q.default)(ut, "connectCount", 0);
+function Dr(e) {
+  return e.isOpen() ? {
+    id: e.id,
+    state: "open",
+    ws: e.ws
+  } : e.isClosed() ? {
+    id: e.id,
+    state: "closed",
+    ws: e.ws
+  } : e.ws ? {
+    id: e.id,
+    state: "connecting",
+    ws: e.ws
+  } : null;
+}
+var R = S(D()), $ = S(k()), Nr = class {
+  constructor(e) {
+    var t, r;
+    (0, R.default)(this, "connectionState", void 0), (0, R.default)(this, "allowReconnect", !1), (0, R.default)(this, "requestManager", new Mr()), (0, R.default)(this, "activeConnection", void 0), (0, R.default)(this, "reconnectRetryDelay", void 0), (0, R.default)(this, "inactivityTimeout", void 0), (0, R.default)(this, "callbacks", void 0), (0, R.default)(this, "lazyMode", void 0), (0, R.default)(this, "encoder", void 0), (0, R.default)(this, "reconnecting", null), this.encoder = (t = e.experimental_encoder) !== null && t !== void 0 ? t : jr, this.callbacks = {
+      onOpen: e.onOpen,
+      onClose: e.onClose,
+      onError: e.onError
+    };
+    const n = (0, $.default)((0, $.default)({}, Or), e.lazy);
+    this.inactivityTimeout = new qr(() => {
+      if (this.requestManager.hasOutgoingRequests() || this.requestManager.hasPendingRequests()) {
+        this.inactivityTimeout.reset();
+        return;
+      }
+      this.close().catch(() => null);
+    }, n.closeMs), this.activeConnection = new ut({
+      WebSocketPonyfill: e.WebSocket,
+      urlOptions: e,
+      keepAlive: (0, $.default)((0, $.default)({}, kr), e.keepAlive),
+      encoder: this.encoder
+    }), this.activeConnection.wsObservable.subscribe({ next: (o) => {
+      o && this.setupWebSocketListeners(o);
+    } }), this.reconnectRetryDelay = (r = e.retryDelayMs) !== null && r !== void 0 ? r : Rr, this.lazyMode = n.enabled, this.connectionState = se({
+      type: "state",
+      state: n.enabled ? "idle" : "connecting",
+      error: null
+    }), this.lazyMode || this.open().catch(() => null);
+  }
+  /**
+  * Opens the WebSocket connection. Handles reconnection attempts and updates
+  * the connection state accordingly.
+  */
+  async open() {
+    var e = this;
+    e.allowReconnect = !0, e.connectionState.get().state === "idle" && e.connectionState.next({
+      type: "state",
+      state: "connecting",
+      error: null
+    });
+    try {
+      await e.activeConnection.open();
+    } catch (t) {
+      return e.reconnect(new U({
+        message: "Initialization error",
+        cause: t
+      })), e.reconnecting;
+    }
+  }
+  /**
+  * Closes the WebSocket connection and stops managing requests.
+  * Ensures all outgoing and pending requests are properly finalized.
+  */
+  async close() {
+    var e = this;
+    e.allowReconnect = !1, e.inactivityTimeout.stop();
+    const t = [];
+    for (const r of e.requestManager.getRequests()) r.message.method === "subscription" ? r.callbacks.complete() : r.state === "outgoing" ? r.callbacks.error(_.from(new U({ message: "Closed before connection was established" }))) : t.push(r.end);
+    await Promise.all(t).catch(() => null), await e.activeConnection.close().catch(() => null), e.connectionState.next({
+      type: "state",
+      state: "idle",
+      error: null
+    });
+  }
+  /**
+  * Method to request the server.
+  * Handles data transformation, batching of requests, and subscription lifecycle.
+  *
+  * @param op - The operation details including id, type, path, input and signal
+  * @param transformer - Data transformer for serializing requests and deserializing responses
+  * @param lastEventId - Optional ID of the last received event for subscriptions
+  *
+  * @returns An observable that emits operation results and handles cleanup
+  */
+  request({ op: { id: e, type: t, path: r, input: n, signal: o }, transformer: i, lastEventId: c }) {
+    return E((a) => {
+      const s = this.batchSend({
+        id: e,
+        method: t,
+        params: {
+          input: i.input.serialize(n),
+          path: r,
+          lastEventId: c
+        }
+      }, (0, $.default)((0, $.default)({}, a), {}, { next(u) {
+        const l = he(u, i.output);
+        if (!l.ok) {
+          a.error(_.from(l.error));
+          return;
+        }
+        a.next({ result: l.result });
+      } }));
+      return () => {
+        s(), t === "subscription" && this.activeConnection.isOpen() && this.send({
+          id: e,
+          method: "subscription.stop"
+        }), o?.removeEventListener("abort", s);
+      };
+    });
+  }
+  get connection() {
+    return Dr(this.activeConnection);
+  }
+  reconnect(e) {
+    var t = this;
+    if (this.connectionState.next({
+      type: "state",
+      state: "connecting",
+      error: _.from(e)
+    }), this.reconnecting) return;
+    const r = async (n) => {
+      try {
+        await we(t.reconnectRetryDelay(n)), t.allowReconnect && (await t.activeConnection.close(), await t.activeConnection.open(), t.requestManager.hasPendingRequests() && t.send(t.requestManager.getPendingRequests().map(({ message: o }) => o))), t.reconnecting = null;
+      } catch {
+        await r(n + 1);
+      }
+    };
+    this.reconnecting = r(0);
+  }
+  setupWebSocketListeners(e) {
+    var t = this;
+    const r = (n) => {
+      const o = this.requestManager.getPendingRequests();
+      for (const { message: i, callbacks: c } of o)
+        i.method !== "subscription" && (c.error(_.from(n ?? new U({
+          message: "WebSocket closed",
+          cause: n
+        }))), this.requestManager.delete(i.id));
+    };
+    e.addEventListener("open", () => {
+      I(async () => {
+        var n, o;
+        t.lazyMode && t.inactivityTimeout.start(), (n = (o = t.callbacks).onOpen) === null || n === void 0 || n.call(o), t.connectionState.next({
+          type: "state",
+          state: "pending",
+          error: null
+        });
+      }).catch((n) => {
+        e.close(3e3), r(n);
+      });
+    }), e.addEventListener("message", ({ data: n }) => {
+      if (this.inactivityTimeout.reset(), ["PING", "PONG"].includes(n)) return;
+      const o = this.encoder.decode(n);
+      if ("method" in o) {
+        this.handleIncomingRequest(o);
+        return;
+      }
+      this.handleResponseMessage(o);
+    }), e.addEventListener("close", (n) => {
+      var o, i;
+      r(n), (o = (i = this.callbacks).onClose) === null || o === void 0 || o.call(i, n), (!this.lazyMode || this.requestManager.hasPendingSubscriptions()) && this.reconnect(new U({
+        message: "WebSocket closed",
+        cause: n
+      }));
+    }), e.addEventListener("error", (n) => {
+      var o, i;
+      r(n), (o = (i = this.callbacks).onError) === null || o === void 0 || o.call(i, n), this.reconnect(new U({
+        message: "WebSocket closed",
+        cause: n
+      }));
+    });
+  }
+  handleResponseMessage(e) {
+    const t = this.requestManager.getPendingRequest(e.id);
+    if (!t) return;
+    t.callbacks.next(e);
+    let r = !0;
+    "result" in e && t.message.method === "subscription" && (e.result.type === "data" && (t.message.params.lastEventId = e.result.id), e.result.type !== "stopped" && (r = !1)), r && (t.callbacks.complete(), this.requestManager.delete(e.id));
+  }
+  handleIncomingRequest(e) {
+    e.method === "reconnect" && this.reconnect(new U({ message: "Server requested reconnect" }));
+  }
+  /**
+  * Sends a message or batch of messages directly to the server.
+  */
+  send(e) {
+    if (!this.activeConnection.isOpen()) throw new Error("Active connection is not open");
+    const t = e instanceof Array ? e : [e];
+    this.activeConnection.ws.send(this.encoder.encode(t.length === 1 ? t[0] : t));
+  }
+  /**
+  * Groups requests for batch sending.
+  *
+  * @returns A function to abort the batched request.
+  */
+  batchSend(e, t) {
+    var r = this;
+    return this.inactivityTimeout.reset(), I(async () => {
+      r.activeConnection.isOpen() || await r.open(), await we(0), r.requestManager.hasOutgoingRequests() && r.send(r.requestManager.flush().map(({ message: n }) => n));
+    }).catch((n) => {
+      this.requestManager.delete(e.id), t.error(_.from(n));
+    }), this.requestManager.register(e, t);
+  }
+};
+function on(e) {
+  return new Nr(e);
+}
+function sn(e) {
+  const { client: t } = e, r = ie(e.transformer);
+  return () => ({ op: n }) => E((o) => {
+    const i = n.type === "subscription" ? t.connectionState.subscribe({ next(a) {
+      o.next({
+        result: a,
+        context: n.context
+      });
+    } }) : null, c = t.request({
+      op: n,
+      transformer: r
+    }).subscribe(o);
+    return () => {
+      c.unsubscribe(), i?.unsubscribe();
+    };
+  });
+}
+var de = S(D()), Le = S(k()), lt = class {
+  constructor(e) {
+    (0, de.default)(this, "links", void 0), (0, de.default)(this, "runtime", void 0), (0, de.default)(this, "requestId", void 0), this.requestId = 0, this.runtime = {}, this.links = e.links.map((t) => t(this.runtime));
+  }
+  $request(e) {
+    var t;
+    return He({
+      links: this.links,
+      op: (0, Le.default)((0, Le.default)({}, e), {}, {
+        context: (t = e.context) !== null && t !== void 0 ? t : {},
+        id: ++this.requestId
+      })
+    }).pipe(Ot());
+  }
+  async requestAsPromise(e) {
+    var t = this;
+    try {
+      const r = t.$request(e);
+      return (await jt(r)).result.data;
+    } catch (r) {
+      throw _.from(r);
+    }
+  }
+  query(e, t, r) {
+    return this.requestAsPromise({
+      type: "query",
+      path: e,
+      input: t,
+      context: r?.context,
+      signal: r?.signal
+    });
+  }
+  mutation(e, t, r) {
+    return this.requestAsPromise({
+      type: "mutation",
+      path: e,
+      input: t,
+      context: r?.context,
+      signal: r?.signal
+    });
+  }
+  subscription(e, t, r) {
+    return this.$request({
+      type: "subscription",
+      path: e,
+      input: t,
+      context: r.context,
+      signal: r.signal
+    }).subscribe({
+      next(o) {
+        switch (o.result.type) {
+          case "state": {
+            var i;
+            (i = r.onConnectionStateChange) === null || i === void 0 || i.call(r, o.result);
+            break;
+          }
+          case "started": {
+            var c;
+            (c = r.onStarted) === null || c === void 0 || c.call(r, { context: o.context });
+            break;
+          }
+          case "stopped": {
+            var a;
+            (a = r.onStopped) === null || a === void 0 || a.call(r);
+            break;
+          }
+          case "data":
+          case void 0: {
+            var s;
+            (s = r.onData) === null || s === void 0 || s.call(r, o.result.data);
+            break;
+          }
+        }
+      },
+      error(o) {
+        var i;
+        (i = r.onError) === null || i === void 0 || i.call(r, o);
+      },
+      complete() {
+        var o;
+        (o = r.onComplete) === null || o === void 0 || o.call(r);
+      }
+    });
+  }
+};
+function an(e) {
+  return new lt(e);
+}
+const dt = Symbol.for("trpc_untypedClient"), Ur = {
+  query: "query",
+  mutate: "mutation",
+  subscribe: "subscription"
+}, $r = (e) => Ur[e];
+function zr(e) {
+  const t = mt(({ path: r, args: n }) => {
+    const o = [...r], i = $r(o.pop()), c = o.join(".");
+    return e[i](c, ...n);
+  });
+  return ht((r) => r === dt ? e : t[r]);
+}
+function cn(e) {
+  const t = new lt(e);
+  return zr(t);
+}
+function un(e) {
+  return e[dt];
+}
+var X = S(k());
+function Wr(e) {
+  var t, r;
+  const n = ve(e), o = (t = e.maxURLLength) !== null && t !== void 0 ? t : 1 / 0, i = (r = e.maxItems) !== null && r !== void 0 ? r : 1 / 0;
+  return () => {
+    const c = (l) => ({
+      validate(d) {
+        if (o === 1 / 0 && i === 1 / 0) return !0;
+        if (d.length > i) return !1;
+        const f = d.map((m) => m.path).join(","), p = d.map((m) => m.input);
+        return L((0, X.default)((0, X.default)({}, n), {}, {
+          type: l,
+          path: f,
+          inputs: p,
+          signal: null
+        })).length <= o;
+      },
+      async fetch(d) {
+        var f;
+        const p = d.map((y) => y.path).join(","), h = d.map((y) => y.input), m = it(...d.map((y) => y.signal)), v = new AbortController(), g = await nt((0, X.default)((0, X.default)({}, n), {}, {
+          signal: be(m, v.signal),
+          type: l,
+          contentTypeHeader: "application/json",
+          trpcAcceptHeader: "application/jsonl",
+          trpcAcceptHeaderKey: (f = e.streamHeader) !== null && f !== void 0 ? f : "trpc-accept",
+          getUrl: L,
+          getBody: tt,
+          inputs: h,
+          path: p,
+          headers() {
+            return e.headers ? typeof e.headers == "function" ? e.headers({ opList: d }) : e.headers : {};
+          }
+        }));
+        if (!g.ok) {
+          const y = await g.json();
+          return "error" in y && (y.error = n.transformer.output.deserialize(y.error)), d.map(() => Promise.resolve({
+            json: y,
+            meta: { response: g }
+          }));
+        }
+        const [b] = await sr({
+          from: g.body,
+          deserialize: (y) => n.transformer.output.deserialize(y),
+          formatError(y) {
+            const P = y.error;
+            return _.from({ error: P });
+          },
+          abortController: v
+        });
+        return Object.keys(d).map(async (y) => {
+          let P = await Promise.resolve(b[y]);
+          if ("result" in P) {
+            const A = await Promise.resolve(P.result);
+            P = { result: { data: await Promise.resolve(A.data) } };
+          }
+          return {
+            json: P,
+            meta: { response: g }
+          };
+        });
+      }
+    }), a = ne(c("query")), s = ne(c("mutation")), u = {
+      query: a,
+      mutation: s
+    };
+    return ({ op: l }) => E((d) => {
+      /* istanbul ignore if -- @preserve */
+      if (l.type === "subscription") throw new Error("Subscriptions are unsupported by `httpBatchStreamLink` - use `httpSubscriptionLink` or `wsLink`");
+      const p = u[l.type].load(l);
+      let h;
+      return p.then((m) => {
+        if (h = m, "error" in m.json) {
+          d.error(_.from(m.json, { meta: m.meta }));
+          return;
+        } else if ("result" in m.json) {
+          d.next({
+            context: m.meta,
+            result: m.json.result
+          }), d.complete();
+          return;
+        }
+        d.complete();
+      }).catch((m) => {
+        d.error(_.from(m, { meta: h?.meta }));
+      }), () => {
+      };
+    });
+  };
+}
+const ln = Wr;
+var De = S(k());
+function ge(e, t) {
+  return !t || e != null && typeof e != "object" ? e : (0, De.default)((0, De.default)({}, e ?? {}), {}, { lastEventId: t });
+}
+var Gr = T({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/asyncIterator.js"(e, t) {
+  function r(o) {
+    var i, c, a, s = 2;
+    for (typeof Symbol < "u" && (c = Symbol.asyncIterator, a = Symbol.iterator); s--; ) {
+      if (c && (i = o[c]) != null) return i.call(o);
+      if (a && (i = o[a]) != null) return new n(i.call(o));
+      c = "@@asyncIterator", a = "@@iterator";
+    }
+    throw new TypeError("Object is not async iterable");
+  }
+  function n(o) {
+    function i(c) {
+      if (Object(c) !== c) return Promise.reject(new TypeError(c + " is not an object."));
+      var a = c.done;
+      return Promise.resolve(c.value).then(function(s) {
+        return {
+          value: s,
+          done: a
+        };
+      });
+    }
+    return n = function(a) {
+      this.s = a, this.n = a.next;
+    }, n.prototype = {
+      s: null,
+      n: null,
+      next: function() {
+        return i(this.n.apply(this.s, arguments));
+      },
+      return: function(a) {
+        var s = this.s.return;
+        return s === void 0 ? Promise.resolve({
+          value: a,
+          done: !0
+        }) : i(s.apply(this.s, arguments));
+      },
+      throw: function(a) {
+        var s = this.s.return;
+        return s === void 0 ? Promise.reject(a) : i(s.apply(this.s, arguments));
+      }
+    }, new n(o);
+  }
+  t.exports = r, t.exports.__esModule = !0, t.exports.default = t.exports;
+} }), Br = S(Gr());
+async function Fr(e) {
+  let t = await F(e.url);
+  if (e.connectionParams) {
+    const r = await F(e.connectionParams), n = t.includes("?") ? "&" : "?";
+    t += n + "connectionParams=" + encodeURIComponent(JSON.stringify(r));
+  }
+  return t;
+}
+function Hr(e) {
+  const t = ie(e.transformer);
+  return () => ({ op: r }) => E((n) => {
+    var o;
+    const { type: i, path: c, input: a } = r;
+    /* istanbul ignore if -- @preserve */
+    if (i !== "subscription") throw new Error("httpSubscriptionLink only supports subscriptions");
+    let s;
+    const u = new AbortController(), l = be(r.signal, u.signal), d = pr({
+      url: async () => L({
+        transformer: t,
+        url: await Fr(e),
+        input: ge(a, s),
+        path: c,
+        type: i,
+        signal: null
+      }),
+      init: () => F(e.eventSourceOptions, { op: r }),
+      signal: l,
+      deserialize: (h) => t.output.deserialize(h),
+      EventSource: (o = e.EventSource) !== null && o !== void 0 ? o : globalThis.EventSource
+    }), f = se({
+      type: "state",
+      state: "connecting",
+      error: null
+    }), p = f.subscribe({ next(h) {
+      n.next({ result: h });
+    } });
+    return I(async () => {
+      var h = !1, m = !1, v;
+      try {
+        for (var x = (0, Br.default)(d), g; h = !(g = await x.next()).done; h = !1) {
+          const b = g.value;
+          switch (b.type) {
+            case "ping":
+              break;
+            case "data":
+              const j = b.data;
+              let y;
+              j.id ? (s = j.id, y = {
+                id: j.id,
+                data: j
+              }) : y = { data: j.data }, n.next({
+                result: y,
+                context: { eventSource: b.eventSource }
+              });
+              break;
+            case "connected": {
+              n.next({
+                result: { type: "started" },
+                context: { eventSource: b.eventSource }
+              }), f.next({
+                type: "state",
+                state: "pending",
+                error: null
+              });
+              break;
+            }
+            case "serialized-error": {
+              const P = _.from({ error: b.error });
+              if (We.includes(b.error.code)) {
+                f.next({
+                  type: "state",
+                  state: "connecting",
+                  error: P
+                });
+                break;
+              }
+              throw P;
+            }
+            case "connecting": {
+              const P = f.get(), A = b.event && _.from(b.event);
+              if (!A && P.state === "connecting") break;
+              f.next({
+                type: "state",
+                state: "connecting",
+                error: A
+              });
+              break;
+            }
+            case "timeout":
+              f.next({
+                type: "state",
+                state: "connecting",
+                error: new _(`Timeout of ${b.ms}ms reached while waiting for a response`)
+              });
+          }
+        }
+      } catch (b) {
+        m = !0, v = b;
+      } finally {
+        try {
+          h && x.return != null && await x.return();
+        } finally {
+          if (m) throw v;
+        }
+      }
+      n.next({ result: { type: "stopped" } }), f.next({
+        type: "state",
+        state: "idle",
+        error: null
+      }), n.complete();
+    }).catch((h) => {
+      n.error(_.from(h));
+    }), () => {
+      n.complete(), u.abort(), p.unsubscribe();
+    };
+  });
+}
+const dn = Hr;
+var Ne = S(k());
+function fn(e) {
+  return () => (t) => E((r) => {
+    let n, o, i;
+    a(1);
+    function c() {
+      const s = t.op;
+      return i ? (0, Ne.default)((0, Ne.default)({}, s), {}, { input: ge(s.input, i) }) : s;
+    }
+    function a(s) {
+      const u = c();
+      n = t.next(u).subscribe({
+        error(l) {
+          var d, f;
+          if (!e.retry({
+            op: u,
+            attempts: s,
+            error: l
+          })) {
+            r.error(l);
+            return;
+          }
+          const h = (d = (f = e.retryDelayMs) === null || f === void 0 ? void 0 : f.call(e, s)) !== null && d !== void 0 ? d : 0;
+          if (h <= 0) {
+            a(s + 1);
+            return;
+          }
+          o = setTimeout(() => a(s + 1), h);
+        },
+        next(l) {
+          (!l.result.type || l.result.type === "data") && l.result.id && (i = l.result.id), r.next(l);
+        },
+        complete() {
+          r.complete();
+        }
+      });
+    }
+    return () => {
+      n.unsubscribe(), clearTimeout(o);
+    };
+  });
+}
+var Jr = T({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/usingCtx.js"(e, t) {
+  function r() {
+    var n = typeof SuppressedError == "function" ? SuppressedError : function(a, s) {
+      var u = Error();
+      return u.name = "SuppressedError", u.error = a, u.suppressed = s, u;
+    }, o = {}, i = [];
+    function c(a, s) {
+      if (s != null) {
+        if (Object(s) !== s) throw new TypeError("using declarations can only be used with objects, functions, null, or undefined.");
+        if (a) var u = s[Symbol.asyncDispose || Symbol.for("Symbol.asyncDispose")];
+        if (u === void 0 && (u = s[Symbol.dispose || Symbol.for("Symbol.dispose")], a)) var l = u;
+        if (typeof u != "function") throw new TypeError("Object is not disposable.");
+        l && (u = function() {
+          try {
+            l.call(s);
+          } catch (f) {
+            return Promise.reject(f);
+          }
+        }), i.push({
+          v: s,
+          d: u,
+          a
+        });
+      } else a && i.push({
+        d: s,
+        a
+      });
+      return s;
+    }
+    return {
+      e: o,
+      u: c.bind(null, !1),
+      a: c.bind(null, !0),
+      d: function() {
+        var s, u = this.e, l = 0;
+        function d() {
+          for (; s = i.pop(); ) try {
+            if (!s.a && l === 1) return l = 0, i.push(s), Promise.resolve().then(d);
+            if (s.d) {
+              var p = s.d.call(s.v);
+              if (s.a) return l |= 2, Promise.resolve(p).then(d, f);
+            } else l |= 1;
+          } catch (h) {
+            return f(h);
+          }
+          if (l === 1) return u !== o ? Promise.reject(u) : Promise.resolve();
+          if (u !== o) throw u;
+        }
+        function f(p) {
+          return u = u !== o ? new n(p, u) : p, d();
+        }
+        return d();
+      }
+    };
+  }
+  t.exports = r, t.exports.__esModule = !0, t.exports.default = t.exports;
+} }), ft = T({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/OverloadYield.js"(e, t) {
+  function r(n, o) {
+    this.v = n, this.k = o;
+  }
+  t.exports = r, t.exports.__esModule = !0, t.exports.default = t.exports;
+} }), Yr = T({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/awaitAsyncGenerator.js"(e, t) {
+  var r = ft();
+  function n(o) {
+    return new r(o, 0);
+  }
+  t.exports = n, t.exports.__esModule = !0, t.exports.default = t.exports;
+} }), Kr = T({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/wrapAsyncGenerator.js"(e, t) {
+  var r = ft();
+  function n(i) {
+    return function() {
+      return new o(i.apply(this, arguments));
+    };
+  }
+  function o(i) {
+    var c, a;
+    function s(l, d) {
+      try {
+        var f = i[l](d), p = f.value, h = p instanceof r;
+        Promise.resolve(h ? p.v : p).then(function(m) {
+          if (h) {
+            var v = l === "return" ? "return" : "next";
+            if (!p.k || m.done) return s(v, m);
+            m = i[v](m).value;
+          }
+          u(f.done ? "return" : "normal", m);
+        }, function(m) {
+          s("throw", m);
+        });
+      } catch (m) {
+        u("throw", m);
+      }
+    }
+    function u(l, d) {
+      switch (l) {
+        case "return":
+          c.resolve({
+            value: d,
+            done: !0
+          });
+          break;
+        case "throw":
+          c.reject(d);
+          break;
+        default:
+          c.resolve({
+            value: d,
+            done: !1
+          });
+      }
+      (c = c.next) ? s(c.key, c.arg) : a = null;
+    }
+    this._invoke = function(l, d) {
+      return new Promise(function(f, p) {
+        var h = {
+          key: l,
+          arg: d,
+          resolve: f,
+          reject: p,
+          next: null
+        };
+        a ? a = a.next = h : (c = a = h, s(l, d));
+      });
+    }, typeof i.return != "function" && (this.return = void 0);
+  }
+  o.prototype[typeof Symbol == "function" && Symbol.asyncIterator || "@@asyncIterator"] = function() {
+    return this;
+  }, o.prototype.next = function(i) {
+    return this._invoke("next", i);
+  }, o.prototype.throw = function(i) {
+    return this._invoke("throw", i);
+  }, o.prototype.return = function(i) {
+    return this._invoke("return", i);
+  }, t.exports = n, t.exports.__esModule = !0, t.exports.default = t.exports;
+} }), fe = S(Jr()), Ue = S(Yr()), Vr = S(Kr()), $e = S(k());
+function Zr(e) {
+  const t = ie(e.transformer), r = (n) => {
+    if (e.transformer || n === void 0) return n;
+    const o = JSON.stringify(t.input.serialize(n));
+    return JSON.parse(t.output.deserialize(o));
+  };
+  return () => ({ op: n }) => E((o) => {
+    let i;
+    const c = new AbortController(), a = be(n.signal, c.signal), s = Sr(a);
+    s.catch(() => {
+    });
+    let u = n.input;
+    async function l(p) {
+      return u = p, i = await e.createContext(), It({
+        router: e.router,
+        path: n.path,
+        getRawInput: async () => p,
+        ctx: i,
+        type: n.type,
+        signal: a,
+        batchIndex: 0
+      });
+    }
+    function d(p) {
+      var h;
+      Pe(p) || (h = e.onError) === null || h === void 0 || h.call(e, {
+        error: ae(p),
+        type: n.type,
+        path: n.path,
+        input: u,
+        ctx: i
+      });
+    }
+    function f(p) {
+      if (Xe(p)) return p;
+      const h = ae(p), m = vt({
+        config: e.router._def._config,
+        ctx: i,
+        error: h,
+        input: u,
+        path: n.path,
+        type: n.type
+      });
+      return _.from({ error: r(m) }, { cause: p instanceof Error ? p : void 0 });
+    }
+    return I(async () => {
+      switch (n.type) {
+        case "query":
+        case "mutation": {
+          const m = await l(n.input);
+          if (!xe(m)) {
+            o.next({ result: { data: r(m) } }), o.complete();
+            break;
+          }
+          o.next({ result: { data: (0, Vr.default)(function* () {
+            try {
+              var v = (0, fe.default)();
+              const x = v.a(Re(m)), g = v.u(re({}, () => {
+                o.complete();
+              }));
+              try {
+                for (; ; ) {
+                  const b = yield (0, Ue.default)(Promise.race([x.next(), s]));
+                  if (b.done) return r(b.value);
+                  yield r(b.value);
+                }
+              } catch (b) {
+                throw d(b), f(b);
+              }
+            } catch (x) {
+              v.e = x;
+            } finally {
+              yield (0, Ue.default)(v.d());
+            }
+          })() } });
+          break;
+        }
+        case "subscription":
+          try {
+            var p = (0, fe.default)();
+            const m = se({
+              type: "state",
+              state: "connecting",
+              error: null
+            }), v = m.subscribe({ next(b) {
+              o.next({ result: b });
+            } });
+            let x;
+            const g = p.u(re({}, async () => {
+              o.complete(), m.next({
+                type: "state",
+                state: "idle",
+                error: null
+              }), v.unsubscribe();
+            }));
+            for (; ; ) try {
+              var h = (0, fe.default)();
+              const b = await l(ge(n.input, x));
+              if (!xe(b)) throw new Error("Expected an async iterable");
+              const j = h.a(Re(b));
+              for (o.next({ result: { type: "started" } }), m.next({
+                type: "state",
+                state: "pending",
+                error: null
+              }); ; ) {
+                let y;
+                try {
+                  y = await Promise.race([j.next(), s]);
+                } catch (A) {
+                  if (Pe(A)) return;
+                  const Y = ae(A);
+                  if (!We.includes(yt[Y.code])) throw f(Y);
+                  d(Y), m.next({
+                    type: "state",
+                    state: "connecting",
+                    error: f(Y)
+                  });
+                  break;
+                }
+                if (y.done) return;
+                let P;
+                Dt(y.value) ? (x = y.value[0], P = {
+                  id: y.value[0],
+                  data: {
+                    id: y.value[0],
+                    data: y.value[1]
+                  }
+                }) : P = { data: y.value }, o.next({ result: (0, $e.default)((0, $e.default)({}, P), {}, { data: r(P.data) }) });
+              }
+            } catch (b) {
+              h.e = b;
+            } finally {
+              await h.d();
+            }
+            break;
+          } catch (m) {
+            p.e = m;
+          } finally {
+            p.d();
+          }
+      }
+    }).catch((p) => {
+      d(p), o.error(f(p));
+    }), () => {
+      c.abort();
+    };
+  });
+}
+const pn = Zr;
+export {
+  _ as TRPCClientError,
+  lt as TRPCUntypedClient,
+  $r as clientCallTypeToProcedureType,
+  cn as createTRPCClient,
+  zr as createTRPCClientProxy,
+  cn as createTRPCProxyClient,
+  an as createTRPCUntypedClient,
+  on as createWSClient,
+  pn as experimental_localLink,
+  yr as getFetch,
+  un as getUntypedClient,
+  rn as httpBatchLink,
+  Wr as httpBatchStreamLink,
+  tn as httpLink,
+  Hr as httpSubscriptionLink,
+  st as isFormData,
+  en as isNonJsonSerializable,
+  ot as isOctetType,
+  Xe as isTRPCClientError,
+  jr as jsonEncoder,
+  nn as loggerLink,
+  fn as retryLink,
+  Xr as splitLink,
+  ln as unstable_httpBatchStreamLink,
+  dn as unstable_httpSubscriptionLink,
+  Zr as unstable_localLink,
+  sn as wsLink
+};