@noxickon/onyx 0.0.1 → 0.0.3

package/dist/chunks/useQuery-mFRa2XuW.js

@@ -0,0 +1,1481 @@
+import { i as m, A as It, c as Tt, r as Qt, n as vt, a as K, b as Mt, d as C, e as _, f as xt, _ as y, g as N, h as Rt, j as H, R as Ct, k as P, l as jt, u as pt, m as Vt, o as At, v as Lt, D as zt } from "./index-Dgwp7JKP.js";
+function Nt(e, r) {
+  var t = e.directives;
+  return !t || !t.length ? !0 : Ut(t).every(function(n) {
+    var i = n.directive, o = n.ifArgument, a = !1;
+    return o.value.kind === "Variable" ? (a = r && r[o.value.name.value], m(a !== void 0, 78, i.name.value)) : a = o.value.value, i.name.value === "skip" ? !a : a;
+  });
+}
+function Wt(e) {
+  var r = e.name.value;
+  return r === "skip" || r === "include";
+}
+function Ut(e) {
+  var r = [];
+  return e && e.length && e.forEach(function(t) {
+    if (Wt(t)) {
+      var n = t.arguments, i = t.name.value;
+      m(n && n.length === 1, 79, i);
+      var o = n[0];
+      m(o.name && o.name.value === "if", 80, i);
+      var a = o.value;
+      m(a && (a.kind === "Variable" || a.kind === "BooleanValue"), 81, i), r.push({ directive: t, ifArgument: o });
+    }
+  }), r;
+}
+function Bt(e) {
+  e === void 0 && (e = []);
+  var r = {};
+  return e.forEach(function(t) {
+    r[t.name.value] = t;
+  }), r;
+}
+function Gt(e, r) {
+  switch (e.kind) {
+    case "InlineFragment":
+      return e;
+    case "FragmentSpread": {
+      var t = e.name.value;
+      if (typeof r == "function")
+        return r(t);
+      var n = r && r[t];
+      return m(n, 87, t), n || null;
+    }
+    default:
+      return null;
+  }
+}
+var dt = Object.assign(function(r) {
+  return JSON.stringify(r, Ht);
+}, {
+  reset: function() {
+    D = new It(
+      Tt.canonicalStringify || 1e3
+      /* defaultCacheSizes.canonicalStringify */
+    );
+  }
+});
+globalThis.__DEV__ !== !1 && Qt("canonicalStringify", function() {
+  return D.size;
+});
+var D;
+dt.reset();
+function Ht(e, r) {
+  if (r && typeof r == "object") {
+    var t = Object.getPrototypeOf(r);
+    if (t === Object.prototype || t === null) {
+      var n = Object.keys(r);
+      if (n.every(Jt))
+        return r;
+      var i = JSON.stringify(n), o = D.get(i);
+      if (!o) {
+        n.sort();
+        var a = JSON.stringify(n);
+        o = D.get(a) || n, D.set(i, o), D.set(a, o);
+      }
+      var u = Object.create(t);
+      return o.forEach(function(s) {
+        u[s] = r[s];
+      }), u;
+    }
+  }
+  return r;
+}
+function Jt(e, r, t) {
+  return r === 0 || t[r - 1] <= e;
+}
+var $t = [
+  "connection",
+  "include",
+  "skip",
+  "client",
+  "rest",
+  "export",
+  "nonreactive"
+], I = dt;
+Object.assign(function(e, r, t) {
+  if (r && t && t.connection && t.connection.key)
+    if (t.connection.filter && t.connection.filter.length > 0) {
+      var n = t.connection.filter ? t.connection.filter : [];
+      n.sort();
+      var i = {};
+      return n.forEach(function(u) {
+        i[u] = r[u];
+      }), "".concat(t.connection.key, "(").concat(I(i), ")");
+    } else
+      return t.connection.key;
+  var o = e;
+  if (r) {
+    var a = I(r);
+    o += "(".concat(a, ")");
+  }
+  return t && Object.keys(t).forEach(function(u) {
+    $t.indexOf(u) === -1 && (t[u] && Object.keys(t[u]).length ? o += "@".concat(u, "(").concat(I(t[u]), ")") : o += "@".concat(u));
+  }), o;
+}, {
+  setStringify: function(e) {
+    var r = I;
+    return I = e, r;
+  }
+});
+function Xt(e) {
+  return e.alias ? e.alias.value : e.name.value;
+}
+function Yt(e) {
+  return e.kind === "Field";
+}
+function bt(e) {
+  m(e && e.kind === "Document", 88);
+  var r = e.definitions.filter(function(t) {
+    return t.kind !== "FragmentDefinition";
+  }).map(function(t) {
+    if (t.kind !== "OperationDefinition")
+      throw vt(89, t.kind);
+    return t;
+  });
+  return m(r.length <= 1, 90, r.length), e;
+}
+function gt(e) {
+  return bt(e), e.definitions.filter(function(r) {
+    return r.kind === "OperationDefinition";
+  })[0];
+}
+function Zt(e) {
+  return e.definitions.filter(function(r) {
+    return r.kind === "FragmentDefinition";
+  });
+}
+function Kt(e) {
+  var r = gt(e);
+  return m(r && r.operation === "query", 91), r;
+}
+function te(e) {
+  bt(e);
+  for (var r, t = 0, n = e.definitions; t < n.length; t++) {
+    var i = n[t];
+    if (i.kind === "OperationDefinition") {
+      var o = i.operation;
+      if (o === "query" || o === "mutation" || o === "subscription")
+        return i;
+    }
+    i.kind === "FragmentDefinition" && !r && (r = i);
+  }
+  if (r)
+    return r;
+  throw vt(95);
+}
+let g = null;
+const tt = {};
+let ee = 1;
+const re = () => class {
+  constructor() {
+    this.id = [
+      "slot",
+      ee++,
+      Date.now(),
+      Math.random().toString(36).slice(2)
+    ].join(":");
+  }
+  hasValue() {
+    for (let r = g; r; r = r.parent)
+      if (this.id in r.slots) {
+        const t = r.slots[this.id];
+        if (t === tt)
+          break;
+        return r !== g && (g.slots[this.id] = t), !0;
+      }
+    return g && (g.slots[this.id] = tt), !1;
+  }
+  getValue() {
+    if (this.hasValue())
+      return g.slots[this.id];
+  }
+  withValue(r, t, n, i) {
+    const o = {
+      __proto__: null,
+      [this.id]: r
+    }, a = g;
+    g = { parent: a, slots: o };
+    try {
+      return t.apply(i, n);
+    } finally {
+      g = a;
+    }
+  }
+  // Capture the current context and wrap a callback function so that it
+  // reestablishes the captured context when called.
+  static bind(r) {
+    const t = g;
+    return function() {
+      const n = g;
+      try {
+        return g = t, r.apply(this, arguments);
+      } finally {
+        g = n;
+      }
+    };
+  }
+  // Immediately run a callback function without any captured context.
+  static noContext(r, t, n) {
+    if (g) {
+      const i = g;
+      try {
+        return g = null, r.apply(n, t);
+      } finally {
+        g = i;
+      }
+    } else
+      return r.apply(n, t);
+  }
+};
+function et(e) {
+  try {
+    return e();
+  } catch {
+  }
+}
+const V = "@wry/context:Slot", ne = (
+  // Prefer globalThis when available.
+  // https://github.com/benjamn/wryware/issues/347
+  et(() => 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
+  et(() => 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)
+), rt = ne, J = rt[V] || // 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[V] || function(e) {
+  try {
+    Object.defineProperty(rt, V, {
+      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;
+  }
+}(re()), { bind: We, noContext: Ue } = J;
+new J();
+function mt(e) {
+  return Array.isArray(e) && e.length > 0;
+}
+function ie(e, r) {
+  var t = typeof Symbol < "u" && e[Symbol.iterator] || e["@@iterator"];
+  if (t) return (t = t.call(e)).next.bind(t);
+  if (Array.isArray(e) || (t = oe(e)) || r) {
+    t && (e = t);
+    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 oe(e, r) {
+  if (e) {
+    if (typeof e == "string") return nt(e, r);
+    var t = Object.prototype.toString.call(e).slice(8, -1);
+    if (t === "Object" && e.constructor && (t = e.constructor.name), t === "Map" || t === "Set") return Array.from(e);
+    if (t === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t)) return nt(e, r);
+  }
+}
+function nt(e, r) {
+  (r == null || r > e.length) && (r = e.length);
+  for (var t = 0, n = new Array(r); t < r; t++)
+    n[t] = e[t];
+  return n;
+}
+function it(e, r) {
+  for (var t = 0; t < r.length; t++) {
+    var n = r[t];
+    n.enumerable = n.enumerable || !1, n.configurable = !0, "value" in n && (n.writable = !0), Object.defineProperty(e, n.key, n);
+  }
+}
+function $(e, r, t) {
+  return r && it(e.prototype, r), t && it(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e;
+}
+var X = function() {
+  return typeof Symbol == "function";
+}, Y = function(e) {
+  return X() && !!Symbol[e];
+}, Z = function(e) {
+  return Y(e) ? Symbol[e] : "@@" + e;
+};
+X() && !Y("observable") && (Symbol.observable = Symbol("observable"));
+var ae = Z("iterator"), W = Z("observable"), wt = Z("species");
+function j(e, r) {
+  var t = e[r];
+  if (t != null) {
+    if (typeof t != "function") throw new TypeError(t + " is not a function");
+    return t;
+  }
+}
+function T(e) {
+  var r = e.constructor;
+  return r !== void 0 && (r = r[wt], r === null && (r = void 0)), r !== void 0 ? r : k;
+}
+function ue(e) {
+  return e instanceof k;
+}
+function F(e) {
+  F.log ? F.log(e) : setTimeout(function() {
+    throw e;
+  });
+}
+function M(e) {
+  Promise.resolve().then(function() {
+    try {
+      e();
+    } catch (r) {
+      F(r);
+    }
+  });
+}
+function _t(e) {
+  var r = e._cleanup;
+  if (r !== void 0 && (e._cleanup = void 0, !!r))
+    try {
+      if (typeof r == "function")
+        r();
+      else {
+        var t = j(r, "unsubscribe");
+        t && t.call(r);
+      }
+    } catch (n) {
+      F(n);
+    }
+}
+function U(e) {
+  e._observer = void 0, e._queue = void 0, e._state = "closed";
+}
+function se(e) {
+  var r = e._queue;
+  if (r) {
+    e._queue = void 0, e._state = "ready";
+    for (var t = 0; t < r.length && (St(e, r[t].type, r[t].value), e._state !== "closed"); ++t)
+      ;
+  }
+}
+function St(e, r, t) {
+  e._state = "running";
+  var n = e._observer;
+  try {
+    var i = j(n, r);
+    switch (r) {
+      case "next":
+        i && i.call(n, t);
+        break;
+      case "error":
+        if (U(e), i) i.call(n, t);
+        else throw t;
+        break;
+      case "complete":
+        U(e), i && i.call(n);
+        break;
+    }
+  } catch (o) {
+    F(o);
+  }
+  e._state === "closed" ? _t(e) : e._state === "running" && (e._state = "ready");
+}
+function A(e, r, t) {
+  if (e._state !== "closed") {
+    if (e._state === "buffering") {
+      e._queue.push({
+        type: r,
+        value: t
+      });
+      return;
+    }
+    if (e._state !== "ready") {
+      e._state = "buffering", e._queue = [{
+        type: r,
+        value: t
+      }], M(function() {
+        return se(e);
+      });
+      return;
+    }
+    St(e, r, t);
+  }
+}
+var ce = /* @__PURE__ */ function() {
+  function e(t, n) {
+    this._cleanup = void 0, this._observer = t, this._queue = void 0, this._state = "initializing";
+    var i = new fe(this);
+    try {
+      this._cleanup = n.call(void 0, i);
+    } catch (o) {
+      i.error(o);
+    }
+    this._state === "initializing" && (this._state = "ready");
+  }
+  var r = e.prototype;
+  return r.unsubscribe = function() {
+    this._state !== "closed" && (U(this), _t(this));
+  }, $(e, [{
+    key: "closed",
+    get: function() {
+      return this._state === "closed";
+    }
+  }]), e;
+}(), fe = /* @__PURE__ */ function() {
+  function e(t) {
+    this._subscription = t;
+  }
+  var r = e.prototype;
+  return r.next = function(n) {
+    A(this._subscription, "next", n);
+  }, r.error = function(n) {
+    A(this._subscription, "error", n);
+  }, r.complete = function() {
+    A(this._subscription, "complete");
+  }, $(e, [{
+    key: "closed",
+    get: function() {
+      return this._subscription._state === "closed";
+    }
+  }]), e;
+}(), k = /* @__PURE__ */ function() {
+  function e(t) {
+    if (!(this instanceof e)) throw new TypeError("Observable cannot be called as a function");
+    if (typeof t != "function") throw new TypeError("Observable initializer must be a function");
+    this._subscriber = t;
+  }
+  var r = e.prototype;
+  return r.subscribe = function(n) {
+    return (typeof n != "object" || n === null) && (n = {
+      next: n,
+      error: arguments[1],
+      complete: arguments[2]
+    }), new ce(n, this._subscriber);
+  }, r.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 u() {
+        s.unsubscribe(), o();
+      }
+      var s = i.subscribe({
+        next: function(c) {
+          try {
+            n(c, u);
+          } catch (f) {
+            a(f), s.unsubscribe();
+          }
+        },
+        error: a,
+        complete: o
+      });
+    });
+  }, r.map = function(n) {
+    var i = this;
+    if (typeof n != "function") throw new TypeError(n + " is not a function");
+    var o = T(this);
+    return new o(function(a) {
+      return i.subscribe({
+        next: function(u) {
+          try {
+            u = n(u);
+          } catch (s) {
+            return a.error(s);
+          }
+          a.next(u);
+        },
+        error: function(u) {
+          a.error(u);
+        },
+        complete: function() {
+          a.complete();
+        }
+      });
+    });
+  }, r.filter = function(n) {
+    var i = this;
+    if (typeof n != "function") throw new TypeError(n + " is not a function");
+    var o = T(this);
+    return new o(function(a) {
+      return i.subscribe({
+        next: function(u) {
+          try {
+            if (!n(u)) return;
+          } catch (s) {
+            return a.error(s);
+          }
+          a.next(u);
+        },
+        error: function(u) {
+          a.error(u);
+        },
+        complete: function() {
+          a.complete();
+        }
+      });
+    });
+  }, r.reduce = function(n) {
+    var i = this;
+    if (typeof n != "function") throw new TypeError(n + " is not a function");
+    var o = T(this), a = arguments.length > 1, u = !1, s = arguments[1], c = s;
+    return new o(function(f) {
+      return i.subscribe({
+        next: function(l) {
+          var h = !u;
+          if (u = !0, !h || a)
+            try {
+              c = n(c, l);
+            } catch (v) {
+              return f.error(v);
+            }
+          else
+            c = l;
+        },
+        error: function(l) {
+          f.error(l);
+        },
+        complete: function() {
+          if (!u && !a) return f.error(new TypeError("Cannot reduce an empty sequence"));
+          f.next(c), f.complete();
+        }
+      });
+    });
+  }, r.concat = function() {
+    for (var n = this, i = arguments.length, o = new Array(i), a = 0; a < i; a++)
+      o[a] = arguments[a];
+    var u = T(this);
+    return new u(function(s) {
+      var c, f = 0;
+      function l(h) {
+        c = h.subscribe({
+          next: function(v) {
+            s.next(v);
+          },
+          error: function(v) {
+            s.error(v);
+          },
+          complete: function() {
+            f === o.length ? (c = void 0, s.complete()) : l(u.from(o[f++]));
+          }
+        });
+      }
+      return l(n), function() {
+        c && (c.unsubscribe(), c = void 0);
+      };
+    });
+  }, r.flatMap = function(n) {
+    var i = this;
+    if (typeof n != "function") throw new TypeError(n + " is not a function");
+    var o = T(this);
+    return new o(function(a) {
+      var u = [], s = 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 = u.indexOf(l);
+              h >= 0 && u.splice(h, 1), c();
+            }
+          });
+          u.push(l);
+        },
+        error: function(f) {
+          a.error(f);
+        },
+        complete: function() {
+          c();
+        }
+      });
+      function c() {
+        s.closed && u.length === 0 && a.complete();
+      }
+      return function() {
+        u.forEach(function(f) {
+          return f.unsubscribe();
+        }), s.unsubscribe();
+      };
+    });
+  }, r[W] = 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 = j(n, W);
+    if (o) {
+      var a = o.call(n);
+      if (Object(a) !== a) throw new TypeError(a + " is not an object");
+      return ue(a) && a.constructor === i ? a : new i(function(u) {
+        return a.subscribe(u);
+      });
+    }
+    if (Y("iterator") && (o = j(n, ae), o))
+      return new i(function(u) {
+        M(function() {
+          if (!u.closed) {
+            for (var s = ie(o.call(n)), c; !(c = s()).done; ) {
+              var f = c.value;
+              if (u.next(f), u.closed) return;
+            }
+            u.complete();
+          }
+        });
+      });
+    if (Array.isArray(n))
+      return new i(function(u) {
+        M(function() {
+          if (!u.closed) {
+            for (var s = 0; s < n.length; ++s)
+              if (u.next(n[s]), u.closed) return;
+            u.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(u) {
+      M(function() {
+        if (!u.closed) {
+          for (var s = 0; s < i.length; ++s)
+            if (u.next(i[s]), u.closed) return;
+          u.complete();
+        }
+      });
+    });
+  }, $(e, null, [{
+    key: wt,
+    get: function() {
+      return this;
+    }
+  }]), e;
+}();
+X() && Object.defineProperty(k, Symbol("extensions"), {
+  value: {
+    symbol: W,
+    hostReportError: F
+  },
+  configurable: !0
+});
+function le(e) {
+  var r, t = e.Symbol;
+  if (typeof t == "function")
+    if (t.observable)
+      r = t.observable;
+    else {
+      typeof t.for == "function" ? r = t.for("https://github.com/benlesh/symbol-observable") : r = t("https://github.com/benlesh/symbol-observable");
+      try {
+        t.observable = r;
+      } catch {
+      }
+    }
+  else
+    r = "@@observable";
+  return r;
+}
+var E;
+typeof self < "u" ? E = self : typeof window < "u" ? E = window : typeof global < "u" ? E = global : typeof module < "u" ? E = module : E = Function("return this")();
+le(E);
+var ot = k.prototype, at = "@@observable";
+ot[at] || (ot[at] = function() {
+  return this;
+});
+function he(e) {
+  return e.catch(function() {
+  }), e;
+}
+var ye = Object.prototype.toString;
+function ve(e) {
+  return B(e);
+}
+function B(e, r) {
+  switch (ye.call(e)) {
+    case "[object Array]": {
+      if (r = r || /* @__PURE__ */ new Map(), r.has(e))
+        return r.get(e);
+      var t = e.slice(0);
+      return r.set(e, t), t.forEach(function(i, o) {
+        t[o] = B(i, r);
+      }), t;
+    }
+    case "[object Object]": {
+      if (r = r || /* @__PURE__ */ new Map(), r.has(e))
+        return r.get(e);
+      var n = Object.create(Object.getPrototypeOf(e));
+      return r.set(e, n), Object.keys(e).forEach(function(i) {
+        n[i] = B(e[i], r);
+      }), n;
+    }
+    default:
+      return e;
+  }
+}
+function pe(e) {
+  var r = /* @__PURE__ */ new Set([e]);
+  return r.forEach(function(t) {
+    K(t) && de(t) === t && Object.getOwnPropertyNames(t).forEach(function(n) {
+      K(t[n]) && r.add(t[n]);
+    });
+  }), e;
+}
+function de(e) {
+  if (globalThis.__DEV__ !== !1 && !Object.isFrozen(e))
+    try {
+      Object.freeze(e);
+    } catch (r) {
+      if (r instanceof TypeError)
+        return null;
+      throw r;
+    }
+  return e;
+}
+function Ot(e) {
+  return globalThis.__DEV__ !== !1 && pe(e), e;
+}
+function ut(e, r, t) {
+  var n = [];
+  e.forEach(function(i) {
+    return i[r] && n.push(i);
+  }), n.forEach(function(i) {
+    return i[r](t);
+  });
+}
+function be(e) {
+  function r(t) {
+    Object.defineProperty(e, t, { value: k });
+  }
+  return Mt && Symbol.species && r(Symbol.species), r("@@species"), e;
+}
+function ge(e, r, t, n) {
+  var i = r.data, o = C(r, ["data"]), a = t.data, u = C(t, ["data"]);
+  return _(o, u) && x(te(e).selectionSet, i, a, {
+    fragmentMap: Bt(Zt(e)),
+    variables: n
+  });
+}
+function x(e, r, t, n) {
+  if (r === t)
+    return !0;
+  var i = /* @__PURE__ */ new Set();
+  return e.selections.every(function(o) {
+    if (i.has(o) || (i.add(o), !Nt(o, n.variables)) || st(o))
+      return !0;
+    if (Yt(o)) {
+      var a = Xt(o), u = r && r[a], s = t && t[a], c = o.selectionSet;
+      if (!c)
+        return _(u, s);
+      var f = Array.isArray(u), l = Array.isArray(s);
+      if (f !== l)
+        return !1;
+      if (f && l) {
+        var h = u.length;
+        if (s.length !== h)
+          return !1;
+        for (var v = 0; v < h; ++v)
+          if (!x(c, u[v], s[v], n))
+            return !1;
+        return !0;
+      }
+      return x(c, u, s, n);
+    } else {
+      var p = Gt(o, n.fragmentMap);
+      if (p)
+        return st(p) ? !0 : x(
+          p.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).
+          r,
+          t,
+          n
+        );
+    }
+  });
+}
+function st(e) {
+  return !!e.directives && e.directives.some(me);
+}
+function me(e) {
+  return e.name.value === "nonreactive";
+}
+var b;
+(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";
+})(b || (b = {}));
+function Q(e) {
+  return e ? e < 7 : !1;
+}
+var ct = Object.assign, we = Object.hasOwnProperty, Pt = (
+  /** @class */
+  function(e) {
+    xt(r, e);
+    function r(t) {
+      var n = t.queryManager, i = t.queryInfo, o = t.options, a = this, u = r.inactiveOnCreation.getValue();
+      a = e.call(this, function(d) {
+        u && (n.queries.set(a.queryId, i), u = !1);
+        try {
+          var w = d._subscription._observer;
+          w && !w.error && (w.error = _e);
+        } catch {
+        }
+        var kt = !a.observers.size;
+        a.observers.add(d);
+        var q = a.last;
+        return q && q.error ? d.error && d.error(q.error) : q && q.result && d.next && d.next(a.maskResult(q.result)), kt && 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 = L(o.fetchPolicy), a.isTornDown = !1, a.subscribeToMore = a.subscribeToMore.bind(a), a.maskResult = a.maskResult.bind(a);
+      var s = n.defaultOptions.watchQuery, c = s === void 0 ? {} : s, f = c.fetchPolicy, l = f === void 0 ? "cache-first" : f, h = o.fetchPolicy, v = h === void 0 ? l : h, p = o.initialFetchPolicy, O = p === void 0 ? v === "standby" ? l : v : p;
+      a.options = y(y({}, 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: O,
+        // This ensures this.options.fetchPolicy always has a string value, in
+        // case options.fetchPolicy was not provided.
+        fetchPolicy: v
+      }), a.queryId = i.queryId || n.generateQueryId();
+      var S = gt(a.query);
+      return a.queryName = S && S.name && S.name.value, a;
+    }
+    return Object.defineProperty(r.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(r.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
+    }), r.prototype.result = function() {
+      var t = this;
+      return new Promise(function(n, i) {
+        var o = {
+          next: function(u) {
+            n(u), t.observers.delete(o), t.observers.size || t.queryManager.removeQuery(t.queryId), setTimeout(function() {
+              a.unsubscribe();
+            }, 0);
+          },
+          error: i
+        }, a = t.subscribe(o);
+      });
+    }, r.prototype.resetDiff = function() {
+      this.queryInfo.resetDiff();
+    }, r.prototype.getCurrentFullResult = function(t) {
+      t === void 0 && (t = !0);
+      var n = this.getLastResult(!0), i = this.queryInfo.networkStatus || n && n.networkStatus || b.ready, o = y(y({}, n), { loading: Q(i), networkStatus: i }), a = this.options.fetchPolicy, u = a === void 0 ? "cache-first" : a;
+      if (
+        // These fetch policies should never deliver data from the cache, unless
+        // redelivering a previously delivered result.
+        !(L(u) || // 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 s = this.queryInfo.getDiff();
+        (s.complete || this.options.returnPartialData) && (o.data = s.result), _(o.data, {}) && (o.data = void 0), s.complete ? (delete o.partial, s.complete && o.networkStatus === b.loading && (u === "cache-first" || u === "cache-only") && (o.networkStatus = b.ready, o.loading = !1)) : o.partial = !0, o.networkStatus === b.ready && (o.error || o.errors) && (o.networkStatus = b.error), globalThis.__DEV__ !== !1 && !s.complete && !this.options.partialRefetch && !o.loading && !o.data && !o.error && Se(s.missing);
+      }
+      return t && this.updateLastResult(o), o;
+    }, r.prototype.getCurrentResult = function(t) {
+      return t === void 0 && (t = !0), this.maskResult(this.getCurrentFullResult(t));
+    }, r.prototype.isDifferentFromLastResult = function(t, n) {
+      if (!this.last)
+        return !0;
+      var i = this.queryManager.getDocumentInfo(this.query), o = this.queryManager.dataMasking, a = o ? i.nonReactiveQuery : this.query, u = o || i.hasNonreactiveDirective ? !ge(a, this.last.result, t, this.variables) : !_(this.last.result, t);
+      return u || n && !_(this.last.variables, n);
+    }, r.prototype.getLast = function(t, n) {
+      var i = this.last;
+      if (i && i[t] && (!n || _(i.variables, this.variables)))
+        return i[t];
+    }, r.prototype.getLastResult = function(t) {
+      return this.getLast("result", t);
+    }, r.prototype.getLastError = function(t) {
+      return this.getLast("error", t);
+    }, r.prototype.resetLastResults = function() {
+      delete this.last, this.isTornDown = !1;
+    }, r.prototype.resetQueryStoreErrors = function() {
+      this.queryManager.resetErrors(this.queryId);
+    }, r.prototype.refetch = function(t) {
+      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 && t && we.call(t, "variables")) {
+        var a = Kt(this.query), u = a.variableDefinitions;
+        (!u || !u.some(function(s) {
+          return s.variable.name.value === "variables";
+        })) && globalThis.__DEV__ !== !1 && m.warn(
+          21,
+          t,
+          ((n = a.name) === null || n === void 0 ? void 0 : n.value) || a
+        );
+      }
+      return t && !_(this.options.variables, t) && (i.variables = this.options.variables = y(y({}, this.options.variables), t)), this.queryInfo.resetLastWrite(), this.reobserve(i, b.refetch);
+    }, r.prototype.fetchMore = function(t) {
+      var n = this, i = y(y({}, t.query ? t : y(y(y(y({}, this.options), { query: this.options.query }), t), { variables: y(y({}, this.options.variables), t.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 = t.query ? this.transformDocument(this.options.query) : i.query;
+      var a = this.queryInfo, u = a.networkStatus;
+      a.networkStatus = b.fetchMore, i.notifyOnNetworkStatusChange && this.observe();
+      var s = /* @__PURE__ */ new Set(), c = t == null ? void 0 : t.updateQuery, f = this.options.fetchPolicy !== "no-cache";
+      return f || m(c, 22), this.queryManager.fetchQuery(o, i, b.fetchMore).then(function(l) {
+        if (n.queryManager.removeQuery(o), a.networkStatus === b.fetchMore && (a.networkStatus = u), f)
+          n.queryManager.cache.batch({
+            update: function(p) {
+              var O = t.updateQuery;
+              O ? p.updateQuery({
+                query: n.query,
+                variables: n.variables,
+                returnPartialData: !0,
+                optimistic: !1
+              }, function(S) {
+                return O(S, {
+                  fetchMoreResult: l.data,
+                  variables: i.variables
+                });
+              }) : p.writeQuery({
+                query: i.query,
+                variables: i.variables,
+                data: l.data
+              });
+            },
+            onWatchUpdated: function(p) {
+              s.add(p.query);
+            }
+          });
+        else {
+          var h = n.getLast("result"), v = c(h.data, {
+            fetchMoreResult: l.data,
+            variables: i.variables
+          });
+          n.reportResult(y(y({}, h), { networkStatus: u, loading: Q(u), data: v }), n.variables);
+        }
+        return n.maskResult(l);
+      }).finally(function() {
+        f && !s.has(n.query) && n.reobserveCacheFirst();
+      });
+    }, r.prototype.subscribeToMore = function(t) {
+      var n = this, i = this.queryManager.startGraphQLSubscription({
+        query: t.document,
+        variables: t.variables,
+        context: t.context
+      }).subscribe({
+        next: function(o) {
+          var a = t.updateQuery;
+          a && n.updateQuery(function(u, s) {
+            return a(u, y({ subscriptionData: o }, s));
+          });
+        },
+        error: function(o) {
+          if (t.onError) {
+            t.onError(o);
+            return;
+          }
+          globalThis.__DEV__ !== !1 && m.error(23, o);
+        }
+      });
+      return this.subscriptions.add(i), function() {
+        n.subscriptions.delete(i) && i.unsubscribe();
+      };
+    }, r.prototype.setOptions = function(t) {
+      return this.reobserve(t);
+    }, r.prototype.silentSetOptions = function(t) {
+      var n = N(this.options, t || {});
+      ct(this.options, n);
+    }, r.prototype.setVariables = function(t) {
+      return _(this.variables, t) ? this.observers.size ? this.result() : Promise.resolve() : (this.options.variables = t, this.observers.size ? this.reobserve({
+        // Reset options.fetchPolicy to its original value.
+        fetchPolicy: this.options.initialFetchPolicy,
+        variables: t
+      }, b.setVariables) : Promise.resolve());
+    }, r.prototype.updateQuery = function(t) {
+      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, u = t(o, {
+        variables: this.variables,
+        complete: !!a,
+        previousData: o
+      });
+      u && (n.cache.writeQuery({
+        query: this.options.query,
+        data: u,
+        variables: this.variables
+      }), n.broadcastQueries());
+    }, r.prototype.startPolling = function(t) {
+      this.options.pollInterval = t, this.updatePolling();
+    }, r.prototype.stopPolling = function() {
+      this.options.pollInterval = 0, this.updatePolling();
+    }, r.prototype.applyNextFetchPolicy = function(t, n) {
+      if (n.nextFetchPolicy) {
+        var i = n.fetchPolicy, o = i === void 0 ? "cache-first" : i, a = n.initialFetchPolicy, u = a === void 0 ? o : a;
+        o === "standby" || (typeof n.nextFetchPolicy == "function" ? n.fetchPolicy = n.nextFetchPolicy(o, {
+          reason: t,
+          options: n,
+          observable: this,
+          initialFetchPolicy: u
+        }) : t === "variables-changed" ? n.fetchPolicy = u : n.fetchPolicy = n.nextFetchPolicy);
+      }
+      return n.fetchPolicy;
+    }, r.prototype.fetch = function(t, n, i) {
+      var o = this.queryManager.getOrCreateQuery(this.queryId);
+      return o.setObservableQuery(this), this.queryManager.fetchConcastWithInfo(o, t, n, i);
+    }, r.prototype.updatePolling = function() {
+      var t = 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)) {
+          m(o, 24);
+          var a = i || (this.pollingInfo = {});
+          a.interval = o;
+          var u = function() {
+            var c, f;
+            t.pollingInfo && (!Q(t.queryInfo.networkStatus) && !(!((f = (c = t.options).skipPollAttempt) === null || f === void 0) && f.call(c)) ? t.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: t.options.initialFetchPolicy === "no-cache" ? "no-cache" : "network-only"
+            }, b.poll).then(s, s) : s());
+          }, s = function() {
+            var c = t.pollingInfo;
+            c && (clearTimeout(c.timeout), c.timeout = setTimeout(u, c.interval));
+          };
+          s();
+        }
+      }
+    }, r.prototype.updateLastResult = function(t, n) {
+      n === void 0 && (n = this.variables);
+      var i = this.getLastError();
+      return i && this.last && !_(n, this.last.variables) && (i = void 0), this.last = y({ result: this.queryManager.assumeImmutableResults ? t : ve(t), variables: n }, i ? { error: i } : null);
+    }, r.prototype.reobserveAsConcast = function(t, 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 === b.refetch || // The fetchMore method does not actually call the reobserve method, but,
+        // if it did, it would definitely use a disposable Concast.
+        n === b.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 === b.poll
+      ), a = this.options.variables, u = this.options.fetchPolicy, s = N(this.options, t || {}), c = o ? (
+        // Disposable Concast fetches receive a shallow copy of this.options
+        // (merged with newOptions), leaving this.options unmodified.
+        s
+      ) : ct(this.options, s), f = this.transformDocument(c.query);
+      this.lastQuery = f, o || (this.updatePolling(), t && t.variables && !_(t.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 === u || // 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 = b.setVariables))), this.waitForOwnResult && (this.waitForOwnResult = L(c.fetchPolicy));
+      var l = function() {
+        i.concast === p && (i.waitForOwnResult = !1);
+      }, h = c.variables && y({}, c.variables), v = this.fetch(c, n, f), p = v.concast, O = v.fromLink, S = {
+        next: function(d) {
+          _(i.variables, h) && (l(), i.reportResult(d, h));
+        },
+        error: function(d) {
+          _(i.variables, h) && (Rt(d) || (d = new H({ networkError: d })), l(), i.reportError(d, h));
+        }
+      };
+      return !o && (O || !this.concast) && (this.concast && this.observer && this.concast.removeObserver(this.observer), this.concast = p, this.observer = S), p.addObserver(S), p;
+    }, r.prototype.reobserve = function(t, n) {
+      return he(this.reobserveAsConcast(t, n).promise.then(this.maskResult));
+    }, r.prototype.resubscribeAfterError = function() {
+      for (var t = [], n = 0; n < arguments.length; n++)
+        t[n] = arguments[n];
+      var i = this.last;
+      this.resetLastResults();
+      var o = this.subscribe.apply(this, t);
+      return this.last = i, o;
+    }, r.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
+      );
+    }, r.prototype.reportResult = function(t, n) {
+      var i = this.getLastError(), o = this.isDifferentFromLastResult(t, n);
+      (i || !t.partial || this.options.returnPartialData) && this.updateLastResult(t, n), (i || o) && ut(this.observers, "next", this.maskResult(t));
+    }, r.prototype.reportError = function(t, n) {
+      var i = y(y({}, this.getLastResult()), { error: t, errors: t.graphQLErrors, networkStatus: b.error, loading: !1 });
+      this.updateLastResult(i, n), ut(this.observers, "error", this.last.error = t);
+    }, r.prototype.hasObservers = function() {
+      return this.observers.size > 0;
+    }, r.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(t) {
+        return t.unsubscribe();
+      }), this.subscriptions.clear(), this.queryManager.stopQuery(this.queryId), this.observers.clear(), this.isTornDown = !0);
+    }, r.prototype.transformDocument = function(t) {
+      return this.queryManager.transform(t);
+    }, r.prototype.maskResult = function(t) {
+      return t && "data" in t ? y(y({}, t), { data: this.queryManager.maskOperation({
+        document: this.query,
+        data: t.data,
+        fetchPolicy: this.options.fetchPolicy,
+        id: this.queryId
+      }) }) : t;
+    }, r.prototype.resetNotifications = function() {
+      this.cancelNotifyTimeout(), this.dirty = !1;
+    }, r.prototype.cancelNotifyTimeout = function() {
+      this.notifyTimeout && (clearTimeout(this.notifyTimeout), this.notifyTimeout = void 0);
+    }, r.prototype.scheduleNotify = function() {
+      var t = this;
+      this.dirty || (this.dirty = !0, this.notifyTimeout || (this.notifyTimeout = setTimeout(function() {
+        return t.notify();
+      }, 0)));
+    }, r.prototype.notify = function() {
+      if (this.cancelNotifyTimeout(), this.dirty && (this.options.fetchPolicy == "cache-only" || this.options.fetchPolicy == "cache-and-network" || !Q(this.queryInfo.networkStatus))) {
+        var t = this.queryInfo.getDiff();
+        t.fromOptimisticTransaction ? this.observe() : this.reobserveCacheFirst();
+      }
+      this.dirty = !1;
+    }, r.prototype.reobserveCacheFirst = function() {
+      var t = this.options, n = t.fetchPolicy, i = t.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();
+    }, r.inactiveOnCreation = new J(), r;
+  }(k)
+);
+be(Pt);
+function _e(e) {
+  globalThis.__DEV__ !== !1 && m.error(25, e.message, e.stack);
+}
+function Se(e) {
+  globalThis.__DEV__ !== !1 && e && globalThis.__DEV__ !== !1 && m.debug(26, e);
+}
+function L(e) {
+  return e === "network-only" || e === "no-cache" || e === "standby";
+}
+var ft = !1, Oe = "useSyncExternalStore", Pe = Ct[Oe], qe = Pe || function(e, r, t) {
+  var n = r();
+  // DEVIATION: Using __DEV__
+  globalThis.__DEV__ !== !1 && !ft && // DEVIATION: Not using Object.is because we know our snapshots will never
+  // be exotic primitive values like NaN, which is !== itself.
+  n !== r() && (ft = !0, globalThis.__DEV__ !== !1 && m.error(68));
+  var i = P.useState({
+    inst: { value: n, getSnapshot: r }
+  }), o = i[0].inst, a = i[1];
+  return jt ? P.useLayoutEffect(function() {
+    Object.assign(o, { value: n, getSnapshot: r }), z(o) && a({ inst: o });
+  }, [e, n, r]) : Object.assign(o, { value: n, getSnapshot: r }), P.useEffect(function() {
+    return z(o) && a({ inst: o }), e(function() {
+      z(o) && a({ inst: o });
+    });
+  }, [e]), n;
+};
+function z(e) {
+  var r = e.value, t = e.getSnapshot;
+  try {
+    return r !== t();
+  } catch {
+    return !0;
+  }
+}
+var Ee = Symbol.for("apollo.hook.wrappers");
+function De(e, r, t) {
+  var n = t.queryManager, i = n && n[Ee], o = i && i[e];
+  return o ? o(r) : r;
+}
+var Fe = Object.prototype.hasOwnProperty;
+function lt() {
+}
+var R = Symbol();
+function Be(e, r) {
+  return r === void 0 && (r = /* @__PURE__ */ Object.create(null)), De(
+    "useQuery",
+    // eslint-disable-next-line react-compiler/react-compiler
+    ke,
+    pt(r && r.client)
+  )(e, r);
+}
+function ke(e, r) {
+  var t = Te(e, r), n = t.result, i = t.obsQueryFields;
+  return P.useMemo(function() {
+    return y(y({}, n), i);
+  }, [n, i]);
+}
+function Ie(e, r, t, n, i) {
+  function o(l) {
+    var h;
+    Lt(r, zt.Query);
+    var v = {
+      client: e,
+      query: r,
+      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()) || Pt.inactiveOnCreation.withValue(!n, function() {
+          return e.watchQuery(qt(void 0, e, t, 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 == null ? void 0 : l.resultData.current) === null || h === void 0 ? void 0 : h.data
+      }
+    };
+    return v;
+  }
+  var a = P.useState(o), u = a[0], s = a[1];
+  function c(l) {
+    var h, v;
+    Object.assign(u.observable, (h = {}, h[R] = l, h));
+    var p = u.resultData;
+    s(y(y({}, u), {
+      // might be a different query
+      query: l.query,
+      resultData: Object.assign(p, {
+        // We need to modify the previous `resultData` object as we rely on the
+        // object reference in other places
+        previousData: ((v = p.current) === null || v === void 0 ? void 0 : v.data) || p.previousData,
+        current: void 0
+      })
+    }));
+  }
+  if (e !== u.client || r !== u.query) {
+    var f = o(u);
+    return s(f), [f, c];
+  }
+  return [u, c];
+}
+function Te(e, r) {
+  var t = pt(r.client), n = P.useContext(Vt()).renderPromises, i = !!n, o = t.disableNetworkFetches, a = r.ssr !== !1 && !r.skip, u = r.partialRefetch, s = Re(t, e, r, i), c = Ie(t, e, r, n, s), f = c[0], l = f.observable, h = f.resultData, v = c[1], p = s(l);
+  xe(
+    h,
+    // might get mutated during render
+    l,
+    // might get mutated during render
+    t,
+    r,
+    p
+  );
+  var O = P.useMemo(function() {
+    return Ae(l);
+  }, [l]);
+  Me(l, n, a);
+  var S = Qe(h, l, t, r, p, o, u, i, {
+    onCompleted: r.onCompleted || lt,
+    onError: r.onError || lt
+  });
+  return {
+    result: S,
+    obsQueryFields: O,
+    observable: l,
+    resultData: h,
+    client: t,
+    onQueryExecuted: v
+  };
+}
+function Qe(e, r, t, n, i, o, a, u, s) {
+  var c = P.useRef(s);
+  P.useEffect(function() {
+    c.current = s;
+  });
+  var f = (u || 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.
+    Dt
+  ) : 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.
+    Ft
+  ) : void 0, l = e.previousData, h = P.useMemo(function() {
+    return f && Et(f, l, r, t);
+  }, [t, r, f, l]);
+  return qe(P.useCallback(function(v) {
+    if (u)
+      return function() {
+      };
+    var p = function() {
+      var d = e.current, w = r.getCurrentResult();
+      d && d.loading === w.loading && d.networkStatus === w.networkStatus && _(d.data, w.data) || G(w, e, r, t, a, v, c.current);
+    }, O = function(d) {
+      if (S.current.unsubscribe(), S.current = r.resubscribeAfterError(p, O), !Fe.call(d, "graphQLErrors"))
+        throw d;
+      var w = e.current;
+      (!w || w && w.loading || !_(d, w.error)) && G({
+        data: w && w.data,
+        error: d,
+        loading: !1,
+        networkStatus: b.error
+      }, e, r, t, a, v, c.current);
+    }, S = { current: r.subscribe(p, O) };
+    return function() {
+      setTimeout(function() {
+        return S.current.unsubscribe();
+      });
+    };
+  }, [
+    o,
+    u,
+    r,
+    e,
+    a,
+    t
+  ]), function() {
+    return h || ht(e, r, c.current, a, t);
+  }, function() {
+    return h || ht(e, r, c.current, a, t);
+  });
+}
+function Me(e, r, t) {
+  r && t && (r.registerSSRObservable(e), e.getCurrentResult().loading && r.addObservableQueryPromise(e));
+}
+function xe(e, r, t, n, i) {
+  var o;
+  r[R] && !_(r[R], i) && (r.reobserve(qt(r, t, n, i)), e.previousData = ((o = e.current) === null || o === void 0 ? void 0 : o.data) || e.previousData, e.current = void 0), r[R] = i;
+}
+function Re(e, r, t, n) {
+  t === void 0 && (t = {});
+  var i = t.skip;
+  t.ssr, t.onCompleted, t.onError;
+  var o = t.defaultOptions, a = C(t, ["skip", "ssr", "onCompleted", "onError", "defaultOptions"]);
+  return function(u) {
+    var s = Object.assign(a, { query: r });
+    return n && (s.fetchPolicy === "network-only" || s.fetchPolicy === "cache-and-network") && (s.fetchPolicy = "cache-first"), s.variables || (s.variables = {}), i ? (s.initialFetchPolicy = s.initialFetchPolicy || s.fetchPolicy || yt(o, e.defaultOptions), s.fetchPolicy = "standby") : s.fetchPolicy || (s.fetchPolicy = (u == null ? void 0 : u.options.initialFetchPolicy) || yt(o, e.defaultOptions)), s;
+  };
+}
+function qt(e, r, t, n) {
+  var i = [], o = r.defaultOptions.watchQuery;
+  return o && i.push(o), t.defaultOptions && i.push(t.defaultOptions), i.push(N(e && e.options, n)), i.reduce(At);
+}
+function G(e, r, t, n, i, o, a) {
+  var u = r.current;
+  u && u.data && (r.previousData = u.data), !e.error && mt(e.errors) && (e.error = new H({ graphQLErrors: e.errors })), r.current = Et(Ve(e, t, i), r.previousData, t, n), o(), Ce(e, u == null ? void 0 : u.networkStatus, a);
+}
+function Ce(e, r, t) {
+  if (!e.loading) {
+    var n = je(e);
+    Promise.resolve().then(function() {
+      n ? t.onError(n) : e.data && r !== e.networkStatus && e.networkStatus === b.ready && t.onCompleted(e.data);
+    }).catch(function(i) {
+      globalThis.__DEV__ !== !1 && m.warn(i);
+    });
+  }
+}
+function ht(e, r, t, n, i) {
+  return e.current || G(r.getCurrentResult(), e, r, i, n, function() {
+  }, t), e.current;
+}
+function yt(e, r) {
+  var t;
+  return (e == null ? void 0 : e.fetchPolicy) || ((t = r == null ? void 0 : r.watchQuery) === null || t === void 0 ? void 0 : t.fetchPolicy) || "cache-first";
+}
+function je(e) {
+  return mt(e.errors) ? new H({ graphQLErrors: e.errors }) : e.error;
+}
+function Et(e, r, t, n) {
+  var i = e.data;
+  e.partial;
+  var o = C(e, ["data", "partial"]), a = y(y({ data: i }, o), { client: n, observable: t, variables: t.variables, called: e !== Dt && e !== Ft, previousData: r });
+  return a;
+}
+function Ve(e, r, t) {
+  return e.partial && t && !e.loading && (!e.data || Object.keys(e.data).length === 0) && r.options.fetchPolicy !== "cache-only" ? (r.refetch(), y(y({}, e), { loading: !0, networkStatus: b.refetch })) : e;
+}
+var Dt = Ot({
+  loading: !0,
+  data: void 0,
+  error: void 0,
+  networkStatus: b.loading
+}), Ft = Ot({
+  loading: !1,
+  data: void 0,
+  error: void 0,
+  networkStatus: b.ready
+});
+function Ae(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 {
+  Te as a,
+  qt as b,
+  Re as c,
+  yt as g,
+  Et as t,
+  Be as u
+};