@shiftengineering/folio 0.0.76

package/dist-embed-component/folio-embed.js

@@ -0,0 +1,2259 @@
+import * as vr from "react";
+import bt, { createContext as Er, useState as Ee, useEffect as Pr, useContext as Rr } from "react";
+var Pe = { exports: {} }, Y = {};
+/**
+ * @license React
+ * react-jsx-runtime.production.min.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var et;
+function Tr() {
+  if (et) return Y;
+  et = 1;
+  var e = bt, t = Symbol.for("react.element"), r = Symbol.for("react.fragment"), n = Object.prototype.hasOwnProperty, i = e.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.ReactCurrentOwner, s = { key: !0, ref: !0, __self: !0, __source: !0 };
+  function u(l, a, f) {
+    var m, p = {}, h = null, b = null;
+    f !== void 0 && (h = "" + f), a.key !== void 0 && (h = "" + a.key), a.ref !== void 0 && (b = a.ref);
+    for (m in a) n.call(a, m) && !s.hasOwnProperty(m) && (p[m] = a[m]);
+    if (l && l.defaultProps) for (m in a = l.defaultProps, a) p[m] === void 0 && (p[m] = a[m]);
+    return { $$typeof: t, type: l, key: h, ref: b, props: p, _owner: i.current };
+  }
+  return Y.Fragment = r, Y.jsx = u, Y.jsxs = u, Y;
+}
+var H = {};
+/**
+ * @license React
+ * react-jsx-runtime.development.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var tt;
+function Or() {
+  return tt || (tt = 1, process.env.NODE_ENV !== "production" && function() {
+    var e = bt, t = Symbol.for("react.element"), r = Symbol.for("react.portal"), n = Symbol.for("react.fragment"), i = Symbol.for("react.strict_mode"), s = Symbol.for("react.profiler"), u = Symbol.for("react.provider"), l = Symbol.for("react.context"), a = Symbol.for("react.forward_ref"), f = Symbol.for("react.suspense"), m = Symbol.for("react.suspense_list"), p = Symbol.for("react.memo"), h = Symbol.for("react.lazy"), b = Symbol.for("react.offscreen"), x = Symbol.iterator, P = "@@iterator";
+    function U(o) {
+      if (o === null || typeof o != "object")
+        return null;
+      var c = x && o[x] || o[P];
+      return typeof c == "function" ? c : null;
+    }
+    var j = e.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+    function S(o) {
+      {
+        for (var c = arguments.length, d = new Array(c > 1 ? c - 1 : 0), y = 1; y < c; y++)
+          d[y - 1] = arguments[y];
+        Ut("error", o, d);
+      }
+    }
+    function Ut(o, c, d) {
+      {
+        var y = j.ReactDebugCurrentFrame, E = y.getStackAddendum();
+        E !== "" && (c += "%s", d = d.concat([E]));
+        var R = d.map(function(v) {
+          return String(v);
+        });
+        R.unshift("Warning: " + c), Function.prototype.apply.call(console[o], console, R);
+      }
+    }
+    var Vt = !1, qt = !1, zt = !1, Mt = !1, Wt = !1, ke;
+    ke = Symbol.for("react.module.reference");
+    function Bt(o) {
+      return !!(typeof o == "string" || typeof o == "function" || o === n || o === s || Wt || o === i || o === f || o === m || Mt || o === b || Vt || qt || zt || typeof o == "object" && o !== null && (o.$$typeof === h || o.$$typeof === p || o.$$typeof === u || o.$$typeof === l || o.$$typeof === a || // This needs to include all possible module reference object
+      // types supported by any Flight configuration anywhere since
+      // we don't know which Flight build this will end up being used
+      // with.
+      o.$$typeof === ke || o.getModuleId !== void 0));
+    }
+    function Kt(o, c, d) {
+      var y = o.displayName;
+      if (y)
+        return y;
+      var E = c.displayName || c.name || "";
+      return E !== "" ? d + "(" + E + ")" : d;
+    }
+    function Ce(o) {
+      return o.displayName || "Context";
+    }
+    function I(o) {
+      if (o == null)
+        return null;
+      if (typeof o.tag == "number" && S("Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue."), typeof o == "function")
+        return o.displayName || o.name || null;
+      if (typeof o == "string")
+        return o;
+      switch (o) {
+        case n:
+          return "Fragment";
+        case r:
+          return "Portal";
+        case s:
+          return "Profiler";
+        case i:
+          return "StrictMode";
+        case f:
+          return "Suspense";
+        case m:
+          return "SuspenseList";
+      }
+      if (typeof o == "object")
+        switch (o.$$typeof) {
+          case l:
+            var c = o;
+            return Ce(c) + ".Consumer";
+          case u:
+            var d = o;
+            return Ce(d._context) + ".Provider";
+          case a:
+            return Kt(o, o.render, "ForwardRef");
+          case p:
+            var y = o.displayName || null;
+            return y !== null ? y : I(o.type) || "Memo";
+          case h: {
+            var E = o, R = E._payload, v = E._init;
+            try {
+              return I(v(R));
+            } catch {
+              return null;
+            }
+          }
+        }
+      return null;
+    }
+    var $ = Object.assign, B = 0, je, Ae, Ie, Fe, De, $e, Ne;
+    function Le() {
+    }
+    Le.__reactDisabledLog = !0;
+    function Yt() {
+      {
+        if (B === 0) {
+          je = console.log, Ae = console.info, Ie = console.warn, Fe = console.error, De = console.group, $e = console.groupCollapsed, Ne = console.groupEnd;
+          var o = {
+            configurable: !0,
+            enumerable: !0,
+            value: Le,
+            writable: !0
+          };
+          Object.defineProperties(console, {
+            info: o,
+            log: o,
+            warn: o,
+            error: o,
+            group: o,
+            groupCollapsed: o,
+            groupEnd: o
+          });
+        }
+        B++;
+      }
+    }
+    function Ht() {
+      {
+        if (B--, B === 0) {
+          var o = {
+            configurable: !0,
+            enumerable: !0,
+            writable: !0
+          };
+          Object.defineProperties(console, {
+            log: $({}, o, {
+              value: je
+            }),
+            info: $({}, o, {
+              value: Ae
+            }),
+            warn: $({}, o, {
+              value: Ie
+            }),
+            error: $({}, o, {
+              value: Fe
+            }),
+            group: $({}, o, {
+              value: De
+            }),
+            groupCollapsed: $({}, o, {
+              value: $e
+            }),
+            groupEnd: $({}, o, {
+              value: Ne
+            })
+          });
+        }
+        B < 0 && S("disabledDepth fell below zero. This is a bug in React. Please file an issue.");
+      }
+    }
+    var ue = j.ReactCurrentDispatcher, ce;
+    function ee(o, c, d) {
+      {
+        if (ce === void 0)
+          try {
+            throw Error();
+          } catch (E) {
+            var y = E.stack.trim().match(/\n( *(at )?)/);
+            ce = y && y[1] || "";
+          }
+        return `
+` + ce + o;
+      }
+    }
+    var le = !1, te;
+    {
+      var Gt = typeof WeakMap == "function" ? WeakMap : Map;
+      te = new Gt();
+    }
+    function Ue(o, c) {
+      if (!o || le)
+        return "";
+      {
+        var d = te.get(o);
+        if (d !== void 0)
+          return d;
+      }
+      var y;
+      le = !0;
+      var E = Error.prepareStackTrace;
+      Error.prepareStackTrace = void 0;
+      var R;
+      R = ue.current, ue.current = null, Yt();
+      try {
+        if (c) {
+          var v = function() {
+            throw Error();
+          };
+          if (Object.defineProperty(v.prototype, "props", {
+            set: function() {
+              throw Error();
+            }
+          }), typeof Reflect == "object" && Reflect.construct) {
+            try {
+              Reflect.construct(v, []);
+            } catch (k) {
+              y = k;
+            }
+            Reflect.construct(o, [], v);
+          } else {
+            try {
+              v.call();
+            } catch (k) {
+              y = k;
+            }
+            o.call(v.prototype);
+          }
+        } else {
+          try {
+            throw Error();
+          } catch (k) {
+            y = k;
+          }
+          o();
+        }
+      } catch (k) {
+        if (k && y && typeof k.stack == "string") {
+          for (var g = k.stack.split(`
+`), _ = y.stack.split(`
+`), T = g.length - 1, O = _.length - 1; T >= 1 && O >= 0 && g[T] !== _[O]; )
+            O--;
+          for (; T >= 1 && O >= 0; T--, O--)
+            if (g[T] !== _[O]) {
+              if (T !== 1 || O !== 1)
+                do
+                  if (T--, O--, O < 0 || g[T] !== _[O]) {
+                    var C = `
+` + g[T].replace(" at new ", " at ");
+                    return o.displayName && C.includes("<anonymous>") && (C = C.replace("<anonymous>", o.displayName)), typeof o == "function" && te.set(o, C), C;
+                  }
+                while (T >= 1 && O >= 0);
+              break;
+            }
+        }
+      } finally {
+        le = !1, ue.current = R, Ht(), Error.prepareStackTrace = E;
+      }
+      var q = o ? o.displayName || o.name : "", N = q ? ee(q) : "";
+      return typeof o == "function" && te.set(o, N), N;
+    }
+    function Xt(o, c, d) {
+      return Ue(o, !1);
+    }
+    function Jt(o) {
+      var c = o.prototype;
+      return !!(c && c.isReactComponent);
+    }
+    function re(o, c, d) {
+      if (o == null)
+        return "";
+      if (typeof o == "function")
+        return Ue(o, Jt(o));
+      if (typeof o == "string")
+        return ee(o);
+      switch (o) {
+        case f:
+          return ee("Suspense");
+        case m:
+          return ee("SuspenseList");
+      }
+      if (typeof o == "object")
+        switch (o.$$typeof) {
+          case a:
+            return Xt(o.render);
+          case p:
+            return re(o.type, c, d);
+          case h: {
+            var y = o, E = y._payload, R = y._init;
+            try {
+              return re(R(E), c, d);
+            } catch {
+            }
+          }
+        }
+      return "";
+    }
+    var K = Object.prototype.hasOwnProperty, Ve = {}, qe = j.ReactDebugCurrentFrame;
+    function ne(o) {
+      if (o) {
+        var c = o._owner, d = re(o.type, o._source, c ? c.type : null);
+        qe.setExtraStackFrame(d);
+      } else
+        qe.setExtraStackFrame(null);
+    }
+    function Zt(o, c, d, y, E) {
+      {
+        var R = Function.call.bind(K);
+        for (var v in o)
+          if (R(o, v)) {
+            var g = void 0;
+            try {
+              if (typeof o[v] != "function") {
+                var _ = Error((y || "React class") + ": " + d + " type `" + v + "` is invalid; it must be a function, usually from the `prop-types` package, but received `" + typeof o[v] + "`.This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`.");
+                throw _.name = "Invariant Violation", _;
+              }
+              g = o[v](c, v, y, d, null, "SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED");
+            } catch (T) {
+              g = T;
+            }
+            g && !(g instanceof Error) && (ne(E), S("%s: type specification of %s `%s` is invalid; the type checker function must return `null` or an `Error` but returned a %s. You may have forgotten to pass an argument to the type checker creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and shape all require an argument).", y || "React class", d, v, typeof g), ne(null)), g instanceof Error && !(g.message in Ve) && (Ve[g.message] = !0, ne(E), S("Failed %s type: %s", d, g.message), ne(null));
+          }
+      }
+    }
+    var Qt = Array.isArray;
+    function fe(o) {
+      return Qt(o);
+    }
+    function er(o) {
+      {
+        var c = typeof Symbol == "function" && Symbol.toStringTag, d = c && o[Symbol.toStringTag] || o.constructor.name || "Object";
+        return d;
+      }
+    }
+    function tr(o) {
+      try {
+        return ze(o), !1;
+      } catch {
+        return !0;
+      }
+    }
+    function ze(o) {
+      return "" + o;
+    }
+    function Me(o) {
+      if (tr(o))
+        return S("The provided key is an unsupported type %s. This value must be coerced to a string before before using it here.", er(o)), ze(o);
+    }
+    var We = j.ReactCurrentOwner, rr = {
+      key: !0,
+      ref: !0,
+      __self: !0,
+      __source: !0
+    }, Be, Ke;
+    function nr(o) {
+      if (K.call(o, "ref")) {
+        var c = Object.getOwnPropertyDescriptor(o, "ref").get;
+        if (c && c.isReactWarning)
+          return !1;
+      }
+      return o.ref !== void 0;
+    }
+    function or(o) {
+      if (K.call(o, "key")) {
+        var c = Object.getOwnPropertyDescriptor(o, "key").get;
+        if (c && c.isReactWarning)
+          return !1;
+      }
+      return o.key !== void 0;
+    }
+    function ir(o, c) {
+      typeof o.ref == "string" && We.current;
+    }
+    function sr(o, c) {
+      {
+        var d = function() {
+          Be || (Be = !0, S("%s: `key` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://reactjs.org/link/special-props)", c));
+        };
+        d.isReactWarning = !0, Object.defineProperty(o, "key", {
+          get: d,
+          configurable: !0
+        });
+      }
+    }
+    function ar(o, c) {
+      {
+        var d = function() {
+          Ke || (Ke = !0, S("%s: `ref` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://reactjs.org/link/special-props)", c));
+        };
+        d.isReactWarning = !0, Object.defineProperty(o, "ref", {
+          get: d,
+          configurable: !0
+        });
+      }
+    }
+    var ur = function(o, c, d, y, E, R, v) {
+      var g = {
+        // This tag allows us to uniquely identify this as a React Element
+        $$typeof: t,
+        // Built-in properties that belong on the element
+        type: o,
+        key: c,
+        ref: d,
+        props: v,
+        // Record the component responsible for creating this element.
+        _owner: R
+      };
+      return g._store = {}, Object.defineProperty(g._store, "validated", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !0,
+        value: !1
+      }), Object.defineProperty(g, "_self", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !1,
+        value: y
+      }), Object.defineProperty(g, "_source", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !1,
+        value: E
+      }), Object.freeze && (Object.freeze(g.props), Object.freeze(g)), g;
+    };
+    function cr(o, c, d, y, E) {
+      {
+        var R, v = {}, g = null, _ = null;
+        d !== void 0 && (Me(d), g = "" + d), or(c) && (Me(c.key), g = "" + c.key), nr(c) && (_ = c.ref, ir(c, E));
+        for (R in c)
+          K.call(c, R) && !rr.hasOwnProperty(R) && (v[R] = c[R]);
+        if (o && o.defaultProps) {
+          var T = o.defaultProps;
+          for (R in T)
+            v[R] === void 0 && (v[R] = T[R]);
+        }
+        if (g || _) {
+          var O = typeof o == "function" ? o.displayName || o.name || "Unknown" : o;
+          g && sr(v, O), _ && ar(v, O);
+        }
+        return ur(o, g, _, E, y, We.current, v);
+      }
+    }
+    var de = j.ReactCurrentOwner, Ye = j.ReactDebugCurrentFrame;
+    function V(o) {
+      if (o) {
+        var c = o._owner, d = re(o.type, o._source, c ? c.type : null);
+        Ye.setExtraStackFrame(d);
+      } else
+        Ye.setExtraStackFrame(null);
+    }
+    var me;
+    me = !1;
+    function pe(o) {
+      return typeof o == "object" && o !== null && o.$$typeof === t;
+    }
+    function He() {
+      {
+        if (de.current) {
+          var o = I(de.current.type);
+          if (o)
+            return `
+
+Check the render method of \`` + o + "`.";
+        }
+        return "";
+      }
+    }
+    function lr(o) {
+      return "";
+    }
+    var Ge = {};
+    function fr(o) {
+      {
+        var c = He();
+        if (!c) {
+          var d = typeof o == "string" ? o : o.displayName || o.name;
+          d && (c = `
+
+Check the top-level render call using <` + d + ">.");
+        }
+        return c;
+      }
+    }
+    function Xe(o, c) {
+      {
+        if (!o._store || o._store.validated || o.key != null)
+          return;
+        o._store.validated = !0;
+        var d = fr(c);
+        if (Ge[d])
+          return;
+        Ge[d] = !0;
+        var y = "";
+        o && o._owner && o._owner !== de.current && (y = " It was passed a child from " + I(o._owner.type) + "."), V(o), S('Each child in a list should have a unique "key" prop.%s%s See https://reactjs.org/link/warning-keys for more information.', d, y), V(null);
+      }
+    }
+    function Je(o, c) {
+      {
+        if (typeof o != "object")
+          return;
+        if (fe(o))
+          for (var d = 0; d < o.length; d++) {
+            var y = o[d];
+            pe(y) && Xe(y, c);
+          }
+        else if (pe(o))
+          o._store && (o._store.validated = !0);
+        else if (o) {
+          var E = U(o);
+          if (typeof E == "function" && E !== o.entries)
+            for (var R = E.call(o), v; !(v = R.next()).done; )
+              pe(v.value) && Xe(v.value, c);
+        }
+      }
+    }
+    function dr(o) {
+      {
+        var c = o.type;
+        if (c == null || typeof c == "string")
+          return;
+        var d;
+        if (typeof c == "function")
+          d = c.propTypes;
+        else if (typeof c == "object" && (c.$$typeof === a || // Note: Memo only checks outer props here.
+        // Inner props are checked in the reconciler.
+        c.$$typeof === p))
+          d = c.propTypes;
+        else
+          return;
+        if (d) {
+          var y = I(c);
+          Zt(d, o.props, "prop", y, o);
+        } else if (c.PropTypes !== void 0 && !me) {
+          me = !0;
+          var E = I(c);
+          S("Component %s declared `PropTypes` instead of `propTypes`. Did you misspell the property assignment?", E || "Unknown");
+        }
+        typeof c.getDefaultProps == "function" && !c.getDefaultProps.isReactClassApproved && S("getDefaultProps is only used on classic React.createClass definitions. Use a static property named `defaultProps` instead.");
+      }
+    }
+    function mr(o) {
+      {
+        for (var c = Object.keys(o.props), d = 0; d < c.length; d++) {
+          var y = c[d];
+          if (y !== "children" && y !== "key") {
+            V(o), S("Invalid prop `%s` supplied to `React.Fragment`. React.Fragment can only have `key` and `children` props.", y), V(null);
+            break;
+          }
+        }
+        o.ref !== null && (V(o), S("Invalid attribute `ref` supplied to `React.Fragment`."), V(null));
+      }
+    }
+    var Ze = {};
+    function Qe(o, c, d, y, E, R) {
+      {
+        var v = Bt(o);
+        if (!v) {
+          var g = "";
+          (o === void 0 || typeof o == "object" && o !== null && Object.keys(o).length === 0) && (g += " You likely forgot to export your component from the file it's defined in, or you might have mixed up default and named imports.");
+          var _ = lr();
+          _ ? g += _ : g += He();
+          var T;
+          o === null ? T = "null" : fe(o) ? T = "array" : o !== void 0 && o.$$typeof === t ? (T = "<" + (I(o.type) || "Unknown") + " />", g = " Did you accidentally export a JSX literal instead of a component?") : T = typeof o, S("React.jsx: type is invalid -- expected a string (for built-in components) or a class/function (for composite components) but got: %s.%s", T, g);
+        }
+        var O = cr(o, c, d, E, R);
+        if (O == null)
+          return O;
+        if (v) {
+          var C = c.children;
+          if (C !== void 0)
+            if (y)
+              if (fe(C)) {
+                for (var q = 0; q < C.length; q++)
+                  Je(C[q], o);
+                Object.freeze && Object.freeze(C);
+              } else
+                S("React.jsx: Static children should always be an array. You are likely explicitly calling React.jsxs or React.jsxDEV. Use the Babel transform instead.");
+            else
+              Je(C, o);
+        }
+        if (K.call(c, "key")) {
+          var N = I(o), k = Object.keys(c).filter(function(wr) {
+            return wr !== "key";
+          }), ye = k.length > 0 ? "{key: someKey, " + k.join(": ..., ") + ": ...}" : "{key: someKey}";
+          if (!Ze[N + ye]) {
+            var br = k.length > 0 ? "{" + k.join(": ..., ") + ": ...}" : "{}";
+            S(`A props object containing a "key" prop is being spread into JSX:
+  let props = %s;
+  <%s {...props} />
+React keys must be passed directly to JSX without using spread:
+  let props = %s;
+  <%s key={someKey} {...props} />`, ye, N, br, N), Ze[N + ye] = !0;
+          }
+        }
+        return o === n ? mr(O) : dr(O), O;
+      }
+    }
+    function pr(o, c, d) {
+      return Qe(o, c, d, !0);
+    }
+    function yr(o, c, d) {
+      return Qe(o, c, d, !1);
+    }
+    var hr = yr, gr = pr;
+    H.Fragment = n, H.jsx = hr, H.jsxs = gr;
+  }()), H;
+}
+process.env.NODE_ENV === "production" ? Pe.exports = Tr() : Pe.exports = Or();
+var Re = Pe.exports, _e = /* @__PURE__ */ ((e) => (e.PDF = "application/pdf", e.TXT = "text/plain", e.CSV = "text/csv", e))(_e || {});
+const he = 4e3 * 1024 * 1024, Sr = [
+  ".txt",
+  ".json",
+  ".py",
+  ".ts",
+  ".tsx"
+], xr = {
+  "application/pdf": {
+    extensions: [".pdf"],
+    maxSize: he
+  },
+  "text/plain": {
+    extensions: Sr,
+    maxSize: he
+  },
+  "text/csv": {
+    extensions: [".csv"],
+    maxSize: he
+  }
+};
+Object.entries(xr).reduce(
+  (e, [t, r]) => ({
+    ...e,
+    [t]: r.extensions
+  }),
+  {}
+);
+new Set(Object.values(_e));
+function W(e) {
+  const t = {
+    subscribe(r) {
+      let n = null, i = !1, s = !1, u = !1;
+      function l() {
+        if (n === null) {
+          u = !0;
+          return;
+        }
+        s || (s = !0, typeof n == "function" ? n() : n && n.unsubscribe());
+      }
+      return n = e({
+        next(a) {
+          var f;
+          i || (f = r.next) == null || f.call(r, a);
+        },
+        error(a) {
+          var f;
+          i || (i = !0, (f = r.error) == null || f.call(r, a), l());
+        },
+        complete() {
+          var a;
+          i || (i = !0, (a = r.complete) == null || a.call(r), l());
+        }
+      }), u && l(), {
+        unsubscribe: l
+      };
+    },
+    pipe(...r) {
+      return r.reduce(_r, t);
+    }
+  };
+  return t;
+}
+function _r(e, t) {
+  return t(e);
+}
+function kr(e) {
+  const t = new AbortController();
+  return new Promise((n, i) => {
+    let s = !1;
+    function u() {
+      s || (s = !0, l.unsubscribe());
+    }
+    t.signal.addEventListener("abort", () => {
+      i(t.signal.reason);
+    });
+    const l = e.subscribe({
+      next(a) {
+        s = !0, n(a), u();
+      },
+      error(a) {
+        i(a);
+      },
+      complete() {
+        t.abort(), u();
+      }
+    });
+  });
+}
+function Cr(e) {
+  return (t) => {
+    let r = 0, n = null;
+    const i = [];
+    function s() {
+      n || (n = t.subscribe({
+        next(l) {
+          var a;
+          for (const f of i)
+            (a = f.next) == null || a.call(f, l);
+        },
+        error(l) {
+          var a;
+          for (const f of i)
+            (a = f.error) == null || a.call(f, l);
+        },
+        complete() {
+          var l;
+          for (const a of i)
+            (l = a.complete) == null || l.call(a);
+        }
+      }));
+    }
+    function u() {
+      if (r === 0 && n) {
+        const l = n;
+        n = null, l.unsubscribe();
+      }
+    }
+    return W((l) => (r++, i.push(l), s(), {
+      unsubscribe() {
+        r--, u();
+        const a = i.findIndex((f) => f === l);
+        a > -1 && i.splice(a, 1);
+      }
+    }));
+  };
+}
+function jr(e) {
+  return (t) => W((r) => t.subscribe({
+    next(n) {
+      var i;
+      (i = e.next) == null || i.call(e, n), r.next(n);
+    },
+    error(n) {
+      var i;
+      (i = e.error) == null || i.call(e, n), r.error(n);
+    },
+    complete() {
+      var n;
+      (n = e.complete) == null || n.call(e), r.complete();
+    }
+  }));
+}
+function Ar(e) {
+  let t = e;
+  const r = [], n = (u) => {
+    t !== void 0 && u.next(t), r.push(u);
+  }, i = (u) => {
+    r.splice(r.indexOf(u), 1);
+  }, s = W((u) => (n(u), () => {
+    i(u);
+  }));
+  return s.next = (u) => {
+    if (t !== u) {
+      t = u;
+      for (const l of r)
+        l.next(u);
+    }
+  }, s.get = () => t, s;
+}
+function Ir(e) {
+  return W((t) => {
+    function r(i = 0, s = e.op) {
+      const u = e.links[i];
+      if (!u)
+        throw new Error("No more links to execute - did you forget to add an ending link?");
+      return u({
+        op: s,
+        next(a) {
+          return r(i + 1, a);
+        }
+      });
+    }
+    return r().subscribe(t);
+  });
+}
+const wt = () => {
+}, rt = (e) => {
+  Object.freeze && Object.freeze(e);
+};
+function vt(e, t, r) {
+  var n, i;
+  const s = t.join(".");
+  return (n = r)[i = s] ?? (n[i] = new Proxy(wt, {
+    get(u, l) {
+      if (!(typeof l != "string" || l === "then"))
+        return vt(e, [
+          ...t,
+          l
+        ], r);
+    },
+    apply(u, l, a) {
+      const f = t[t.length - 1];
+      let m = {
+        args: a,
+        path: t
+      };
+      return f === "call" ? m = {
+        args: a.length >= 2 ? [
+          a[1]
+        ] : [],
+        path: t.slice(0, -1)
+      } : f === "apply" && (m = {
+        args: a.length >= 2 ? a[1] : [],
+        path: t.slice(0, -1)
+      }), rt(m.args), rt(m.path), e(m);
+    }
+  })), r[s];
+}
+const Fr = (e) => vt(e, [], /* @__PURE__ */ Object.create(null)), Dr = (e) => new Proxy(wt, {
+  get(t, r) {
+    if (r !== "then")
+      return e(r);
+  }
+});
+function X(e) {
+  return !!e && !Array.isArray(e) && typeof e == "object";
+}
+function $r(e, t) {
+  if ("error" in e) {
+    const n = t.deserialize(e.error);
+    return {
+      ok: !1,
+      error: {
+        ...e,
+        error: n
+      }
+    };
+  }
+  return {
+    ok: !0,
+    result: {
+      ...e.result,
+      ...(!e.result.type || e.result.type === "data") && {
+        type: "data",
+        data: t.deserialize(e.result.data)
+      }
+    }
+  };
+}
+class ge extends Error {
+  constructor() {
+    super("Unable to transform response from server");
+  }
+}
+function Nr(e, t) {
+  let r;
+  try {
+    r = $r(e, t);
+  } catch {
+    throw new ge();
+  }
+  if (!r.ok && (!X(r.error.error) || typeof r.error.error.code != "number"))
+    throw new ge();
+  if (r.ok && !X(r.result))
+    throw new ge();
+  return r;
+}
+var nt, ot;
+(nt = Symbol).dispose ?? (nt.dispose = Symbol());
+(ot = Symbol).asyncDispose ?? (ot.asyncDispose = Symbol());
+var dt, mt, pt, yt, ht, gt;
+typeof window > "u" || "Deno" in window || // eslint-disable-next-line @typescript-eslint/dot-notation
+((mt = (dt = globalThis.process) == null ? void 0 : dt.env) == null ? void 0 : mt.NODE_ENV) === "test" || (yt = (pt = globalThis.process) == null ? void 0 : pt.env) != null && yt.JEST_WORKER_ID || (gt = (ht = globalThis.process) == null ? void 0 : ht.env) != null && gt.VITEST_WORKER_ID;
+function oe(e, t, r) {
+  return t in e ? Object.defineProperty(e, t, {
+    value: r,
+    enumerable: !0,
+    configurable: !0,
+    writable: !0
+  }) : e[t] = r, e;
+}
+function Lr(e) {
+  return e instanceof F || /**
+  * @deprecated
+  * Delete in next major
+  */
+  e instanceof Error && e.name === "TRPCClientError";
+}
+function Ur(e) {
+  return X(e) && X(e.error) && typeof e.error.code == "number" && typeof e.error.message == "string";
+}
+function Vr(e, t) {
+  return typeof e == "string" ? e : X(e) && typeof e.message == "string" ? e.message : t;
+}
+class F extends Error {
+  static from(t, r = {}) {
+    const n = t;
+    return Lr(n) ? (r.meta && (n.meta = {
+      ...n.meta,
+      ...r.meta
+    }), n) : Ur(n) ? new F(n.error.message, {
+      ...r,
+      result: n
+    }) : new F(Vr(n, "Unknown error"), {
+      ...r,
+      cause: n
+    });
+  }
+  constructor(t, r) {
+    var i, s;
+    const n = r == null ? void 0 : r.cause;
+    super(t, {
+      cause: n
+    }), // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore override doesn't work in all environments due to "This member cannot have an 'override' modifier because it is not declared in the base class 'Error'"
+    oe(this, "cause", void 0), oe(this, "shape", void 0), oe(this, "data", void 0), /**
+    * Additional meta data about the error
+    * In the case of HTTP-errors, we'll have `response` and potentially `responseJSON` here
+    */
+    oe(this, "meta", void 0), this.meta = r == null ? void 0 : r.meta, this.cause = n, this.shape = (i = r == null ? void 0 : r.result) == null ? void 0 : i.error, this.data = (s = r == null ? void 0 : r.result) == null ? void 0 : s.error.data, this.name = "TRPCClientError", Object.setPrototypeOf(this, F.prototype);
+  }
+}
+function be(e, t, r) {
+  return t in e ? Object.defineProperty(e, t, {
+    value: r,
+    enumerable: !0,
+    configurable: !0,
+    writable: !0
+  }) : e[t] = r, e;
+}
+class qr {
+  $request(t) {
+    return Ir({
+      links: this.links,
+      op: {
+        ...t,
+        context: t.context ?? {},
+        id: ++this.requestId
+      }
+    }).pipe(Cr());
+  }
+  async requestAsPromise(t) {
+    try {
+      const r = this.$request(t);
+      return (await kr(r)).result.data;
+    } catch (r) {
+      throw F.from(r);
+    }
+  }
+  query(t, r, n) {
+    return this.requestAsPromise({
+      type: "query",
+      path: t,
+      input: r,
+      context: n == null ? void 0 : n.context,
+      signal: n == null ? void 0 : n.signal
+    });
+  }
+  mutation(t, r, n) {
+    return this.requestAsPromise({
+      type: "mutation",
+      path: t,
+      input: r,
+      context: n == null ? void 0 : n.context,
+      signal: n == null ? void 0 : n.signal
+    });
+  }
+  subscription(t, r, n) {
+    return this.$request({
+      type: "subscription",
+      path: t,
+      input: r,
+      context: n.context,
+      signal: n.signal
+    }).subscribe({
+      next(s) {
+        var u, l, a, f;
+        switch (s.result.type) {
+          case "state": {
+            (u = n.onConnectionStateChange) == null || u.call(n, s.result);
+            break;
+          }
+          case "started": {
+            (l = n.onStarted) == null || l.call(n, {
+              context: s.context
+            });
+            break;
+          }
+          case "stopped": {
+            (a = n.onStopped) == null || a.call(n);
+            break;
+          }
+          case "data":
+          case void 0: {
+            (f = n.onData) == null || f.call(n, s.result.data);
+            break;
+          }
+        }
+      },
+      error(s) {
+        var u;
+        (u = n.onError) == null || u.call(n, s);
+      },
+      complete() {
+        var s;
+        (s = n.onComplete) == null || s.call(n);
+      }
+    });
+  }
+  constructor(t) {
+    be(this, "links", void 0), be(this, "runtime", void 0), be(this, "requestId", void 0), this.requestId = 0, this.runtime = {}, this.links = t.links.map((r) => r(this.runtime));
+  }
+}
+const zr = Symbol.for("trpc_untypedClient"), Mr = {
+  query: "query",
+  mutate: "mutation",
+  subscribe: "subscription"
+}, Wr = (e) => Mr[e];
+function Br(e) {
+  const t = Fr(({ path: r, args: n }) => {
+    const i = [
+      ...r
+    ], s = Wr(i.pop()), u = i.join(".");
+    return e[s](u, ...n);
+  });
+  return Dr((r) => r === zr ? e : t[r]);
+}
+function Kr(e) {
+  const t = new qr(e);
+  return Br(t);
+}
+const it = (e) => typeof e == "function";
+function Yr(e) {
+  if (e)
+    return e;
+  if (typeof window < "u" && it(window.fetch))
+    return window.fetch;
+  if (typeof globalThis < "u" && it(globalThis.fetch))
+    return globalThis.fetch;
+  throw new Error("No fetch implementation found");
+}
+const st = () => {
+  throw new Error("Something went wrong. Please submit an issue at https://github.com/trpc/trpc/issues/new");
+};
+function at(e) {
+  let t = null, r = null;
+  const n = () => {
+    clearTimeout(r), r = null, t = null;
+  };
+  function i(l) {
+    var m, p;
+    const a = [
+      []
+    ];
+    let f = 0;
+    for (; ; ) {
+      const h = l[f];
+      if (!h)
+        break;
+      const b = a[a.length - 1];
+      if (h.aborted) {
+        (m = h.reject) == null || m.call(h, new Error("Aborted")), f++;
+        continue;
+      }
+      if (e.validate(b.concat(h).map((P) => P.key))) {
+        b.push(h), f++;
+        continue;
+      }
+      if (b.length === 0) {
+        (p = h.reject) == null || p.call(h, new Error("Input is too big for a single dispatch")), f++;
+        continue;
+      }
+      a.push([]);
+    }
+    return a;
+  }
+  function s() {
+    const l = i(t);
+    n();
+    for (const a of l) {
+      if (!a.length)
+        continue;
+      const f = {
+        items: a
+      };
+      for (const p of a)
+        p.batch = f;
+      e.fetch(f.items.map((p) => p.key)).then(async (p) => {
+        var h;
+        await Promise.all(p.map(async (b, x) => {
+          var U, j;
+          const P = f.items[x];
+          try {
+            const S = await Promise.resolve(b);
+            (U = P.resolve) == null || U.call(P, S);
+          } catch (S) {
+            (j = P.reject) == null || j.call(P, S);
+          }
+          P.batch = null, P.reject = null, P.resolve = null;
+        }));
+        for (const b of f.items)
+          (h = b.reject) == null || h.call(b, new Error("Missing result")), b.batch = null;
+      }).catch((p) => {
+        var h;
+        for (const b of f.items)
+          (h = b.reject) == null || h.call(b, p), b.batch = null;
+      });
+    }
+  }
+  function u(l) {
+    const a = {
+      aborted: !1,
+      key: l,
+      batch: null,
+      resolve: st,
+      reject: st
+    }, f = new Promise((m, p) => {
+      a.reject = p, a.resolve = m, t || (t = []), t.push(a);
+    });
+    return r || (r = setTimeout(s)), f;
+  }
+  return {
+    load: u
+  };
+}
+function Hr(...e) {
+  const t = new AbortController(), r = e.length;
+  let n = 0;
+  const i = () => {
+    ++n === r && t.abort();
+  };
+  for (const s of e)
+    s != null && s.aborted ? i() : s == null || s.addEventListener("abort", i, {
+      once: !0
+    });
+  return t.signal;
+}
+function Gr(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
+    }
+  };
+}
+function Xr(e) {
+  return {
+    url: e.url.toString(),
+    fetch: e.fetch,
+    transformer: Gr(e.transformer),
+    methodOverride: e.methodOverride
+  };
+}
+function Jr(e) {
+  const t = {};
+  for (let r = 0; r < e.length; r++) {
+    const n = e[r];
+    t[r] = n;
+  }
+  return t;
+}
+const Zr = {
+  query: "GET",
+  mutation: "POST",
+  subscription: "PATCH"
+};
+function Et(e) {
+  return "input" in e ? e.transformer.input.serialize(e.input) : Jr(e.inputs.map((t) => e.transformer.input.serialize(t)));
+}
+const Pt = (e) => {
+  const t = e.url.split("?");
+  let n = t[0].replace(/\/$/, "") + "/" + e.path;
+  const i = [];
+  if (t[1] && i.push(t[1]), "inputs" in e && i.push("batch=1"), e.type === "query" || e.type === "subscription") {
+    const s = Et(e);
+    s !== void 0 && e.methodOverride !== "POST" && i.push(`input=${encodeURIComponent(JSON.stringify(s))}`);
+  }
+  return i.length && (n += "?" + i.join("&")), n;
+}, Qr = (e) => {
+  if (e.type === "query" && e.methodOverride !== "POST")
+    return;
+  const t = Et(e);
+  return t !== void 0 ? JSON.stringify(t) : void 0;
+}, en = (e) => on({
+  ...e,
+  contentTypeHeader: "application/json",
+  getUrl: Pt,
+  getBody: Qr
+});
+class tn extends Error {
+  constructor() {
+    const t = "AbortError";
+    super(t), this.name = t, this.message = t;
+  }
+}
+const rn = (e) => {
+  var t;
+  if (e != null && e.aborted)
+    throw (t = e.throwIfAborted) == null || t.call(e), typeof DOMException < "u" ? new DOMException("AbortError", "AbortError") : new tn();
+};
+async function nn(e) {
+  rn(e.signal);
+  const t = e.getUrl(e), r = e.getBody(e), { type: n } = e, i = await (async () => {
+    const u = await e.headers();
+    return Symbol.iterator in u ? Object.fromEntries(u) : u;
+  })(), s = {
+    ...e.contentTypeHeader ? {
+      "content-type": e.contentTypeHeader
+    } : {},
+    ...e.trpcAcceptHeader ? {
+      "trpc-accept": e.trpcAcceptHeader
+    } : void 0,
+    ...i
+  };
+  return Yr(e.fetch)(t, {
+    method: e.methodOverride ?? Zr[n],
+    signal: e.signal,
+    body: r,
+    headers: s
+  });
+}
+async function on(e) {
+  const t = {}, r = await nn(e);
+  t.response = r;
+  const n = await r.json();
+  return t.responseJSON = n, {
+    json: n,
+    meta: t
+  };
+}
+function sn(e) {
+  const t = Xr(e), r = e.maxURLLength ?? 1 / 0;
+  return () => {
+    const n = (l) => ({
+      validate(a) {
+        if (r === 1 / 0)
+          return !0;
+        const f = a.map((h) => h.path).join(","), m = a.map((h) => h.input);
+        return Pt({
+          ...t,
+          type: l,
+          path: f,
+          inputs: m,
+          signal: null
+        }).length <= r;
+      },
+      async fetch(a) {
+        const f = a.map((P) => P.path).join(","), m = a.map((P) => P.input), p = Hr(...a.map((P) => P.signal)), h = await en({
+          ...t,
+          path: f,
+          inputs: m,
+          type: l,
+          headers() {
+            return e.headers ? typeof e.headers == "function" ? e.headers({
+              opList: a
+            }) : e.headers : {};
+          },
+          signal: p
+        });
+        return (Array.isArray(h.json) ? h.json : a.map(() => h.json)).map((P) => ({
+          meta: h.meta,
+          json: P
+        }));
+      }
+    }), i = at(n("query")), s = at(n("mutation")), u = {
+      query: i,
+      mutation: s
+    };
+    return ({ op: l }) => W((a) => {
+      /* istanbul ignore if -- @preserve */
+      if (l.type === "subscription")
+        throw new Error("Subscriptions are unsupported by `httpLink` - use `httpSubscriptionLink` or `wsLink`");
+      const m = u[l.type].load(l);
+      let p;
+      return m.then((h) => {
+        p = h;
+        const b = Nr(h.json, t.transformer.output);
+        if (!b.ok) {
+          a.error(F.from(b.error, {
+            meta: h.meta
+          }));
+          return;
+        }
+        a.next({
+          context: h.meta,
+          result: b.result
+        }), a.complete();
+      }).catch((h) => {
+        a.error(F.from(h, {
+          meta: p == null ? void 0 : p.meta
+        }));
+      }), () => {
+      };
+    });
+  };
+}
+function an(e) {
+  return typeof FormData > "u" ? !1 : e instanceof FormData;
+}
+const we = {
+  css: {
+    query: [
+      "72e3ff",
+      "3fb0d8"
+    ],
+    mutation: [
+      "c5a3fc",
+      "904dfc"
+    ],
+    subscription: [
+      "ff49e1",
+      "d83fbe"
+    ]
+  },
+  ansi: {
+    regular: {
+      // Cyan background, black and white text respectively
+      query: [
+        "\x1B[30;46m",
+        "\x1B[97;46m"
+      ],
+      // Magenta background, black and white text respectively
+      mutation: [
+        "\x1B[30;45m",
+        "\x1B[97;45m"
+      ],
+      // Green background, black and white text respectively
+      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 un(e) {
+  const { direction: t, type: r, withContext: n, path: i, id: s, input: u } = e, l = [], a = [];
+  if (e.colorMode === "none")
+    l.push(t === "up" ? ">>" : "<<", r, `#${s}`, i);
+  else if (e.colorMode === "ansi") {
+    const [f, m] = we.ansi.regular[r], [p, h] = we.ansi.bold[r];
+    l.push(t === "up" ? f : m, t === "up" ? ">>" : "<<", r, t === "up" ? p : h, `#${s}`, i, "\x1B[0m");
+  } else {
+    const [f, m] = we.css[r], p = `
+    background-color: #${t === "up" ? f : m};
+    color: ${t === "up" ? "black" : "white"};
+    padding: 2px;
+  `;
+    l.push("%c", t === "up" ? ">>" : "<<", r, `#${s}`, `%c${i}%c`, "%O"), a.push(p, `${p}; font-weight: bold;`, `${p}; font-weight: normal;`);
+  }
+  return t === "up" ? a.push(n ? {
+    input: u,
+    context: e.context
+  } : {
+    input: u
+  }) : a.push({
+    input: u,
+    result: e.result,
+    elapsedMs: e.elapsedMs,
+    ...n && {
+      context: e.context
+    }
+  }), {
+    parts: l,
+    args: a
+  };
+}
+const cn = ({ c: e = console, colorMode: t = "css", withContext: r }) => (n) => {
+  const i = n.input, s = an(i) ? Object.fromEntries(i) : i, { parts: u, args: l } = un({
+    ...n,
+    colorMode: t,
+    input: s,
+    withContext: r
+  }), a = n.direction === "down" && n.result && (n.result instanceof Error || "error" in n.result.result && n.result.result.error) ? "error" : "log";
+  e[a].apply(null, [
+    u.join(" ")
+  ].concat(l));
+};
+function ln(e = {}) {
+  const { enabled: t = () => !0 } = e, r = e.colorMode ?? (typeof window > "u" ? "ansi" : "css"), n = e.withContext ?? r === "css", { logger: i = cn({
+    c: e.console,
+    colorMode: r,
+    withContext: n
+  }) } = e;
+  return () => ({ op: s, next: u }) => W((l) => {
+    t({
+      ...s,
+      direction: "up"
+    }) && i({
+      ...s,
+      direction: "up"
+    });
+    const a = Date.now();
+    function f(m) {
+      const p = Date.now() - a;
+      t({
+        ...s,
+        direction: "down",
+        result: m
+      }) && i({
+        ...s,
+        direction: "down",
+        elapsedMs: p,
+        result: m
+      });
+    }
+    return u(s).pipe(jr({
+      next(m) {
+        f(m);
+      },
+      error(m) {
+        f(m);
+      }
+    })).subscribe(l);
+  });
+}
+const fn = (e, ...t) => typeof e == "function" ? e(...t) : e;
+function dn() {
+  let e, t;
+  return {
+    promise: new Promise((n, i) => {
+      e = n, t = i;
+    }),
+    resolve: e,
+    reject: t
+  };
+}
+async function mn(e) {
+  const t = await fn(e.url);
+  if (!e.connectionParams) return t;
+  const n = `${t.includes("?") ? "&" : "?"}connectionParams=1`;
+  return t + n;
+}
+function L(e, t, r) {
+  return t in e ? Object.defineProperty(e, t, {
+    value: r,
+    enumerable: !0,
+    configurable: !0,
+    writable: !0
+  }) : e[t] = r, e;
+}
+function pn(e) {
+  const { promise: t, resolve: r, reject: n } = dn();
+  return e.addEventListener("open", () => {
+    e.removeEventListener("error", n), r();
+  }), e.addEventListener("error", n), t;
+}
+function yn(e, { intervalMs: t, pongTimeoutMs: r }) {
+  let n, i;
+  function s() {
+    n = setTimeout(() => {
+      e.send("PING"), i = setTimeout(() => {
+        e.close();
+      }, r);
+    }, t);
+  }
+  function u() {
+    clearTimeout(n), s();
+  }
+  function l() {
+    clearTimeout(i), u();
+  }
+  e.addEventListener("open", s), e.addEventListener("message", ({ data: a }) => {
+    clearTimeout(n), s(), a === "PONG" && l();
+  }), e.addEventListener("close", () => {
+    clearTimeout(n), clearTimeout(i);
+  });
+}
+class se {
+  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;
+  }
+  /**
+  * 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() {
+    if (this.openPromise) return this.openPromise;
+    this.id = ++se.connectCount;
+    const t = mn(this.urlOptions).then((r) => new this.WebSocketPonyfill(r));
+    this.openPromise = t.then(pn), this.ws = await t, this.ws.addEventListener("message", function({ data: r }) {
+      r === "PING" && this.send("PONG");
+    }), this.keepAliveOpts.enabled && yn(this.ws, this.keepAliveOpts), this.ws.addEventListener("close", () => {
+      this.ws = null;
+    });
+    try {
+      await this.openPromise;
+    } finally {
+      this.openPromise = null;
+    }
+  }
+  /**
+  * Closes the WebSocket connection gracefully.
+  * Waits for any ongoing open operation to complete before closing.
+  */
+  async close() {
+    var t;
+    try {
+      await this.openPromise;
+    } finally {
+      (t = this.ws) == null || t.close();
+    }
+  }
+  constructor(t) {
+    if (L(this, "id", ++se.connectCount), L(this, "WebSocketPonyfill", void 0), L(this, "urlOptions", void 0), L(this, "keepAliveOpts", void 0), L(this, "wsObservable", Ar(null)), L(this, "openPromise", null), this.WebSocketPonyfill = t.WebSocketPonyfill ?? 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;
+  }
+}
+L(se, "connectCount", 0);
+class hn {
+  constructor() {
+    this.keyToValue = /* @__PURE__ */ new Map(), this.valueToKey = /* @__PURE__ */ new Map();
+  }
+  set(t, r) {
+    this.keyToValue.set(t, r), this.valueToKey.set(r, t);
+  }
+  getByKey(t) {
+    return this.keyToValue.get(t);
+  }
+  getByValue(t) {
+    return this.valueToKey.get(t);
+  }
+  clear() {
+    this.keyToValue.clear(), this.valueToKey.clear();
+  }
+}
+class Rt {
+  constructor(t) {
+    this.generateIdentifier = t, this.kv = new hn();
+  }
+  register(t, r) {
+    this.kv.getByValue(t) || (r || (r = this.generateIdentifier(t)), this.kv.set(r, t));
+  }
+  clear() {
+    this.kv.clear();
+  }
+  getIdentifier(t) {
+    return this.kv.getByValue(t);
+  }
+  getValue(t) {
+    return this.kv.getByKey(t);
+  }
+}
+class gn extends Rt {
+  constructor() {
+    super((t) => t.name), this.classToAllowedProps = /* @__PURE__ */ new Map();
+  }
+  register(t, r) {
+    typeof r == "object" ? (r.allowProps && this.classToAllowedProps.set(t, r.allowProps), super.register(t, r.identifier)) : super.register(t, r);
+  }
+  getAllowedProps(t) {
+    return this.classToAllowedProps.get(t);
+  }
+}
+function bn(e) {
+  if ("values" in Object)
+    return Object.values(e);
+  const t = [];
+  for (const r in e)
+    e.hasOwnProperty(r) && t.push(e[r]);
+  return t;
+}
+function wn(e, t) {
+  const r = bn(e);
+  if ("find" in r)
+    return r.find(t);
+  const n = r;
+  for (let i = 0; i < n.length; i++) {
+    const s = n[i];
+    if (t(s))
+      return s;
+  }
+}
+function M(e, t) {
+  Object.entries(e).forEach(([r, n]) => t(n, r));
+}
+function ie(e, t) {
+  return e.indexOf(t) !== -1;
+}
+function ut(e, t) {
+  for (let r = 0; r < e.length; r++) {
+    const n = e[r];
+    if (t(n))
+      return n;
+  }
+}
+class vn {
+  constructor() {
+    this.transfomers = {};
+  }
+  register(t) {
+    this.transfomers[t.name] = t;
+  }
+  findApplicable(t) {
+    return wn(this.transfomers, (r) => r.isApplicable(t));
+  }
+  findByName(t) {
+    return this.transfomers[t];
+  }
+}
+const En = (e) => Object.prototype.toString.call(e).slice(8, -1), Tt = (e) => typeof e > "u", Pn = (e) => e === null, J = (e) => typeof e != "object" || e === null || e === Object.prototype ? !1 : Object.getPrototypeOf(e) === null ? !0 : Object.getPrototypeOf(e) === Object.prototype, Te = (e) => J(e) && Object.keys(e).length === 0, D = (e) => Array.isArray(e), Rn = (e) => typeof e == "string", Tn = (e) => typeof e == "number" && !isNaN(e), On = (e) => typeof e == "boolean", Sn = (e) => e instanceof RegExp, Z = (e) => e instanceof Map, Q = (e) => e instanceof Set, Ot = (e) => En(e) === "Symbol", xn = (e) => e instanceof Date && !isNaN(e.valueOf()), _n = (e) => e instanceof Error, ct = (e) => typeof e == "number" && isNaN(e), kn = (e) => On(e) || Pn(e) || Tt(e) || Tn(e) || Rn(e) || Ot(e), Cn = (e) => typeof e == "bigint", jn = (e) => e === 1 / 0 || e === -1 / 0, An = (e) => ArrayBuffer.isView(e) && !(e instanceof DataView), In = (e) => e instanceof URL, St = (e) => e.replace(/\./g, "\\."), ve = (e) => e.map(String).map(St).join("."), G = (e) => {
+  const t = [];
+  let r = "";
+  for (let i = 0; i < e.length; i++) {
+    let s = e.charAt(i);
+    if (s === "\\" && e.charAt(i + 1) === ".") {
+      r += ".", i++;
+      continue;
+    }
+    if (s === ".") {
+      t.push(r), r = "";
+      continue;
+    }
+    r += s;
+  }
+  const n = r;
+  return t.push(n), t;
+};
+function A(e, t, r, n) {
+  return {
+    isApplicable: e,
+    annotation: t,
+    transform: r,
+    untransform: n
+  };
+}
+const xt = [
+  A(Tt, "undefined", () => null, () => {
+  }),
+  A(Cn, "bigint", (e) => e.toString(), (e) => typeof BigInt < "u" ? BigInt(e) : (console.error("Please add a BigInt polyfill."), e)),
+  A(xn, "Date", (e) => e.toISOString(), (e) => new Date(e)),
+  A(_n, "Error", (e, t) => {
+    const r = {
+      name: e.name,
+      message: e.message
+    };
+    return t.allowedErrorProps.forEach((n) => {
+      r[n] = e[n];
+    }), r;
+  }, (e, t) => {
+    const r = new Error(e.message);
+    return r.name = e.name, r.stack = e.stack, t.allowedErrorProps.forEach((n) => {
+      r[n] = e[n];
+    }), r;
+  }),
+  A(Sn, "regexp", (e) => "" + e, (e) => {
+    const t = e.slice(1, e.lastIndexOf("/")), r = e.slice(e.lastIndexOf("/") + 1);
+    return new RegExp(t, r);
+  }),
+  A(
+    Q,
+    "set",
+    // (sets only exist in es6+)
+    // eslint-disable-next-line es5/no-es6-methods
+    (e) => [...e.values()],
+    (e) => new Set(e)
+  ),
+  A(Z, "map", (e) => [...e.entries()], (e) => new Map(e)),
+  A((e) => ct(e) || jn(e), "number", (e) => ct(e) ? "NaN" : e > 0 ? "Infinity" : "-Infinity", Number),
+  A((e) => e === 0 && 1 / e === -1 / 0, "number", () => "-0", Number),
+  A(In, "URL", (e) => e.toString(), (e) => new URL(e))
+];
+function ae(e, t, r, n) {
+  return {
+    isApplicable: e,
+    annotation: t,
+    transform: r,
+    untransform: n
+  };
+}
+const _t = ae((e, t) => Ot(e) ? !!t.symbolRegistry.getIdentifier(e) : !1, (e, t) => ["symbol", t.symbolRegistry.getIdentifier(e)], (e) => e.description, (e, t, r) => {
+  const n = r.symbolRegistry.getValue(t[1]);
+  if (!n)
+    throw new Error("Trying to deserialize unknown symbol");
+  return n;
+}), Fn = [
+  Int8Array,
+  Uint8Array,
+  Int16Array,
+  Uint16Array,
+  Int32Array,
+  Uint32Array,
+  Float32Array,
+  Float64Array,
+  Uint8ClampedArray
+].reduce((e, t) => (e[t.name] = t, e), {}), kt = ae(An, (e) => ["typed-array", e.constructor.name], (e) => [...e], (e, t) => {
+  const r = Fn[t[1]];
+  if (!r)
+    throw new Error("Trying to deserialize unknown typed array");
+  return new r(e);
+});
+function Ct(e, t) {
+  return e != null && e.constructor ? !!t.classRegistry.getIdentifier(e.constructor) : !1;
+}
+const jt = ae(Ct, (e, t) => ["class", t.classRegistry.getIdentifier(e.constructor)], (e, t) => {
+  const r = t.classRegistry.getAllowedProps(e.constructor);
+  if (!r)
+    return { ...e };
+  const n = {};
+  return r.forEach((i) => {
+    n[i] = e[i];
+  }), n;
+}, (e, t, r) => {
+  const n = r.classRegistry.getValue(t[1]);
+  if (!n)
+    throw new Error(`Trying to deserialize unknown class '${t[1]}' - check https://github.com/blitz-js/superjson/issues/116#issuecomment-773996564`);
+  return Object.assign(Object.create(n.prototype), e);
+}), At = ae((e, t) => !!t.customTransformerRegistry.findApplicable(e), (e, t) => ["custom", t.customTransformerRegistry.findApplicable(e).name], (e, t) => t.customTransformerRegistry.findApplicable(e).serialize(e), (e, t, r) => {
+  const n = r.customTransformerRegistry.findByName(t[1]);
+  if (!n)
+    throw new Error("Trying to deserialize unknown custom value");
+  return n.deserialize(e);
+}), Dn = [jt, _t, At, kt], lt = (e, t) => {
+  const r = ut(Dn, (i) => i.isApplicable(e, t));
+  if (r)
+    return {
+      value: r.transform(e, t),
+      type: r.annotation(e, t)
+    };
+  const n = ut(xt, (i) => i.isApplicable(e, t));
+  if (n)
+    return {
+      value: n.transform(e, t),
+      type: n.annotation
+    };
+}, It = {};
+xt.forEach((e) => {
+  It[e.annotation] = e;
+});
+const $n = (e, t, r) => {
+  if (D(t))
+    switch (t[0]) {
+      case "symbol":
+        return _t.untransform(e, t, r);
+      case "class":
+        return jt.untransform(e, t, r);
+      case "custom":
+        return At.untransform(e, t, r);
+      case "typed-array":
+        return kt.untransform(e, t, r);
+      default:
+        throw new Error("Unknown transformation: " + t);
+    }
+  else {
+    const n = It[t];
+    if (!n)
+      throw new Error("Unknown transformation: " + t);
+    return n.untransform(e, r);
+  }
+}, z = (e, t) => {
+  if (t > e.size)
+    throw new Error("index out of bounds");
+  const r = e.keys();
+  for (; t > 0; )
+    r.next(), t--;
+  return r.next().value;
+};
+function Ft(e) {
+  if (ie(e, "__proto__"))
+    throw new Error("__proto__ is not allowed as a property");
+  if (ie(e, "prototype"))
+    throw new Error("prototype is not allowed as a property");
+  if (ie(e, "constructor"))
+    throw new Error("constructor is not allowed as a property");
+}
+const Nn = (e, t) => {
+  Ft(t);
+  for (let r = 0; r < t.length; r++) {
+    const n = t[r];
+    if (Q(e))
+      e = z(e, +n);
+    else if (Z(e)) {
+      const i = +n, s = +t[++r] == 0 ? "key" : "value", u = z(e, i);
+      switch (s) {
+        case "key":
+          e = u;
+          break;
+        case "value":
+          e = e.get(u);
+          break;
+      }
+    } else
+      e = e[n];
+  }
+  return e;
+}, Oe = (e, t, r) => {
+  if (Ft(t), t.length === 0)
+    return r(e);
+  let n = e;
+  for (let s = 0; s < t.length - 1; s++) {
+    const u = t[s];
+    if (D(n)) {
+      const l = +u;
+      n = n[l];
+    } else if (J(n))
+      n = n[u];
+    else if (Q(n)) {
+      const l = +u;
+      n = z(n, l);
+    } else if (Z(n)) {
+      if (s === t.length - 2)
+        break;
+      const a = +u, f = +t[++s] == 0 ? "key" : "value", m = z(n, a);
+      switch (f) {
+        case "key":
+          n = m;
+          break;
+        case "value":
+          n = n.get(m);
+          break;
+      }
+    }
+  }
+  const i = t[t.length - 1];
+  if (D(n) ? n[+i] = r(n[+i]) : J(n) && (n[i] = r(n[i])), Q(n)) {
+    const s = z(n, +i), u = r(s);
+    s !== u && (n.delete(s), n.add(u));
+  }
+  if (Z(n)) {
+    const s = +t[t.length - 2], u = z(n, s);
+    switch (+i == 0 ? "key" : "value") {
+      case "key": {
+        const a = r(u);
+        n.set(a, n.get(u)), a !== u && n.delete(u);
+        break;
+      }
+      case "value": {
+        n.set(u, r(n.get(u)));
+        break;
+      }
+    }
+  }
+  return e;
+};
+function Se(e, t, r = []) {
+  if (!e)
+    return;
+  if (!D(e)) {
+    M(e, (s, u) => Se(s, t, [...r, ...G(u)]));
+    return;
+  }
+  const [n, i] = e;
+  i && M(i, (s, u) => {
+    Se(s, t, [...r, ...G(u)]);
+  }), t(n, r);
+}
+function Ln(e, t, r) {
+  return Se(t, (n, i) => {
+    e = Oe(e, i, (s) => $n(s, n, r));
+  }), e;
+}
+function Un(e, t) {
+  function r(n, i) {
+    const s = Nn(e, G(i));
+    n.map(G).forEach((u) => {
+      e = Oe(e, u, () => s);
+    });
+  }
+  if (D(t)) {
+    const [n, i] = t;
+    n.forEach((s) => {
+      e = Oe(e, G(s), () => e);
+    }), i && M(i, r);
+  } else
+    M(t, r);
+  return e;
+}
+const Vn = (e, t) => J(e) || D(e) || Z(e) || Q(e) || Ct(e, t);
+function qn(e, t, r) {
+  const n = r.get(e);
+  n ? n.push(t) : r.set(e, [t]);
+}
+function zn(e, t) {
+  const r = {};
+  let n;
+  return e.forEach((i) => {
+    if (i.length <= 1)
+      return;
+    t || (i = i.map((l) => l.map(String)).sort((l, a) => l.length - a.length));
+    const [s, ...u] = i;
+    s.length === 0 ? n = u.map(ve) : r[ve(s)] = u.map(ve);
+  }), n ? Te(r) ? [n] : [n, r] : Te(r) ? void 0 : r;
+}
+const Dt = (e, t, r, n, i = [], s = [], u = /* @__PURE__ */ new Map()) => {
+  const l = kn(e);
+  if (!l) {
+    qn(e, i, t);
+    const b = u.get(e);
+    if (b)
+      return n ? {
+        transformedValue: null
+      } : b;
+  }
+  if (!Vn(e, r)) {
+    const b = lt(e, r), x = b ? {
+      transformedValue: b.value,
+      annotations: [b.type]
+    } : {
+      transformedValue: e
+    };
+    return l || u.set(e, x), x;
+  }
+  if (ie(s, e))
+    return {
+      transformedValue: null
+    };
+  const a = lt(e, r), f = (a == null ? void 0 : a.value) ?? e, m = D(f) ? [] : {}, p = {};
+  M(f, (b, x) => {
+    if (x === "__proto__" || x === "constructor" || x === "prototype")
+      throw new Error(`Detected property ${x}. This is a prototype pollution risk, please remove it from your object.`);
+    const P = Dt(b, t, r, n, [...i, x], [...s, e], u);
+    m[x] = P.transformedValue, D(P.annotations) ? p[x] = P.annotations : J(P.annotations) && M(P.annotations, (U, j) => {
+      p[St(x) + "." + j] = U;
+    });
+  });
+  const h = Te(p) ? {
+    transformedValue: m,
+    annotations: a ? [a.type] : void 0
+  } : {
+    transformedValue: m,
+    annotations: a ? [a.type, p] : p
+  };
+  return l || u.set(e, h), h;
+};
+function $t(e) {
+  return Object.prototype.toString.call(e).slice(8, -1);
+}
+function ft(e) {
+  return $t(e) === "Array";
+}
+function Mn(e) {
+  if ($t(e) !== "Object")
+    return !1;
+  const t = Object.getPrototypeOf(e);
+  return !!t && t.constructor === Object && t === Object.prototype;
+}
+function Wn(e, t, r, n, i) {
+  const s = {}.propertyIsEnumerable.call(n, t) ? "enumerable" : "nonenumerable";
+  s === "enumerable" && (e[t] = r), i && s === "nonenumerable" && Object.defineProperty(e, t, {
+    value: r,
+    enumerable: !1,
+    writable: !0,
+    configurable: !0
+  });
+}
+function xe(e, t = {}) {
+  if (ft(e))
+    return e.map((i) => xe(i, t));
+  if (!Mn(e))
+    return e;
+  const r = Object.getOwnPropertyNames(e), n = Object.getOwnPropertySymbols(e);
+  return [...r, ...n].reduce((i, s) => {
+    if (ft(t.props) && !t.props.includes(s))
+      return i;
+    const u = e[s], l = xe(u, t);
+    return Wn(i, s, l, e, t.nonenumerable), i;
+  }, {});
+}
+class w {
+  /**
+   * @param dedupeReferentialEqualities  If true, SuperJSON will make sure only one instance of referentially equal objects are serialized and the rest are replaced with `null`.
+   */
+  constructor({ dedupe: t = !1 } = {}) {
+    this.classRegistry = new gn(), this.symbolRegistry = new Rt((r) => r.description ?? ""), this.customTransformerRegistry = new vn(), this.allowedErrorProps = [], this.dedupe = t;
+  }
+  serialize(t) {
+    const r = /* @__PURE__ */ new Map(), n = Dt(t, r, this, this.dedupe), i = {
+      json: n.transformedValue
+    };
+    n.annotations && (i.meta = {
+      ...i.meta,
+      values: n.annotations
+    });
+    const s = zn(r, this.dedupe);
+    return s && (i.meta = {
+      ...i.meta,
+      referentialEqualities: s
+    }), i;
+  }
+  deserialize(t) {
+    const { json: r, meta: n } = t;
+    let i = xe(r);
+    return n != null && n.values && (i = Ln(i, n.values, this)), n != null && n.referentialEqualities && (i = Un(i, n.referentialEqualities)), i;
+  }
+  stringify(t) {
+    return JSON.stringify(this.serialize(t));
+  }
+  parse(t) {
+    return this.deserialize(JSON.parse(t));
+  }
+  registerClass(t, r) {
+    this.classRegistry.register(t, r);
+  }
+  registerSymbol(t, r) {
+    this.symbolRegistry.register(t, r);
+  }
+  registerCustom(t, r) {
+    this.customTransformerRegistry.register({
+      name: r,
+      ...t
+    });
+  }
+  allowErrorProps(...t) {
+    this.allowedErrorProps.push(...t);
+  }
+}
+w.defaultInstance = new w();
+w.serialize = w.defaultInstance.serialize.bind(w.defaultInstance);
+w.deserialize = w.defaultInstance.deserialize.bind(w.defaultInstance);
+w.stringify = w.defaultInstance.stringify.bind(w.defaultInstance);
+w.parse = w.defaultInstance.parse.bind(w.defaultInstance);
+w.registerClass = w.defaultInstance.registerClass.bind(w.defaultInstance);
+w.registerSymbol = w.defaultInstance.registerSymbol.bind(w.defaultInstance);
+w.registerCustom = w.defaultInstance.registerCustom.bind(w.defaultInstance);
+w.allowErrorProps = w.defaultInstance.allowErrorProps.bind(w.defaultInstance);
+w.serialize;
+w.deserialize;
+w.stringify;
+w.parse;
+w.registerClass;
+w.registerCustom;
+w.registerSymbol;
+w.allowErrorProps;
+const Bn = "dev-jwt-token-for-testing", Kn = async () => Bn, Nt = Er(null);
+function Yn(e, t) {
+  const r = Kr({
+    links: [
+      ln({
+        enabled: (n) => process.env.NODE_ENV === "development" && typeof window < "u" || n.direction === "down" && n.result instanceof Error
+      }),
+      sn({
+        url: `${e}/trpc`,
+        headers: async () => ({
+          Authorization: `Bearer ${await t()}`
+        }),
+        transformer: w
+      })
+    ]
+  });
+  return {
+    getProjectsForUser: async () => (await r.projectRouter.getAllProjects.query()).map((i) => ({
+      name: i.name,
+      id: i.id
+    })),
+    addProjectForUser: async (n) => {
+      const i = await r.projectRouter.createProject.mutate({
+        name: n
+      });
+      return {
+        name: i.name,
+        id: i.id
+      };
+    },
+    addFilesToProject: async (n, i) => {
+      const s = [];
+      for (const u of i) {
+        const l = await r.fileRouter.createFile.mutate({
+          file: {
+            projectId: n,
+            mimeType: _e.PDF,
+            // Adjust as needed
+            path: u.path,
+            name: u.name,
+            size: 0,
+            // You might need to calculate or pass size
+            metadata: null,
+            isArtifact: !1,
+            summary: null
+          }
+        });
+        s.push({
+          path: l.path,
+          name: l.name,
+          id: l.id
+        });
+      }
+      return s;
+    },
+    getFilesForProject: async (n) => (await r.fileRouter.getFilesByProject.query({
+      projectId: n
+    })).map((s) => ({
+      path: s.path,
+      name: s.name,
+      id: s.id
+    }))
+  };
+}
+function Zn({
+  children: e,
+  host: t = "http://localhost",
+  port: r = 5174,
+  getToken: n = Kn
+}) {
+  const [i, s] = Ee(null);
+  return Pr(() => {
+    const u = `${t}:${r}`, l = Yn(u, n);
+    s(l);
+  }, [t, r, n]), /* @__PURE__ */ Re.jsx(Nt.Provider, { value: { host: t, port: r, client: i }, children: e });
+}
+function Lt() {
+  const e = Rr(Nt);
+  if (!e)
+    throw new Error("useFolioContext must be used within a FolioProvider");
+  return e;
+}
+const { useEffect: Hn, useRef: Gn, useState: Xn } = vr;
+function Qn({
+  width: e = "100%",
+  height: t = "100vh",
+  allow: r = "camera; microphone; clipboard-read; clipboard-write; fullscreen",
+  style: n,
+  className: i = "",
+  iframeProps: s = {}
+}) {
+  const { host: u, port: l } = Lt(), a = Gn(null), [f, m] = Xn();
+  return Hn(() => {
+    m(`${u}:${l}`);
+  }, [u, l]), f ? /* @__PURE__ */ Re.jsx(
+    "div",
+    {
+      className: `folio-embed-container ${i}`,
+      style: {
+        width: e,
+        height: t,
+        overflow: "hidden",
+        ...n
+      },
+      children: /* @__PURE__ */ Re.jsx(
+        "iframe",
+        {
+          ref: a,
+          src: f,
+          width: "100%",
+          height: "100%",
+          style: {
+            border: "none",
+            width: "100%",
+            height: "100%",
+            overflow: "auto"
+          },
+          allow: r,
+          allowFullScreen: !0,
+          ...s
+        }
+      )
+    }
+  ) : null;
+}
+function eo() {
+  const { client: e } = Lt(), [t, r] = Ee(!1), [n, i] = Ee(null);
+  return {
+    isLoading: t,
+    error: n,
+    getProjectsForUser: async () => {
+      for (; !e; )
+        await new Promise((f) => setTimeout(f, 100));
+      r(!0), i(null);
+      try {
+        return await e.getProjectsForUser();
+      } catch (f) {
+        return i(f instanceof Error ? f : new Error(String(f))), [];
+      } finally {
+        r(!1);
+      }
+    },
+    addProjectForUser: async (f) => {
+      for (; !e; )
+        await new Promise((m) => setTimeout(m, 100));
+      r(!0), i(null);
+      try {
+        return await e.addProjectForUser(f);
+      } catch (m) {
+        return i(m instanceof Error ? m : new Error(String(m))), null;
+      } finally {
+        r(!1);
+      }
+    },
+    addFilesToProject: async (f, m) => {
+      for (; !e; )
+        await new Promise((p) => setTimeout(p, 100));
+      r(!0), i(null);
+      try {
+        return await e.addFilesToProject(f, m);
+      } catch (p) {
+        return i(p instanceof Error ? p : new Error(String(p))), null;
+      } finally {
+        r(!1);
+      }
+    },
+    getFilesForProject: async (f) => {
+      for (; !e; )
+        await new Promise((m) => setTimeout(m, 100));
+      r(!0), i(null);
+      try {
+        return await e.getFilesForProject(f);
+      } catch (m) {
+        return i(m instanceof Error ? m : new Error(String(m))), [];
+      } finally {
+        r(!1);
+      }
+    }
+  };
+}
+export {
+  Qn as FolioEmbed,
+  Zn as FolioProvider,
+  eo as useFolio
+};