@noxickon/onyx 0.0.2 → 0.0.4-dev.2

package/dist/chunks/useQuery-BvCyJMae.js

@@ -0,0 +1,2065 @@
+import { g as gt } from "./_commonjsHelpers-C6fGbg64.js";
+import bt from "react";
+function mt(e, t) {
+  for (var r = 0; r < t.length; r++) {
+    const n = t[r];
+    if (typeof n != "string" && !Array.isArray(n)) {
+      for (const i in n)
+        if (i !== "default" && !(i in e)) {
+          const o = Object.getOwnPropertyDescriptor(n, i);
+          o && Object.defineProperty(e, i, o.get ? o : {
+            enumerable: !0,
+            get: () => n[i]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(e, Symbol.toStringTag, { value: "Module" }));
+}
+var Z = function(e, t) {
+  return Z = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(r, n) {
+    r.__proto__ = n;
+  } || function(r, n) {
+    for (var i in n) Object.prototype.hasOwnProperty.call(n, i) && (r[i] = n[i]);
+  }, Z(e, t);
+};
+function ce(e, t) {
+  if (typeof t != "function" && t !== null)
+    throw new TypeError("Class extends value " + String(t) + " is not a constructor or null");
+  Z(e, t);
+  function r() {
+    this.constructor = e;
+  }
+  e.prototype = t === null ? Object.create(t) : (r.prototype = t.prototype, new r());
+}
+var p = function() {
+  return p = Object.assign || function(t) {
+    for (var r, n = 1, i = arguments.length; n < i; n++) {
+      r = arguments[n];
+      for (var o in r) Object.prototype.hasOwnProperty.call(r, o) && (t[o] = r[o]);
+    }
+    return t;
+  }, p.apply(this, arguments);
+};
+function W(e, t) {
+  var r = {};
+  for (var n in e) Object.prototype.hasOwnProperty.call(e, n) && t.indexOf(n) < 0 && (r[n] = e[n]);
+  if (e != null && typeof Object.getOwnPropertySymbols == "function")
+    for (var i = 0, n = Object.getOwnPropertySymbols(e); i < n.length; i++)
+      t.indexOf(n[i]) < 0 && Object.prototype.propertyIsEnumerable.call(e, n[i]) && (r[n[i]] = e[n[i]]);
+  return r;
+}
+function T(e, t, r) {
+  if (r || arguments.length === 2) for (var n = 0, i = t.length, o; n < i; n++)
+    (o || !(n in t)) && (o || (o = Array.prototype.slice.call(t, 0, n)), o[n] = t[n]);
+  return e.concat(o || Array.prototype.slice.call(t));
+}
+var B = "Invariant Violation", be = Object.setPrototypeOf, wt = be === void 0 ? function(e, t) {
+  return e.__proto__ = t, e;
+} : be, We = (
+  /** @class */
+  function(e) {
+    ce(t, e);
+    function t(r) {
+      r === void 0 && (r = B);
+      var n = e.call(this, typeof r == "number" ? B + ": " + r + " (see https://github.com/apollographql/invariant-packages)" : r) || this;
+      return n.framesToPop = 1, n.name = B, wt(n, t.prototype), n;
+    }
+    return t;
+  }(Error)
+);
+function q(e, t) {
+  if (!e)
+    throw new We(t);
+}
+var $e = ["debug", "log", "warn", "error", "silent"], _t = $e.indexOf("log");
+function A(e) {
+  return function() {
+    if ($e.indexOf(e) >= _t) {
+      var t = console[e] || console.log;
+      return t.apply(console, arguments);
+    }
+  };
+}
+(function(e) {
+  e.debug = A("debug"), e.log = A("log"), e.warn = A("warn"), e.error = A("error");
+})(q || (q = {}));
+var Be = "3.13.8";
+function P(e) {
+  try {
+    return e();
+  } catch {
+  }
+}
+const ee = P(function() {
+  return globalThis;
+}) || P(function() {
+  return window;
+}) || P(function() {
+  return self;
+}) || P(function() {
+  return global;
+}) || // We don't expect the Function constructor ever to be invoked at runtime, as
+// long as at least one of globalThis, window, self, or global is defined, so
+// we are under no obligation to make it easy for static analysis tools to
+// detect syntactic usage of the Function constructor. If you think you can
+// improve your static analysis to detect this obfuscation, think again. This
+// is an arms race you cannot win, at least not in JavaScript.
+P(function() {
+  return P.constructor("return this")();
+});
+var me = /* @__PURE__ */ new Map();
+function Ot(e) {
+  var t = me.get(e) || 1;
+  return me.set(e, t + 1), "".concat(e, ":").concat(t, ":").concat(Math.random().toString(36).slice(2));
+}
+function St(e, t) {
+  var r = Ot("stringifyForDisplay");
+  return JSON.stringify(e, function(n, i) {
+    return i === void 0 ? r : i;
+  }, t).split(JSON.stringify(r)).join("<undefined>");
+}
+function N(e) {
+  return function(t) {
+    for (var r = [], n = 1; n < arguments.length; n++)
+      r[n - 1] = arguments[n];
+    if (typeof t == "number") {
+      var i = t;
+      t = fe(i), t || (t = le(i, r), r = []);
+    }
+    e.apply(void 0, [t].concat(r));
+  };
+}
+var b = Object.assign(function(t, r) {
+  for (var n = [], i = 2; i < arguments.length; i++)
+    n[i - 2] = arguments[i];
+  t || q(t, fe(r, n) || le(r, n));
+}, {
+  debug: N(q.debug),
+  log: N(q.log),
+  warn: N(q.warn),
+  error: N(q.error)
+});
+function Ge(e) {
+  for (var t = [], r = 1; r < arguments.length; r++)
+    t[r - 1] = arguments[r];
+  return new We(fe(e, t) || le(e, t));
+}
+var we = Symbol.for("ApolloErrorMessageHandler_" + Be);
+function He(e) {
+  if (typeof e == "string")
+    return e;
+  try {
+    return St(e, 2).slice(0, 1e3);
+  } catch {
+    return "<non-serializable>";
+  }
+}
+function fe(e, t) {
+  if (t === void 0 && (t = []), !!e)
+    return ee[we] && ee[we](e, t.map(He));
+}
+function le(e, t) {
+  if (t === void 0 && (t = []), !!e)
+    return "An error occurred! For more details, see the full error text at https://go.apollo.dev/c/err#".concat(encodeURIComponent(JSON.stringify({
+      version: Be,
+      message: e,
+      args: t.map(He)
+    })));
+}
+function Et(e, t) {
+  var r = e.directives;
+  return !r || !r.length ? !0 : kt(r).every(function(n) {
+    var i = n.directive, o = n.ifArgument, a = !1;
+    return o.value.kind === "Variable" ? (a = t && t[o.value.name.value], b(a !== void 0, 78, i.name.value)) : a = o.value.value, i.name.value === "skip" ? !a : a;
+  });
+}
+function Pt(e) {
+  var t = e.name.value;
+  return t === "skip" || t === "include";
+}
+function kt(e) {
+  var t = [];
+  return e && e.length && e.forEach(function(r) {
+    if (Pt(r)) {
+      var n = r.arguments, i = r.name.value;
+      b(n && n.length === 1, 79, i);
+      var o = n[0];
+      b(o.name && o.name.value === "if", 80, i);
+      var a = o.value;
+      b(a && (a.kind === "Variable" || a.kind === "BooleanValue"), 81, i), t.push({ directive: r, ifArgument: o });
+    }
+  }), t;
+}
+var qt = P(function() {
+  return navigator.product;
+}) == "ReactNative", Je = typeof Symbol == "function" && typeof Symbol.for == "function", Dt = typeof P(function() {
+  return window.document.createElement;
+}) == "function", It = (
+  // Following advice found in this comment from @domenic (maintainer of jsdom):
+  // https://github.com/jsdom/jsdom/issues/1537#issuecomment-229405327
+  //
+  // Since we control the version of Jest and jsdom used when running Apollo
+  // Client tests, and that version is recent enought to include " jsdom/x.y.z"
+  // at the end of the user agent string, I believe this case is all we need to
+  // check. Testing for "Node.js" was recommended for backwards compatibility
+  // with older version of jsdom, but we don't have that problem.
+  P(function() {
+    return navigator.userAgent.indexOf("jsdom") >= 0;
+  }) || !1
+), Ft = (Dt || qt) && !It;
+function te(e) {
+  return e !== null && typeof e == "object";
+}
+function jt(e) {
+  e === void 0 && (e = []);
+  var t = {};
+  return e.forEach(function(r) {
+    t[r.name.value] = r;
+  }), t;
+}
+function Tt(e, t) {
+  switch (e.kind) {
+    case "InlineFragment":
+      return e;
+    case "FragmentSpread": {
+      var r = e.name.value;
+      if (typeof t == "function")
+        return t(r);
+      var n = t && t[r];
+      return b(n, 87, r), n || null;
+    }
+    default:
+      return null;
+  }
+}
+function xt() {
+}
+class _e {
+  constructor(t = 1 / 0, r = xt) {
+    this.max = t, this.dispose = r, this.map = /* @__PURE__ */ new Map(), this.newest = null, this.oldest = null;
+  }
+  has(t) {
+    return this.map.has(t);
+  }
+  get(t) {
+    const r = this.getNode(t);
+    return r && r.value;
+  }
+  get size() {
+    return this.map.size;
+  }
+  getNode(t) {
+    const r = this.map.get(t);
+    if (r && r !== this.newest) {
+      const { older: n, newer: i } = r;
+      i && (i.older = n), n && (n.newer = i), r.older = this.newest, r.older.newer = r, r.newer = null, this.newest = r, r === this.oldest && (this.oldest = i);
+    }
+    return r;
+  }
+  set(t, r) {
+    let n = this.getNode(t);
+    return n ? n.value = r : (n = {
+      key: t,
+      value: r,
+      newer: null,
+      older: this.newest
+    }, this.newest && (this.newest.newer = n), this.newest = n, this.oldest = this.oldest || n, this.map.set(t, n), n.value);
+  }
+  clean() {
+    for (; this.oldest && this.map.size > this.max; )
+      this.delete(this.oldest.key);
+  }
+  delete(t) {
+    const r = this.map.get(t);
+    return r ? (r === this.newest && (this.newest = r.older), r === this.oldest && (this.oldest = r.newer), r.newer && (r.newer.older = r.older), r.older && (r.older.newer = r.newer), this.map.delete(t), this.dispose(r.value, t), !0) : !1;
+  }
+}
+function re() {
+}
+const Mt = re, Rt = typeof WeakRef < "u" ? WeakRef : function(e) {
+  return { deref: () => e };
+}, Ct = typeof WeakMap < "u" ? WeakMap : Map, Qt = typeof FinalizationRegistry < "u" ? FinalizationRegistry : function() {
+  return {
+    register: re,
+    unregister: re
+  };
+}, At = 10024;
+class Oe {
+  constructor(t = 1 / 0, r = Mt) {
+    this.max = t, this.dispose = r, this.map = new Ct(), this.newest = null, this.oldest = null, this.unfinalizedNodes = /* @__PURE__ */ new Set(), this.finalizationScheduled = !1, this.size = 0, this.finalize = () => {
+      const n = this.unfinalizedNodes.values();
+      for (let i = 0; i < At; i++) {
+        const o = n.next().value;
+        if (!o)
+          break;
+        this.unfinalizedNodes.delete(o);
+        const a = o.key;
+        delete o.key, o.keyRef = new Rt(a), this.registry.register(a, o, o);
+      }
+      this.unfinalizedNodes.size > 0 ? queueMicrotask(this.finalize) : this.finalizationScheduled = !1;
+    }, this.registry = new Qt(this.deleteNode.bind(this));
+  }
+  has(t) {
+    return this.map.has(t);
+  }
+  get(t) {
+    const r = this.getNode(t);
+    return r && r.value;
+  }
+  getNode(t) {
+    const r = this.map.get(t);
+    if (r && r !== this.newest) {
+      const { older: n, newer: i } = r;
+      i && (i.older = n), n && (n.newer = i), r.older = this.newest, r.older.newer = r, r.newer = null, this.newest = r, r === this.oldest && (this.oldest = i);
+    }
+    return r;
+  }
+  set(t, r) {
+    let n = this.getNode(t);
+    return n ? n.value = r : (n = {
+      key: t,
+      value: r,
+      newer: null,
+      older: this.newest
+    }, this.newest && (this.newest.newer = n), this.newest = n, this.oldest = this.oldest || n, this.scheduleFinalization(n), this.map.set(t, n), this.size++, n.value);
+  }
+  clean() {
+    for (; this.oldest && this.size > this.max; )
+      this.deleteNode(this.oldest);
+  }
+  deleteNode(t) {
+    t === this.newest && (this.newest = t.older), t === this.oldest && (this.oldest = t.newer), t.newer && (t.newer.older = t.older), t.older && (t.older.newer = t.newer), this.size--;
+    const r = t.key || t.keyRef && t.keyRef.deref();
+    this.dispose(t.value, r), t.keyRef ? this.registry.unregister(t) : this.unfinalizedNodes.delete(t), r && this.map.delete(r);
+  }
+  delete(t) {
+    const r = this.map.get(t);
+    return r ? (this.deleteNode(r), !0) : !1;
+  }
+  scheduleFinalization(t) {
+    this.unfinalizedNodes.add(t), this.finalizationScheduled || (this.finalizationScheduled = !0, queueMicrotask(this.finalize));
+  }
+}
+var G = /* @__PURE__ */ new WeakSet();
+function Ke(e) {
+  e.size <= (e.max || -1) || G.has(e) || (G.add(e), setTimeout(function() {
+    e.clean(), G.delete(e);
+  }, 100));
+}
+var Nt = function(e, t) {
+  var r = new Oe(e, t);
+  return r.set = function(n, i) {
+    var o = Oe.prototype.set.call(this, n, i);
+    return Ke(this), o;
+  }, r;
+}, zt = function(e, t) {
+  var r = new _e(e, t);
+  return r.set = function(n, i) {
+    var o = _e.prototype.set.call(this, n, i);
+    return Ke(this), o;
+  }, r;
+}, Lt = Symbol.for("apollo.cacheSize"), Ye = p({}, ee[Lt]), Vt = {};
+function Xe(e, t) {
+  Vt[e] = t;
+}
+var Ze = Object.assign(function(t) {
+  return JSON.stringify(t, Ut);
+}, {
+  reset: function() {
+    j = new zt(
+      Ye.canonicalStringify || 1e3
+      /* defaultCacheSizes.canonicalStringify */
+    );
+  }
+});
+globalThis.__DEV__ !== !1 && Xe("canonicalStringify", function() {
+  return j.size;
+});
+var j;
+Ze.reset();
+function Ut(e, t) {
+  if (t && typeof t == "object") {
+    var r = Object.getPrototypeOf(t);
+    if (r === Object.prototype || r === null) {
+      var n = Object.keys(t);
+      if (n.every(Wt))
+        return t;
+      var i = JSON.stringify(n), o = j.get(i);
+      if (!o) {
+        n.sort();
+        var a = JSON.stringify(n);
+        o = j.get(a) || n, j.set(i, o), j.set(a, o);
+      }
+      var s = Object.create(r);
+      return o.forEach(function(u) {
+        s[u] = t[u];
+      }), s;
+    }
+  }
+  return t;
+}
+function Wt(e, t, r) {
+  return t === 0 || r[t - 1] <= e;
+}
+var $t = [
+  "connection",
+  "include",
+  "skip",
+  "client",
+  "rest",
+  "export",
+  "nonreactive"
+], R = Ze;
+Object.assign(function(e, t, r) {
+  if (t && r && r.connection && r.connection.key)
+    if (r.connection.filter && r.connection.filter.length > 0) {
+      var n = r.connection.filter ? r.connection.filter : [];
+      n.sort();
+      var i = {};
+      return n.forEach(function(s) {
+        i[s] = t[s];
+      }), "".concat(r.connection.key, "(").concat(R(i), ")");
+    } else
+      return r.connection.key;
+  var o = e;
+  if (t) {
+    var a = R(t);
+    o += "(".concat(a, ")");
+  }
+  return r && Object.keys(r).forEach(function(s) {
+    $t.indexOf(s) === -1 && (r[s] && Object.keys(r[s]).length ? o += "@".concat(s, "(").concat(R(r[s]), ")") : o += "@".concat(s));
+  }), o;
+}, {
+  setStringify: function(e) {
+    var t = R;
+    return R = e, t;
+  }
+});
+function Bt(e) {
+  return e.alias ? e.alias.value : e.name.value;
+}
+function Gt(e) {
+  return e.kind === "Field";
+}
+function et(e) {
+  b(e && e.kind === "Document", 88);
+  var t = e.definitions.filter(function(r) {
+    return r.kind !== "FragmentDefinition";
+  }).map(function(r) {
+    if (r.kind !== "OperationDefinition")
+      throw Ge(89, r.kind);
+    return r;
+  });
+  return b(t.length <= 1, 90, t.length), e;
+}
+function tt(e) {
+  return et(e), e.definitions.filter(function(t) {
+    return t.kind === "OperationDefinition";
+  })[0];
+}
+function Ht(e) {
+  return e.definitions.filter(function(t) {
+    return t.kind === "FragmentDefinition";
+  });
+}
+function Jt(e) {
+  var t = tt(e);
+  return b(t && t.operation === "query", 91), t;
+}
+function Kt(e) {
+  et(e);
+  for (var t, r = 0, n = e.definitions; r < n.length; r++) {
+    var i = n[r];
+    if (i.kind === "OperationDefinition") {
+      var o = i.operation;
+      if (o === "query" || o === "mutation" || o === "subscription")
+        return i;
+    }
+    i.kind === "FragmentDefinition" && !t && (t = i);
+  }
+  if (t)
+    return t;
+  throw Ge(95);
+}
+let m = null;
+const Se = {};
+let Yt = 1;
+const Xt = () => class {
+  constructor() {
+    this.id = [
+      "slot",
+      Yt++,
+      Date.now(),
+      Math.random().toString(36).slice(2)
+    ].join(":");
+  }
+  hasValue() {
+    for (let t = m; t; t = t.parent)
+      if (this.id in t.slots) {
+        const r = t.slots[this.id];
+        if (r === Se)
+          break;
+        return t !== m && (m.slots[this.id] = r), !0;
+      }
+    return m && (m.slots[this.id] = Se), !1;
+  }
+  getValue() {
+    if (this.hasValue())
+      return m.slots[this.id];
+  }
+  withValue(t, r, n, i) {
+    const o = {
+      __proto__: null,
+      [this.id]: t
+    }, a = m;
+    m = { parent: a, slots: o };
+    try {
+      return r.apply(i, n);
+    } finally {
+      m = a;
+    }
+  }
+  // Capture the current context and wrap a callback function so that it
+  // reestablishes the captured context when called.
+  static bind(t) {
+    const r = m;
+    return function() {
+      const n = m;
+      try {
+        return m = r, t.apply(this, arguments);
+      } finally {
+        m = n;
+      }
+    };
+  }
+  // Immediately run a callback function without any captured context.
+  static noContext(t, r, n) {
+    if (m) {
+      const i = m;
+      try {
+        return m = null, t.apply(n, r);
+      } finally {
+        m = i;
+      }
+    } else
+      return t.apply(n, r);
+  }
+};
+function Ee(e) {
+  try {
+    return e();
+  } catch {
+  }
+}
+const H = "@wry/context:Slot", Zt = (
+  // Prefer globalThis when available.
+  // https://github.com/benjamn/wryware/issues/347
+  Ee(() => globalThis) || // Fall back to global, which works in Node.js and may be converted by some
+  // bundlers to the appropriate identifier (window, self, ...) depending on the
+  // bundling target. https://github.com/endojs/endo/issues/576#issuecomment-1178515224
+  Ee(() => global) || // Otherwise, use a dummy host that's local to this module. We used to fall
+  // back to using the Array constructor as a namespace, but that was flagged in
+  // https://github.com/benjamn/wryware/issues/347, and can be avoided.
+  /* @__PURE__ */ Object.create(null)
+), Pe = Zt, he = Pe[H] || // Earlier versions of this package stored the globalKey property on the Array
+// constructor, so we check there as well, to prevent Slot class duplication.
+Array[H] || function(e) {
+  try {
+    Object.defineProperty(Pe, H, {
+      value: e,
+      enumerable: !1,
+      writable: !1,
+      // When it was possible for globalHost to be the Array constructor (a
+      // legacy Slot dedup strategy), it was important for the property to be
+      // configurable:true so it could be deleted. That does not seem to be as
+      // important when globalHost is the global object, but I don't want to
+      // cause similar problems again, and configurable:true seems safest.
+      // https://github.com/endojs/endo/issues/576#issuecomment-1178274008
+      configurable: !0
+    });
+  } finally {
+    return e;
+  }
+}(Xt()), { bind: Kr, noContext: Yr } = he;
+new he();
+function rt(e) {
+  return Array.isArray(e) && e.length > 0;
+}
+function er(e, t) {
+  var r = typeof Symbol < "u" && e[Symbol.iterator] || e["@@iterator"];
+  if (r) return (r = r.call(e)).next.bind(r);
+  if (Array.isArray(e) || (r = tr(e)) || t) {
+    r && (e = r);
+    var n = 0;
+    return function() {
+      return n >= e.length ? { done: !0 } : { done: !1, value: e[n++] };
+    };
+  }
+  throw new TypeError(`Invalid attempt to iterate non-iterable instance.
+In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`);
+}
+function tr(e, t) {
+  if (e) {
+    if (typeof e == "string") return ke(e, t);
+    var r = Object.prototype.toString.call(e).slice(8, -1);
+    if (r === "Object" && e.constructor && (r = e.constructor.name), r === "Map" || r === "Set") return Array.from(e);
+    if (r === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(r)) return ke(e, t);
+  }
+}
+function ke(e, t) {
+  (t == null || t > e.length) && (t = e.length);
+  for (var r = 0, n = new Array(t); r < t; r++)
+    n[r] = e[r];
+  return n;
+}
+function qe(e, t) {
+  for (var r = 0; r < t.length; r++) {
+    var n = t[r];
+    n.enumerable = n.enumerable || !1, n.configurable = !0, "value" in n && (n.writable = !0), Object.defineProperty(e, n.key, n);
+  }
+}
+function pe(e, t, r) {
+  return t && qe(e.prototype, t), r && qe(e, r), Object.defineProperty(e, "prototype", { writable: !1 }), e;
+}
+var ye = function() {
+  return typeof Symbol == "function";
+}, ve = function(e) {
+  return ye() && !!Symbol[e];
+}, de = function(e) {
+  return ve(e) ? Symbol[e] : "@@" + e;
+};
+ye() && !ve("observable") && (Symbol.observable = Symbol("observable"));
+var rr = de("iterator"), ne = de("observable"), nt = de("species");
+function $(e, t) {
+  var r = e[t];
+  if (r != null) {
+    if (typeof r != "function") throw new TypeError(r + " is not a function");
+    return r;
+  }
+}
+function C(e) {
+  var t = e.constructor;
+  return t !== void 0 && (t = t[nt], t === null && (t = void 0)), t !== void 0 ? t : M;
+}
+function nr(e) {
+  return e instanceof M;
+}
+function x(e) {
+  x.log ? x.log(e) : setTimeout(function() {
+    throw e;
+  });
+}
+function L(e) {
+  Promise.resolve().then(function() {
+    try {
+      e();
+    } catch (t) {
+      x(t);
+    }
+  });
+}
+function it(e) {
+  var t = e._cleanup;
+  if (t !== void 0 && (e._cleanup = void 0, !!t))
+    try {
+      if (typeof t == "function")
+        t();
+      else {
+        var r = $(t, "unsubscribe");
+        r && r.call(t);
+      }
+    } catch (n) {
+      x(n);
+    }
+}
+function ie(e) {
+  e._observer = void 0, e._queue = void 0, e._state = "closed";
+}
+function ir(e) {
+  var t = e._queue;
+  if (t) {
+    e._queue = void 0, e._state = "ready";
+    for (var r = 0; r < t.length && (ot(e, t[r].type, t[r].value), e._state !== "closed"); ++r)
+      ;
+  }
+}
+function ot(e, t, r) {
+  e._state = "running";
+  var n = e._observer;
+  try {
+    var i = $(n, t);
+    switch (t) {
+      case "next":
+        i && i.call(n, r);
+        break;
+      case "error":
+        if (ie(e), i) i.call(n, r);
+        else throw r;
+        break;
+      case "complete":
+        ie(e), i && i.call(n);
+        break;
+    }
+  } catch (o) {
+    x(o);
+  }
+  e._state === "closed" ? it(e) : e._state === "running" && (e._state = "ready");
+}
+function J(e, t, r) {
+  if (e._state !== "closed") {
+    if (e._state === "buffering") {
+      e._queue.push({
+        type: t,
+        value: r
+      });
+      return;
+    }
+    if (e._state !== "ready") {
+      e._state = "buffering", e._queue = [{
+        type: t,
+        value: r
+      }], L(function() {
+        return ir(e);
+      });
+      return;
+    }
+    ot(e, t, r);
+  }
+}
+var or = /* @__PURE__ */ function() {
+  function e(r, n) {
+    this._cleanup = void 0, this._observer = r, this._queue = void 0, this._state = "initializing";
+    var i = new ar(this);
+    try {
+      this._cleanup = n.call(void 0, i);
+    } catch (o) {
+      i.error(o);
+    }
+    this._state === "initializing" && (this._state = "ready");
+  }
+  var t = e.prototype;
+  return t.unsubscribe = function() {
+    this._state !== "closed" && (ie(this), it(this));
+  }, pe(e, [{
+    key: "closed",
+    get: function() {
+      return this._state === "closed";
+    }
+  }]), e;
+}(), ar = /* @__PURE__ */ function() {
+  function e(r) {
+    this._subscription = r;
+  }
+  var t = e.prototype;
+  return t.next = function(n) {
+    J(this._subscription, "next", n);
+  }, t.error = function(n) {
+    J(this._subscription, "error", n);
+  }, t.complete = function() {
+    J(this._subscription, "complete");
+  }, pe(e, [{
+    key: "closed",
+    get: function() {
+      return this._subscription._state === "closed";
+    }
+  }]), e;
+}(), M = /* @__PURE__ */ function() {
+  function e(r) {
+    if (!(this instanceof e)) throw new TypeError("Observable cannot be called as a function");
+    if (typeof r != "function") throw new TypeError("Observable initializer must be a function");
+    this._subscriber = r;
+  }
+  var t = e.prototype;
+  return t.subscribe = function(n) {
+    return (typeof n != "object" || n === null) && (n = {
+      next: n,
+      error: arguments[1],
+      complete: arguments[2]
+    }), new or(n, this._subscriber);
+  }, t.forEach = function(n) {
+    var i = this;
+    return new Promise(function(o, a) {
+      if (typeof n != "function") {
+        a(new TypeError(n + " is not a function"));
+        return;
+      }
+      function s() {
+        u.unsubscribe(), o();
+      }
+      var u = i.subscribe({
+        next: function(c) {
+          try {
+            n(c, s);
+          } catch (f) {
+            a(f), u.unsubscribe();
+          }
+        },
+        error: a,
+        complete: o
+      });
+    });
+  }, t.map = function(n) {
+    var i = this;
+    if (typeof n != "function") throw new TypeError(n + " is not a function");
+    var o = C(this);
+    return new o(function(a) {
+      return i.subscribe({
+        next: function(s) {
+          try {
+            s = n(s);
+          } catch (u) {
+            return a.error(u);
+          }
+          a.next(s);
+        },
+        error: function(s) {
+          a.error(s);
+        },
+        complete: function() {
+          a.complete();
+        }
+      });
+    });
+  }, t.filter = function(n) {
+    var i = this;
+    if (typeof n != "function") throw new TypeError(n + " is not a function");
+    var o = C(this);
+    return new o(function(a) {
+      return i.subscribe({
+        next: function(s) {
+          try {
+            if (!n(s)) return;
+          } catch (u) {
+            return a.error(u);
+          }
+          a.next(s);
+        },
+        error: function(s) {
+          a.error(s);
+        },
+        complete: function() {
+          a.complete();
+        }
+      });
+    });
+  }, t.reduce = function(n) {
+    var i = this;
+    if (typeof n != "function") throw new TypeError(n + " is not a function");
+    var o = C(this), a = arguments.length > 1, s = !1, u = arguments[1], c = u;
+    return new o(function(f) {
+      return i.subscribe({
+        next: function(l) {
+          var h = !s;
+          if (s = !0, !h || a)
+            try {
+              c = n(c, l);
+            } catch (y) {
+              return f.error(y);
+            }
+          else
+            c = l;
+        },
+        error: function(l) {
+          f.error(l);
+        },
+        complete: function() {
+          if (!s && !a) return f.error(new TypeError("Cannot reduce an empty sequence"));
+          f.next(c), f.complete();
+        }
+      });
+    });
+  }, t.concat = function() {
+    for (var n = this, i = arguments.length, o = new Array(i), a = 0; a < i; a++)
+      o[a] = arguments[a];
+    var s = C(this);
+    return new s(function(u) {
+      var c, f = 0;
+      function l(h) {
+        c = h.subscribe({
+          next: function(y) {
+            u.next(y);
+          },
+          error: function(y) {
+            u.error(y);
+          },
+          complete: function() {
+            f === o.length ? (c = void 0, u.complete()) : l(s.from(o[f++]));
+          }
+        });
+      }
+      return l(n), function() {
+        c && (c.unsubscribe(), c = void 0);
+      };
+    });
+  }, t.flatMap = function(n) {
+    var i = this;
+    if (typeof n != "function") throw new TypeError(n + " is not a function");
+    var o = C(this);
+    return new o(function(a) {
+      var s = [], u = i.subscribe({
+        next: function(f) {
+          if (n)
+            try {
+              f = n(f);
+            } catch (h) {
+              return a.error(h);
+            }
+          var l = o.from(f).subscribe({
+            next: function(h) {
+              a.next(h);
+            },
+            error: function(h) {
+              a.error(h);
+            },
+            complete: function() {
+              var h = s.indexOf(l);
+              h >= 0 && s.splice(h, 1), c();
+            }
+          });
+          s.push(l);
+        },
+        error: function(f) {
+          a.error(f);
+        },
+        complete: function() {
+          c();
+        }
+      });
+      function c() {
+        u.closed && s.length === 0 && a.complete();
+      }
+      return function() {
+        s.forEach(function(f) {
+          return f.unsubscribe();
+        }), u.unsubscribe();
+      };
+    });
+  }, t[ne] = function() {
+    return this;
+  }, e.from = function(n) {
+    var i = typeof this == "function" ? this : e;
+    if (n == null) throw new TypeError(n + " is not an object");
+    var o = $(n, ne);
+    if (o) {
+      var a = o.call(n);
+      if (Object(a) !== a) throw new TypeError(a + " is not an object");
+      return nr(a) && a.constructor === i ? a : new i(function(s) {
+        return a.subscribe(s);
+      });
+    }
+    if (ve("iterator") && (o = $(n, rr), o))
+      return new i(function(s) {
+        L(function() {
+          if (!s.closed) {
+            for (var u = er(o.call(n)), c; !(c = u()).done; ) {
+              var f = c.value;
+              if (s.next(f), s.closed) return;
+            }
+            s.complete();
+          }
+        });
+      });
+    if (Array.isArray(n))
+      return new i(function(s) {
+        L(function() {
+          if (!s.closed) {
+            for (var u = 0; u < n.length; ++u)
+              if (s.next(n[u]), s.closed) return;
+            s.complete();
+          }
+        });
+      });
+    throw new TypeError(n + " is not observable");
+  }, e.of = function() {
+    for (var n = arguments.length, i = new Array(n), o = 0; o < n; o++)
+      i[o] = arguments[o];
+    var a = typeof this == "function" ? this : e;
+    return new a(function(s) {
+      L(function() {
+        if (!s.closed) {
+          for (var u = 0; u < i.length; ++u)
+            if (s.next(i[u]), s.closed) return;
+          s.complete();
+        }
+      });
+    });
+  }, pe(e, null, [{
+    key: nt,
+    get: function() {
+      return this;
+    }
+  }]), e;
+}();
+ye() && Object.defineProperty(M, Symbol("extensions"), {
+  value: {
+    symbol: ne,
+    hostReportError: x
+  },
+  configurable: !0
+});
+function sr(e) {
+  var t, r = e.Symbol;
+  if (typeof r == "function")
+    if (r.observable)
+      t = r.observable;
+    else {
+      typeof r.for == "function" ? t = r.for("https://github.com/benlesh/symbol-observable") : t = r("https://github.com/benlesh/symbol-observable");
+      try {
+        r.observable = t;
+      } catch {
+      }
+    }
+  else
+    t = "@@observable";
+  return t;
+}
+var F;
+typeof self < "u" ? F = self : typeof window < "u" ? F = window : typeof global < "u" ? F = global : typeof module < "u" ? F = module : F = Function("return this")();
+sr(F);
+var De = M.prototype, Ie = "@@observable";
+De[Ie] || (De[Ie] = function() {
+  return this;
+});
+function ur(e) {
+  return e.catch(function() {
+  }), e;
+}
+var cr = Object.prototype.toString;
+function fr(e) {
+  return oe(e);
+}
+function oe(e, t) {
+  switch (cr.call(e)) {
+    case "[object Array]": {
+      if (t = t || /* @__PURE__ */ new Map(), t.has(e))
+        return t.get(e);
+      var r = e.slice(0);
+      return t.set(e, r), r.forEach(function(i, o) {
+        r[o] = oe(i, t);
+      }), r;
+    }
+    case "[object Object]": {
+      if (t = t || /* @__PURE__ */ new Map(), t.has(e))
+        return t.get(e);
+      var n = Object.create(Object.getPrototypeOf(e));
+      return t.set(e, n), Object.keys(e).forEach(function(i) {
+        n[i] = oe(e[i], t);
+      }), n;
+    }
+    default:
+      return e;
+  }
+}
+function lr(e) {
+  var t = /* @__PURE__ */ new Set([e]);
+  return t.forEach(function(r) {
+    te(r) && hr(r) === r && Object.getOwnPropertyNames(r).forEach(function(n) {
+      te(r[n]) && t.add(r[n]);
+    });
+  }), e;
+}
+function hr(e) {
+  if (globalThis.__DEV__ !== !1 && !Object.isFrozen(e))
+    try {
+      Object.freeze(e);
+    } catch (t) {
+      if (t instanceof TypeError)
+        return null;
+      throw t;
+    }
+  return e;
+}
+function at(e) {
+  return globalThis.__DEV__ !== !1 && lr(e), e;
+}
+function Fe(e, t, r) {
+  var n = [];
+  e.forEach(function(i) {
+    return i[t] && n.push(i);
+  }), n.forEach(function(i) {
+    return i[t](r);
+  });
+}
+function pr(e) {
+  function t(r) {
+    Object.defineProperty(e, r, { value: M });
+  }
+  return Je && Symbol.species && t(Symbol.species), t("@@species"), e;
+}
+function Q() {
+  for (var e = [], t = 0; t < arguments.length; t++)
+    e[t] = arguments[t];
+  var r = /* @__PURE__ */ Object.create(null);
+  return e.forEach(function(n) {
+    n && Object.keys(n).forEach(function(i) {
+      var o = n[i];
+      o !== void 0 && (r[i] = o);
+    });
+  }), r;
+}
+function yr(e, t) {
+  return Q(e, t, t.variables && {
+    variables: Q(p(p({}, e && e.variables), t.variables))
+  });
+}
+function vr(e) {
+  return e.hasOwnProperty("graphQLErrors");
+}
+var dr = function(e) {
+  var t = T(T(T([], e.graphQLErrors, !0), e.clientErrors, !0), e.protocolErrors, !0);
+  return e.networkError && t.push(e.networkError), t.map(function(r) {
+    return te(r) && r.message || "Error message not found.";
+  }).join(`
+`);
+}, ge = (
+  /** @class */
+  function(e) {
+    ce(t, e);
+    function t(r) {
+      var n = r.graphQLErrors, i = r.protocolErrors, o = r.clientErrors, a = r.networkError, s = r.errorMessage, u = r.extraInfo, c = e.call(this, s) || this;
+      return c.name = "ApolloError", c.graphQLErrors = n || [], c.protocolErrors = i || [], c.clientErrors = o || [], c.networkError = a || null, c.message = s || dr(c), c.extraInfo = u, c.cause = T(T(T([
+        a
+      ], n || [], !0), i || [], !0), o || [], !0).find(function(f) {
+        return !!f;
+      }) || null, c.__proto__ = t.prototype, c;
+    }
+    return t;
+  }(Error)
+);
+const { toString: je, hasOwnProperty: gr } = Object.prototype, Te = Function.prototype.toString, ae = /* @__PURE__ */ new Map();
+function O(e, t) {
+  try {
+    return se(e, t);
+  } finally {
+    ae.clear();
+  }
+}
+function se(e, t) {
+  if (e === t)
+    return !0;
+  const r = je.call(e), n = je.call(t);
+  if (r !== n)
+    return !1;
+  switch (r) {
+    case "[object Array]":
+      if (e.length !== t.length)
+        return !1;
+    // Fall through to object case...
+    case "[object Object]": {
+      if (Me(e, t))
+        return !0;
+      const i = xe(e), o = xe(t), a = i.length;
+      if (a !== o.length)
+        return !1;
+      for (let s = 0; s < a; ++s)
+        if (!gr.call(t, i[s]))
+          return !1;
+      for (let s = 0; s < a; ++s) {
+        const u = i[s];
+        if (!se(e[u], t[u]))
+          return !1;
+      }
+      return !0;
+    }
+    case "[object Error]":
+      return e.name === t.name && e.message === t.message;
+    case "[object Number]":
+      if (e !== e)
+        return t !== t;
+    // Fall through to shared +a === +b case...
+    case "[object Boolean]":
+    case "[object Date]":
+      return +e == +t;
+    case "[object RegExp]":
+    case "[object String]":
+      return e == `${t}`;
+    case "[object Map]":
+    case "[object Set]": {
+      if (e.size !== t.size)
+        return !1;
+      if (Me(e, t))
+        return !0;
+      const i = e.entries(), o = r === "[object Map]";
+      for (; ; ) {
+        const a = i.next();
+        if (a.done)
+          break;
+        const [s, u] = a.value;
+        if (!t.has(s) || o && !se(u, t.get(s)))
+          return !1;
+      }
+      return !0;
+    }
+    case "[object Uint16Array]":
+    case "[object Uint8Array]":
+    // Buffer, in Node.js.
+    case "[object Uint32Array]":
+    case "[object Int32Array]":
+    case "[object Int8Array]":
+    case "[object Int16Array]":
+    case "[object ArrayBuffer]":
+      e = new Uint8Array(e), t = new Uint8Array(t);
+    // Fall through...
+    case "[object DataView]": {
+      let i = e.byteLength;
+      if (i === t.byteLength)
+        for (; i-- && e[i] === t[i]; )
+          ;
+      return i === -1;
+    }
+    case "[object AsyncFunction]":
+    case "[object GeneratorFunction]":
+    case "[object AsyncGeneratorFunction]":
+    case "[object Function]": {
+      const i = Te.call(e);
+      return i !== Te.call(t) ? !1 : !wr(i, mr);
+    }
+  }
+  return !1;
+}
+function xe(e) {
+  return Object.keys(e).filter(br, e);
+}
+function br(e) {
+  return this[e] !== void 0;
+}
+const mr = "{ [native code] }";
+function wr(e, t) {
+  const r = e.length - t.length;
+  return r >= 0 && e.indexOf(t, r) === r;
+}
+function Me(e, t) {
+  let r = ae.get(e);
+  if (r) {
+    if (r.has(t))
+      return !0;
+  } else
+    ae.set(e, r = /* @__PURE__ */ new Set());
+  return r.add(t), !1;
+}
+function _r(e, t, r, n) {
+  var i = t.data, o = W(t, ["data"]), a = r.data, s = W(r, ["data"]);
+  return O(o, s) && V(Kt(e).selectionSet, i, a, {
+    fragmentMap: jt(Ht(e)),
+    variables: n
+  });
+}
+function V(e, t, r, n) {
+  if (t === r)
+    return !0;
+  var i = /* @__PURE__ */ new Set();
+  return e.selections.every(function(o) {
+    if (i.has(o) || (i.add(o), !Et(o, n.variables)) || Re(o))
+      return !0;
+    if (Gt(o)) {
+      var a = Bt(o), s = t && t[a], u = r && r[a], c = o.selectionSet;
+      if (!c)
+        return O(s, u);
+      var f = Array.isArray(s), l = Array.isArray(u);
+      if (f !== l)
+        return !1;
+      if (f && l) {
+        var h = s.length;
+        if (u.length !== h)
+          return !1;
+        for (var y = 0; y < h; ++y)
+          if (!V(c, s[y], u[y], n))
+            return !1;
+        return !0;
+      }
+      return V(c, s, u, n);
+    } else {
+      var v = Tt(o, n.fragmentMap);
+      if (v)
+        return Re(v) ? !0 : V(
+          v.selectionSet,
+          // Notice that we reuse the same aResult and bResult values here,
+          // since the fragment ...spread does not specify a field name, but
+          // consists of multiple fields (within the fragment's selection set)
+          // that should be applied to the current result value(s).
+          t,
+          r,
+          n
+        );
+    }
+  });
+}
+function Re(e) {
+  return !!e.directives && e.directives.some(Or);
+}
+function Or(e) {
+  return e.name.value === "nonreactive";
+}
+var g;
+(function(e) {
+  e[e.loading = 1] = "loading", e[e.setVariables = 2] = "setVariables", e[e.fetchMore = 3] = "fetchMore", e[e.refetch = 4] = "refetch", e[e.poll = 6] = "poll", e[e.ready = 7] = "ready", e[e.error = 8] = "error";
+})(g || (g = {}));
+function z(e) {
+  return e ? e < 7 : !1;
+}
+var Ce = Object.assign, Sr = Object.hasOwnProperty, st = (
+  /** @class */
+  function(e) {
+    ce(t, e);
+    function t(r) {
+      var n = r.queryManager, i = r.queryInfo, o = r.options, a = this, s = t.inactiveOnCreation.getValue();
+      a = e.call(this, function(d) {
+        s && (n.queries.set(a.queryId, i), s = !1);
+        try {
+          var _ = d._subscription._observer;
+          _ && !_.error && (_.error = Er);
+        } catch {
+        }
+        var dt = !a.observers.size;
+        a.observers.add(d);
+        var I = a.last;
+        return I && I.error ? d.error && d.error(I.error) : I && I.result && d.next && d.next(a.maskResult(I.result)), dt && a.reobserve().catch(function() {
+        }), function() {
+          a.observers.delete(d) && !a.observers.size && a.tearDownQuery();
+        };
+      }) || this, a.observers = /* @__PURE__ */ new Set(), a.subscriptions = /* @__PURE__ */ new Set(), a.dirty = !1, a.queryInfo = i, a.queryManager = n, a.waitForOwnResult = K(o.fetchPolicy), a.isTornDown = !1, a.subscribeToMore = a.subscribeToMore.bind(a), a.maskResult = a.maskResult.bind(a);
+      var u = n.defaultOptions.watchQuery, c = u === void 0 ? {} : u, f = c.fetchPolicy, l = f === void 0 ? "cache-first" : f, h = o.fetchPolicy, y = h === void 0 ? l : h, v = o.initialFetchPolicy, E = v === void 0 ? y === "standby" ? l : y : v;
+      a.options = p(p({}, o), {
+        // Remember the initial options.fetchPolicy so we can revert back to this
+        // policy when variables change. This information can also be specified
+        // (or overridden) by providing options.initialFetchPolicy explicitly.
+        initialFetchPolicy: E,
+        // This ensures this.options.fetchPolicy always has a string value, in
+        // case options.fetchPolicy was not provided.
+        fetchPolicy: y
+      }), a.queryId = i.queryId || n.generateQueryId();
+      var S = tt(a.query);
+      return a.queryName = S && S.name && S.name.value, a;
+    }
+    return Object.defineProperty(t.prototype, "query", {
+      // The `query` computed property will always reflect the document transformed
+      // by the last run query. `this.options.query` will always reflect the raw
+      // untransformed query to ensure document transforms with runtime conditionals
+      // are run on the original document.
+      get: function() {
+        return this.lastQuery || this.options.query;
+      },
+      enumerable: !1,
+      configurable: !0
+    }), Object.defineProperty(t.prototype, "variables", {
+      // Computed shorthand for this.options.variables, preserved for
+      // backwards compatibility.
+      /**
+       * An object containing the variables that were provided for the query.
+       */
+      get: function() {
+        return this.options.variables;
+      },
+      enumerable: !1,
+      configurable: !0
+    }), t.prototype.result = function() {
+      var r = this;
+      return new Promise(function(n, i) {
+        var o = {
+          next: function(s) {
+            n(s), r.observers.delete(o), r.observers.size || r.queryManager.removeQuery(r.queryId), setTimeout(function() {
+              a.unsubscribe();
+            }, 0);
+          },
+          error: i
+        }, a = r.subscribe(o);
+      });
+    }, t.prototype.resetDiff = function() {
+      this.queryInfo.resetDiff();
+    }, t.prototype.getCurrentFullResult = function(r) {
+      r === void 0 && (r = !0);
+      var n = this.getLastResult(!0), i = this.queryInfo.networkStatus || n && n.networkStatus || g.ready, o = p(p({}, n), { loading: z(i), networkStatus: i }), a = this.options.fetchPolicy, s = a === void 0 ? "cache-first" : a;
+      if (
+        // These fetch policies should never deliver data from the cache, unless
+        // redelivering a previously delivered result.
+        !(K(s) || // If this.options.query has @client(always: true) fields, we cannot
+        // trust diff.result, since it was read from the cache without running
+        // local resolvers (and it's too late to run resolvers now, since we must
+        // return a result synchronously).
+        this.queryManager.getDocumentInfo(this.query).hasForcedResolvers)
+      ) if (this.waitForOwnResult)
+        this.queryInfo.updateWatch();
+      else {
+        var u = this.queryInfo.getDiff();
+        (u.complete || this.options.returnPartialData) && (o.data = u.result), O(o.data, {}) && (o.data = void 0), u.complete ? (delete o.partial, u.complete && o.networkStatus === g.loading && (s === "cache-first" || s === "cache-only") && (o.networkStatus = g.ready, o.loading = !1)) : o.partial = !0, o.networkStatus === g.ready && (o.error || o.errors) && (o.networkStatus = g.error), globalThis.__DEV__ !== !1 && !u.complete && !this.options.partialRefetch && !o.loading && !o.data && !o.error && Pr(u.missing);
+      }
+      return r && this.updateLastResult(o), o;
+    }, t.prototype.getCurrentResult = function(r) {
+      return r === void 0 && (r = !0), this.maskResult(this.getCurrentFullResult(r));
+    }, t.prototype.isDifferentFromLastResult = function(r, n) {
+      if (!this.last)
+        return !0;
+      var i = this.queryManager.getDocumentInfo(this.query), o = this.queryManager.dataMasking, a = o ? i.nonReactiveQuery : this.query, s = o || i.hasNonreactiveDirective ? !_r(a, this.last.result, r, this.variables) : !O(this.last.result, r);
+      return s || n && !O(this.last.variables, n);
+    }, t.prototype.getLast = function(r, n) {
+      var i = this.last;
+      if (i && i[r] && (!n || O(i.variables, this.variables)))
+        return i[r];
+    }, t.prototype.getLastResult = function(r) {
+      return this.getLast("result", r);
+    }, t.prototype.getLastError = function(r) {
+      return this.getLast("error", r);
+    }, t.prototype.resetLastResults = function() {
+      delete this.last, this.isTornDown = !1;
+    }, t.prototype.resetQueryStoreErrors = function() {
+      this.queryManager.resetErrors(this.queryId);
+    }, t.prototype.refetch = function(r) {
+      var n, i = {
+        // Always disable polling for refetches.
+        pollInterval: 0
+      }, o = this.options.fetchPolicy;
+      if (o === "no-cache" ? i.fetchPolicy = "no-cache" : i.fetchPolicy = "network-only", globalThis.__DEV__ !== !1 && r && Sr.call(r, "variables")) {
+        var a = Jt(this.query), s = a.variableDefinitions;
+        (!s || !s.some(function(u) {
+          return u.variable.name.value === "variables";
+        })) && globalThis.__DEV__ !== !1 && b.warn(
+          21,
+          r,
+          ((n = a.name) === null || n === void 0 ? void 0 : n.value) || a
+        );
+      }
+      return r && !O(this.options.variables, r) && (i.variables = this.options.variables = p(p({}, this.options.variables), r)), this.queryInfo.resetLastWrite(), this.reobserve(i, g.refetch);
+    }, t.prototype.fetchMore = function(r) {
+      var n = this, i = p(p({}, r.query ? r : p(p(p(p({}, this.options), { query: this.options.query }), r), { variables: p(p({}, this.options.variables), r.variables) })), {
+        // The fetchMore request goes immediately to the network and does
+        // not automatically write its result to the cache (hence no-cache
+        // instead of network-only), because we allow the caller of
+        // fetchMore to provide an updateQuery callback that determines how
+        // the data gets written to the cache.
+        fetchPolicy: "no-cache"
+      });
+      i.query = this.transformDocument(i.query);
+      var o = this.queryManager.generateQueryId();
+      this.lastQuery = r.query ? this.transformDocument(this.options.query) : i.query;
+      var a = this.queryInfo, s = a.networkStatus;
+      a.networkStatus = g.fetchMore, i.notifyOnNetworkStatusChange && this.observe();
+      var u = /* @__PURE__ */ new Set(), c = r?.updateQuery, f = this.options.fetchPolicy !== "no-cache";
+      return f || b(c, 22), this.queryManager.fetchQuery(o, i, g.fetchMore).then(function(l) {
+        if (n.queryManager.removeQuery(o), a.networkStatus === g.fetchMore && (a.networkStatus = s), f)
+          n.queryManager.cache.batch({
+            update: function(v) {
+              var E = r.updateQuery;
+              E ? v.updateQuery({
+                query: n.query,
+                variables: n.variables,
+                returnPartialData: !0,
+                optimistic: !1
+              }, function(S) {
+                return E(S, {
+                  fetchMoreResult: l.data,
+                  variables: i.variables
+                });
+              }) : v.writeQuery({
+                query: i.query,
+                variables: i.variables,
+                data: l.data
+              });
+            },
+            onWatchUpdated: function(v) {
+              u.add(v.query);
+            }
+          });
+        else {
+          var h = n.getLast("result"), y = c(h.data, {
+            fetchMoreResult: l.data,
+            variables: i.variables
+          });
+          n.reportResult(p(p({}, h), { networkStatus: s, loading: z(s), data: y }), n.variables);
+        }
+        return n.maskResult(l);
+      }).finally(function() {
+        f && !u.has(n.query) && n.reobserveCacheFirst();
+      });
+    }, t.prototype.subscribeToMore = function(r) {
+      var n = this, i = this.queryManager.startGraphQLSubscription({
+        query: r.document,
+        variables: r.variables,
+        context: r.context
+      }).subscribe({
+        next: function(o) {
+          var a = r.updateQuery;
+          a && n.updateQuery(function(s, u) {
+            return a(s, p({ subscriptionData: o }, u));
+          });
+        },
+        error: function(o) {
+          if (r.onError) {
+            r.onError(o);
+            return;
+          }
+          globalThis.__DEV__ !== !1 && b.error(23, o);
+        }
+      });
+      return this.subscriptions.add(i), function() {
+        n.subscriptions.delete(i) && i.unsubscribe();
+      };
+    }, t.prototype.setOptions = function(r) {
+      return this.reobserve(r);
+    }, t.prototype.silentSetOptions = function(r) {
+      var n = Q(this.options, r || {});
+      Ce(this.options, n);
+    }, t.prototype.setVariables = function(r) {
+      return O(this.variables, r) ? this.observers.size ? this.result() : Promise.resolve() : (this.options.variables = r, this.observers.size ? this.reobserve({
+        // Reset options.fetchPolicy to its original value.
+        fetchPolicy: this.options.initialFetchPolicy,
+        variables: r
+      }, g.setVariables) : Promise.resolve());
+    }, t.prototype.updateQuery = function(r) {
+      var n = this.queryManager, i = n.cache.diff({
+        query: this.options.query,
+        variables: this.variables,
+        returnPartialData: !0,
+        optimistic: !1
+      }), o = i.result, a = i.complete, s = r(o, {
+        variables: this.variables,
+        complete: !!a,
+        previousData: o
+      });
+      s && (n.cache.writeQuery({
+        query: this.options.query,
+        data: s,
+        variables: this.variables
+      }), n.broadcastQueries());
+    }, t.prototype.startPolling = function(r) {
+      this.options.pollInterval = r, this.updatePolling();
+    }, t.prototype.stopPolling = function() {
+      this.options.pollInterval = 0, this.updatePolling();
+    }, t.prototype.applyNextFetchPolicy = function(r, n) {
+      if (n.nextFetchPolicy) {
+        var i = n.fetchPolicy, o = i === void 0 ? "cache-first" : i, a = n.initialFetchPolicy, s = a === void 0 ? o : a;
+        o === "standby" || (typeof n.nextFetchPolicy == "function" ? n.fetchPolicy = n.nextFetchPolicy(o, {
+          reason: r,
+          options: n,
+          observable: this,
+          initialFetchPolicy: s
+        }) : r === "variables-changed" ? n.fetchPolicy = s : n.fetchPolicy = n.nextFetchPolicy);
+      }
+      return n.fetchPolicy;
+    }, t.prototype.fetch = function(r, n, i) {
+      var o = this.queryManager.getOrCreateQuery(this.queryId);
+      return o.setObservableQuery(this), this.queryManager.fetchConcastWithInfo(o, r, n, i);
+    }, t.prototype.updatePolling = function() {
+      var r = this;
+      if (!this.queryManager.ssrMode) {
+        var n = this, i = n.pollingInfo, o = n.options.pollInterval;
+        if (!o || !this.hasObservers()) {
+          i && (clearTimeout(i.timeout), delete this.pollingInfo);
+          return;
+        }
+        if (!(i && i.interval === o)) {
+          b(o, 24);
+          var a = i || (this.pollingInfo = {});
+          a.interval = o;
+          var s = function() {
+            var c, f;
+            r.pollingInfo && (!z(r.queryInfo.networkStatus) && !(!((f = (c = r.options).skipPollAttempt) === null || f === void 0) && f.call(c)) ? r.reobserve({
+              // Most fetchPolicy options don't make sense to use in a polling context, as
+              // users wouldn't want to be polling the cache directly. However, network-only and
+              // no-cache are both useful for when the user wants to control whether or not the
+              // polled results are written to the cache.
+              fetchPolicy: r.options.initialFetchPolicy === "no-cache" ? "no-cache" : "network-only"
+            }, g.poll).then(u, u) : u());
+          }, u = function() {
+            var c = r.pollingInfo;
+            c && (clearTimeout(c.timeout), c.timeout = setTimeout(s, c.interval));
+          };
+          u();
+        }
+      }
+    }, t.prototype.updateLastResult = function(r, n) {
+      n === void 0 && (n = this.variables);
+      var i = this.getLastError();
+      return i && this.last && !O(n, this.last.variables) && (i = void 0), this.last = p({ result: this.queryManager.assumeImmutableResults ? r : fr(r), variables: n }, i ? { error: i } : null);
+    }, t.prototype.reobserveAsConcast = function(r, n) {
+      var i = this;
+      this.isTornDown = !1;
+      var o = (
+        // Refetching uses a disposable Concast to allow refetches using different
+        // options/variables, without permanently altering the options of the
+        // original ObservableQuery.
+        n === g.refetch || // The fetchMore method does not actually call the reobserve method, but,
+        // if it did, it would definitely use a disposable Concast.
+        n === g.fetchMore || // Polling uses a disposable Concast so the polling options (which force
+        // fetchPolicy to be "network-only" or "no-cache") won't override the original options.
+        n === g.poll
+      ), a = this.options.variables, s = this.options.fetchPolicy, u = Q(this.options, r || {}), c = o ? (
+        // Disposable Concast fetches receive a shallow copy of this.options
+        // (merged with newOptions), leaving this.options unmodified.
+        u
+      ) : Ce(this.options, u), f = this.transformDocument(c.query);
+      this.lastQuery = f, o || (this.updatePolling(), r && r.variables && !O(r.variables, a) && // Don't mess with the fetchPolicy if it's currently "standby".
+      c.fetchPolicy !== "standby" && // If we're changing the fetchPolicy anyway, don't try to change it here
+      // using applyNextFetchPolicy. The explicit options.fetchPolicy wins.
+      (c.fetchPolicy === s || // A `nextFetchPolicy` function has even higher priority, though,
+      // so in that case `applyNextFetchPolicy` must be called.
+      typeof c.nextFetchPolicy == "function") && (this.applyNextFetchPolicy("variables-changed", c), n === void 0 && (n = g.setVariables))), this.waitForOwnResult && (this.waitForOwnResult = K(c.fetchPolicy));
+      var l = function() {
+        i.concast === v && (i.waitForOwnResult = !1);
+      }, h = c.variables && p({}, c.variables), y = this.fetch(c, n, f), v = y.concast, E = y.fromLink, S = {
+        next: function(d) {
+          O(i.variables, h) && (l(), i.reportResult(d, h));
+        },
+        error: function(d) {
+          O(i.variables, h) && (vr(d) || (d = new ge({ networkError: d })), l(), i.reportError(d, h));
+        }
+      };
+      return !o && (E || !this.concast) && (this.concast && this.observer && this.concast.removeObserver(this.observer), this.concast = v, this.observer = S), v.addObserver(S), v;
+    }, t.prototype.reobserve = function(r, n) {
+      return ur(this.reobserveAsConcast(r, n).promise.then(this.maskResult));
+    }, t.prototype.resubscribeAfterError = function() {
+      for (var r = [], n = 0; n < arguments.length; n++)
+        r[n] = arguments[n];
+      var i = this.last;
+      this.resetLastResults();
+      var o = this.subscribe.apply(this, r);
+      return this.last = i, o;
+    }, t.prototype.observe = function() {
+      this.reportResult(
+        // Passing false is important so that this.getCurrentResult doesn't
+        // save the fetchMore result as this.lastResult, causing it to be
+        // ignored due to the this.isDifferentFromLastResult check in
+        // this.reportResult.
+        this.getCurrentFullResult(!1),
+        this.variables
+      );
+    }, t.prototype.reportResult = function(r, n) {
+      var i = this.getLastError(), o = this.isDifferentFromLastResult(r, n);
+      (i || !r.partial || this.options.returnPartialData) && this.updateLastResult(r, n), (i || o) && Fe(this.observers, "next", this.maskResult(r));
+    }, t.prototype.reportError = function(r, n) {
+      var i = p(p({}, this.getLastResult()), { error: r, errors: r.graphQLErrors, networkStatus: g.error, loading: !1 });
+      this.updateLastResult(i, n), Fe(this.observers, "error", this.last.error = r);
+    }, t.prototype.hasObservers = function() {
+      return this.observers.size > 0;
+    }, t.prototype.tearDownQuery = function() {
+      this.isTornDown || (this.concast && this.observer && (this.concast.removeObserver(this.observer), delete this.concast, delete this.observer), this.stopPolling(), this.subscriptions.forEach(function(r) {
+        return r.unsubscribe();
+      }), this.subscriptions.clear(), this.queryManager.stopQuery(this.queryId), this.observers.clear(), this.isTornDown = !0);
+    }, t.prototype.transformDocument = function(r) {
+      return this.queryManager.transform(r);
+    }, t.prototype.maskResult = function(r) {
+      return r && "data" in r ? p(p({}, r), { data: this.queryManager.maskOperation({
+        document: this.query,
+        data: r.data,
+        fetchPolicy: this.options.fetchPolicy,
+        id: this.queryId
+      }) }) : r;
+    }, t.prototype.resetNotifications = function() {
+      this.cancelNotifyTimeout(), this.dirty = !1;
+    }, t.prototype.cancelNotifyTimeout = function() {
+      this.notifyTimeout && (clearTimeout(this.notifyTimeout), this.notifyTimeout = void 0);
+    }, t.prototype.scheduleNotify = function() {
+      var r = this;
+      this.dirty || (this.dirty = !0, this.notifyTimeout || (this.notifyTimeout = setTimeout(function() {
+        return r.notify();
+      }, 0)));
+    }, t.prototype.notify = function() {
+      if (this.cancelNotifyTimeout(), this.dirty && (this.options.fetchPolicy == "cache-only" || this.options.fetchPolicy == "cache-and-network" || !z(this.queryInfo.networkStatus))) {
+        var r = this.queryInfo.getDiff();
+        r.fromOptimisticTransaction ? this.observe() : this.reobserveCacheFirst();
+      }
+      this.dirty = !1;
+    }, t.prototype.reobserveCacheFirst = function() {
+      var r = this.options, n = r.fetchPolicy, i = r.nextFetchPolicy;
+      return n === "cache-and-network" || n === "network-only" ? this.reobserve({
+        fetchPolicy: "cache-first",
+        // Use a temporary nextFetchPolicy function that replaces itself with the
+        // previous nextFetchPolicy value and returns the original fetchPolicy.
+        nextFetchPolicy: function(o, a) {
+          return this.nextFetchPolicy = i, typeof this.nextFetchPolicy == "function" ? this.nextFetchPolicy(o, a) : n;
+        }
+      }) : this.reobserve();
+    }, t.inactiveOnCreation = new he(), t;
+  }(M)
+);
+pr(st);
+function Er(e) {
+  globalThis.__DEV__ !== !1 && b.error(25, e.message, e.stack);
+}
+function Pr(e) {
+  globalThis.__DEV__ !== !1 && e && globalThis.__DEV__ !== !1 && b.debug(26, e);
+}
+function K(e) {
+  return e === "network-only" || e === "no-cache" || e === "standby";
+}
+var Y = { exports: {} }, Qe;
+function kr() {
+  return Qe || (Qe = 1, function(e) {
+    e.exports.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED = void 0, e.exports.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE = void 0, e.exports.__SERVER_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE = void 0, Object.assign(e.exports, bt);
+  }(Y)), Y.exports;
+}
+var w = kr();
+const qr = /* @__PURE__ */ gt(w), ut = /* @__PURE__ */ mt({
+  __proto__: null,
+  default: qr
+}, [w]);
+var Ae = Je ? Symbol.for("__APOLLO_CONTEXT__") : "__APOLLO_CONTEXT__";
+function ct() {
+  b("createContext" in ut, 54);
+  var e = w.createContext[Ae];
+  return e || (Object.defineProperty(w.createContext, Ae, {
+    value: e = w.createContext({}),
+    enumerable: !1,
+    writable: !1,
+    configurable: !0
+  }), e.displayName = "ApolloContext"), e;
+}
+function ft(e) {
+  var t = w.useContext(ct()), r = e || t.client;
+  return b(!!r, 58), r;
+}
+var Ne = !1, Dr = "useSyncExternalStore", Ir = ut[Dr], Fr = Ir || function(e, t, r) {
+  var n = t();
+  // DEVIATION: Using __DEV__
+  globalThis.__DEV__ !== !1 && !Ne && // DEVIATION: Not using Object.is because we know our snapshots will never
+  // be exotic primitive values like NaN, which is !== itself.
+  n !== t() && (Ne = !0, globalThis.__DEV__ !== !1 && b.error(68));
+  var i = w.useState({
+    inst: { value: n, getSnapshot: t }
+  }), o = i[0].inst, a = i[1];
+  return Ft ? w.useLayoutEffect(function() {
+    Object.assign(o, { value: n, getSnapshot: t }), X(o) && a({ inst: o });
+  }, [e, n, t]) : Object.assign(o, { value: n, getSnapshot: t }), w.useEffect(function() {
+    return X(o) && a({ inst: o }), e(function() {
+      X(o) && a({ inst: o });
+    });
+  }, [e]), n;
+};
+function X(e) {
+  var t = e.value, r = e.getSnapshot;
+  try {
+    return t !== r();
+  } catch {
+    return !0;
+  }
+}
+var k;
+(function(e) {
+  e[e.Query = 0] = "Query", e[e.Mutation = 1] = "Mutation", e[e.Subscription = 2] = "Subscription";
+})(k || (k = {}));
+var D;
+function ze(e) {
+  var t;
+  switch (e) {
+    case k.Query:
+      t = "Query";
+      break;
+    case k.Mutation:
+      t = "Mutation";
+      break;
+    case k.Subscription:
+      t = "Subscription";
+      break;
+  }
+  return t;
+}
+function lt(e) {
+  D || (D = new Nt(
+    Ye.parser || 1e3
+    /* defaultCacheSizes.parser */
+  ));
+  var t = D.get(e);
+  if (t)
+    return t;
+  var r, n, i;
+  b(!!e && !!e.kind, 70, e);
+  for (var o = [], a = [], s = [], u = [], c = 0, f = e.definitions; c < f.length; c++) {
+    var l = f[c];
+    if (l.kind === "FragmentDefinition") {
+      o.push(l);
+      continue;
+    }
+    if (l.kind === "OperationDefinition")
+      switch (l.operation) {
+        case "query":
+          a.push(l);
+          break;
+        case "mutation":
+          s.push(l);
+          break;
+        case "subscription":
+          u.push(l);
+          break;
+      }
+  }
+  b(!o.length || a.length || s.length || u.length, 71), b(
+    a.length + s.length + u.length <= 1,
+    72,
+    e,
+    a.length,
+    u.length,
+    s.length
+  ), n = a.length ? k.Query : k.Mutation, !a.length && !s.length && (n = k.Subscription);
+  var h = a.length ? a : s.length ? s : u;
+  b(h.length === 1, 73, e, h.length);
+  var y = h[0];
+  r = y.variableDefinitions || [], y.name && y.name.kind === "Name" ? i = y.name.value : i = "data";
+  var v = { name: i, type: n, variables: r };
+  return D.set(e, v), v;
+}
+lt.resetCache = function() {
+  D = void 0;
+};
+globalThis.__DEV__ !== !1 && Xe("parser", function() {
+  return D ? D.size : 0;
+});
+function jr(e, t) {
+  var r = lt(e), n = ze(t), i = ze(r.type);
+  b(
+    r.type === t,
+    74,
+    n,
+    n,
+    i
+  );
+}
+var Tr = Symbol.for("apollo.hook.wrappers");
+function xr(e, t, r) {
+  var n = r.queryManager, i = n && n[Tr], o = i && i[e];
+  return o ? o(t) : t;
+}
+var Mr = Object.prototype.hasOwnProperty;
+function Le() {
+}
+var U = Symbol();
+function Xr(e, t) {
+  return t === void 0 && (t = /* @__PURE__ */ Object.create(null)), xr(
+    "useQuery",
+    // eslint-disable-next-line react-compiler/react-compiler
+    Rr,
+    ft(t && t.client)
+  )(e, t);
+}
+function Rr(e, t) {
+  var r = Qr(e, t), n = r.result, i = r.obsQueryFields;
+  return w.useMemo(function() {
+    return p(p({}, n), i);
+  }, [n, i]);
+}
+function Cr(e, t, r, n, i) {
+  function o(l) {
+    var h;
+    jr(t, k.Query);
+    var y = {
+      client: e,
+      query: t,
+      observable: (
+        // See if there is an existing observable that was used to fetch the same
+        // data and if so, use it instead since it will contain the proper queryId
+        // to fetch the result set. This is used during SSR.
+        n && n.getSSRObservable(i()) || st.inactiveOnCreation.withValue(!n, function() {
+          return e.watchQuery(ht(void 0, e, r, i()));
+        })
+      ),
+      resultData: {
+        // Reuse previousData from previous InternalState (if any) to provide
+        // continuity of previousData even if/when the query or client changes.
+        previousData: (h = l?.resultData.current) === null || h === void 0 ? void 0 : h.data
+      }
+    };
+    return y;
+  }
+  var a = w.useState(o), s = a[0], u = a[1];
+  function c(l) {
+    var h, y;
+    Object.assign(s.observable, (h = {}, h[U] = l, h));
+    var v = s.resultData;
+    u(p(p({}, s), {
+      // might be a different query
+      query: l.query,
+      resultData: Object.assign(v, {
+        // We need to modify the previous `resultData` object as we rely on the
+        // object reference in other places
+        previousData: ((y = v.current) === null || y === void 0 ? void 0 : y.data) || v.previousData,
+        current: void 0
+      })
+    }));
+  }
+  if (e !== s.client || t !== s.query) {
+    var f = o(s);
+    return u(f), [f, c];
+  }
+  return [s, c];
+}
+function Qr(e, t) {
+  var r = ft(t.client), n = w.useContext(ct()).renderPromises, i = !!n, o = r.disableNetworkFetches, a = t.ssr !== !1 && !t.skip, s = t.partialRefetch, u = Lr(r, e, t, i), c = Cr(r, e, t, n, u), f = c[0], l = f.observable, h = f.resultData, y = c[1], v = u(l);
+  zr(
+    h,
+    // might get mutated during render
+    l,
+    // might get mutated during render
+    r,
+    t,
+    v
+  );
+  var E = w.useMemo(function() {
+    return $r(l);
+  }, [l]);
+  Nr(l, n, a);
+  var S = Ar(h, l, r, t, v, o, s, i, {
+    onCompleted: t.onCompleted || Le,
+    onError: t.onError || Le
+  });
+  return {
+    result: S,
+    obsQueryFields: E,
+    observable: l,
+    resultData: h,
+    client: r,
+    onQueryExecuted: y
+  };
+}
+function Ar(e, t, r, n, i, o, a, s, u) {
+  var c = w.useRef(u);
+  w.useEffect(function() {
+    c.current = u;
+  });
+  var f = (s || o) && n.ssr === !1 && !n.skip ? (
+    // If SSR has been explicitly disabled, and this function has been called
+    // on the server side, return the default loading state.
+    yt
+  ) : n.skip || i.fetchPolicy === "standby" ? (
+    // When skipping a query (ie. we're not querying for data but still want to
+    // render children), make sure the `data` is cleared out and `loading` is
+    // set to `false` (since we aren't loading anything).
+    //
+    // NOTE: We no longer think this is the correct behavior. Skipping should
+    // not automatically set `data` to `undefined`, but instead leave the
+    // previous data in place. In other words, skipping should not mandate that
+    // previously received data is all of a sudden removed. Unfortunately,
+    // changing this is breaking, so we'll have to wait until Apollo Client 4.0
+    // to address this.
+    vt
+  ) : void 0, l = e.previousData, h = w.useMemo(function() {
+    return f && pt(f, l, t, r);
+  }, [r, t, f, l]);
+  return Fr(w.useCallback(function(y) {
+    if (s)
+      return function() {
+      };
+    var v = function() {
+      var d = e.current, _ = t.getCurrentResult();
+      d && d.loading === _.loading && d.networkStatus === _.networkStatus && O(d.data, _.data) || ue(_, e, t, r, a, y, c.current);
+    }, E = function(d) {
+      if (S.current.unsubscribe(), S.current = t.resubscribeAfterError(v, E), !Mr.call(d, "graphQLErrors"))
+        throw d;
+      var _ = e.current;
+      (!_ || _ && _.loading || !O(d, _.error)) && ue({
+        data: _ && _.data,
+        error: d,
+        loading: !1,
+        networkStatus: g.error
+      }, e, t, r, a, y, c.current);
+    }, S = { current: t.subscribe(v, E) };
+    return function() {
+      setTimeout(function() {
+        return S.current.unsubscribe();
+      });
+    };
+  }, [
+    o,
+    s,
+    t,
+    e,
+    a,
+    r
+  ]), function() {
+    return h || Ve(e, t, c.current, a, r);
+  }, function() {
+    return h || Ve(e, t, c.current, a, r);
+  });
+}
+function Nr(e, t, r) {
+  t && r && (t.registerSSRObservable(e), e.getCurrentResult().loading && t.addObservableQueryPromise(e));
+}
+function zr(e, t, r, n, i) {
+  var o;
+  t[U] && !O(t[U], i) && (t.reobserve(ht(t, r, n, i)), e.previousData = ((o = e.current) === null || o === void 0 ? void 0 : o.data) || e.previousData, e.current = void 0), t[U] = i;
+}
+function Lr(e, t, r, n) {
+  r === void 0 && (r = {});
+  var i = r.skip;
+  r.ssr, r.onCompleted, r.onError;
+  var o = r.defaultOptions, a = W(r, ["skip", "ssr", "onCompleted", "onError", "defaultOptions"]);
+  return function(s) {
+    var u = Object.assign(a, { query: t });
+    return n && (u.fetchPolicy === "network-only" || u.fetchPolicy === "cache-and-network") && (u.fetchPolicy = "cache-first"), u.variables || (u.variables = {}), i ? (u.initialFetchPolicy = u.initialFetchPolicy || u.fetchPolicy || Ue(o, e.defaultOptions), u.fetchPolicy = "standby") : u.fetchPolicy || (u.fetchPolicy = s?.options.initialFetchPolicy || Ue(o, e.defaultOptions)), u;
+  };
+}
+function ht(e, t, r, n) {
+  var i = [], o = t.defaultOptions.watchQuery;
+  return o && i.push(o), r.defaultOptions && i.push(r.defaultOptions), i.push(Q(e && e.options, n)), i.reduce(yr);
+}
+function ue(e, t, r, n, i, o, a) {
+  var s = t.current;
+  s && s.data && (t.previousData = s.data), !e.error && rt(e.errors) && (e.error = new ge({ graphQLErrors: e.errors })), t.current = pt(Wr(e, r, i), t.previousData, r, n), o(), Vr(e, s?.networkStatus, a);
+}
+function Vr(e, t, r) {
+  if (!e.loading) {
+    var n = Ur(e);
+    Promise.resolve().then(function() {
+      n ? r.onError(n) : e.data && t !== e.networkStatus && e.networkStatus === g.ready && r.onCompleted(e.data);
+    }).catch(function(i) {
+      globalThis.__DEV__ !== !1 && b.warn(i);
+    });
+  }
+}
+function Ve(e, t, r, n, i) {
+  return e.current || ue(t.getCurrentResult(), e, t, i, n, function() {
+  }, r), e.current;
+}
+function Ue(e, t) {
+  var r;
+  return e?.fetchPolicy || ((r = t?.watchQuery) === null || r === void 0 ? void 0 : r.fetchPolicy) || "cache-first";
+}
+function Ur(e) {
+  return rt(e.errors) ? new ge({ graphQLErrors: e.errors }) : e.error;
+}
+function pt(e, t, r, n) {
+  var i = e.data;
+  e.partial;
+  var o = W(e, ["data", "partial"]), a = p(p({ data: i }, o), { client: n, observable: r, variables: r.variables, called: e !== yt && e !== vt, previousData: t });
+  return a;
+}
+function Wr(e, t, r) {
+  return e.partial && r && !e.loading && (!e.data || Object.keys(e.data).length === 0) && t.options.fetchPolicy !== "cache-only" ? (t.refetch(), p(p({}, e), { loading: !0, networkStatus: g.refetch })) : e;
+}
+var yt = at({
+  loading: !0,
+  data: void 0,
+  error: void 0,
+  networkStatus: g.loading
+}), vt = at({
+  loading: !1,
+  data: void 0,
+  error: void 0,
+  networkStatus: g.ready
+});
+function $r(e) {
+  return {
+    refetch: e.refetch.bind(e),
+    reobserve: e.reobserve.bind(e),
+    fetchMore: e.fetchMore.bind(e),
+    updateQuery: e.updateQuery.bind(e),
+    startPolling: e.startPolling.bind(e),
+    stopPolling: e.stopPolling.bind(e),
+    subscribeToMore: e.subscribeToMore.bind(e)
+  };
+}
+export {
+  ge as A,
+  k as D,
+  p as _,
+  Qr as a,
+  ht as b,
+  Lr as c,
+  Dt as d,
+  ft as e,
+  O as f,
+  Ue as g,
+  yr as m,
+  w as r,
+  pt as t,
+  Xr as u,
+  jr as v
+};