(self.webpackChunk_N_E = self.webpackChunk_N_E || []).push([
  [52745],
  {
    54098: function (e, t) {
      var r = "undefined" != typeof self ? self : this,
        i = (function () {
          function F() {
            (this.fetch = !1), (this.DOMException = r.DOMException);
          }
          return (F.prototype = r), new F();
        })();
      (function (e) {
        var t = {
          searchParams: "URLSearchParams" in i,
          iterable: "Symbol" in i && "iterator" in Symbol,
          blob:
            "FileReader" in i &&
            "Blob" in i &&
            (function () {
              try {
                return new Blob(), !0;
              } catch (e) {
                return !1;
              }
            })(),
          formData: "FormData" in i,
          arrayBuffer: "ArrayBuffer" in i,
        };
        if (t.arrayBuffer)
          var r = [
              "[object Int8Array]",
              "[object Uint8Array]",
              "[object Uint8ClampedArray]",
              "[object Int16Array]",
              "[object Uint16Array]",
              "[object Int32Array]",
              "[object Uint32Array]",
              "[object Float32Array]",
              "[object Float64Array]",
            ],
            n =
              ArrayBuffer.isView ||
              function (e) {
                return e && r.indexOf(Object.prototype.toString.call(e)) > -1;
              };
        function normalizeName(e) {
          if (
            ("string" != typeof e && (e = String(e)),
            /[^a-z0-9\-#$%&'*+.^_`|~]/i.test(e))
          )
            throw TypeError("Invalid character in header field name");
          return e.toLowerCase();
        }
        function normalizeValue(e) {
          return "string" != typeof e && (e = String(e)), e;
        }
        function iteratorFor(e) {
          var r = {
            next: function () {
              var t = e.shift();
              return { done: void 0 === t, value: t };
            },
          };
          return (
            t.iterable &&
              (r[Symbol.iterator] = function () {
                return r;
              }),
            r
          );
        }
        function Headers(e) {
          (this.map = {}),
            e instanceof Headers
              ? e.forEach(function (e, t) {
                  this.append(t, e);
                }, this)
              : Array.isArray(e)
              ? e.forEach(function (e) {
                  this.append(e[0], e[1]);
                }, this)
              : e &&
                Object.getOwnPropertyNames(e).forEach(function (t) {
                  this.append(t, e[t]);
                }, this);
        }
        function consumed(e) {
          if (e.bodyUsed) return Promise.reject(TypeError("Already read"));
          e.bodyUsed = !0;
        }
        function fileReaderReady(e) {
          return new Promise(function (t, r) {
            (e.onload = function () {
              t(e.result);
            }),
              (e.onerror = function () {
                r(e.error);
              });
          });
        }
        function readBlobAsArrayBuffer(e) {
          var t = new FileReader(),
            r = fileReaderReady(t);
          return t.readAsArrayBuffer(e), r;
        }
        function bufferClone(e) {
          if (e.slice) return e.slice(0);
          var t = new Uint8Array(e.byteLength);
          return t.set(new Uint8Array(e)), t.buffer;
        }
        function Body() {
          return (
            (this.bodyUsed = !1),
            (this._initBody = function (e) {
              if (((this._bodyInit = e), e)) {
                if ("string" == typeof e) this._bodyText = e;
                else if (t.blob && Blob.prototype.isPrototypeOf(e))
                  this._bodyBlob = e;
                else if (t.formData && FormData.prototype.isPrototypeOf(e))
                  this._bodyFormData = e;
                else if (
                  t.searchParams &&
                  URLSearchParams.prototype.isPrototypeOf(e)
                )
                  this._bodyText = e.toString();
                else {
                  var r;
                  t.arrayBuffer &&
                  t.blob &&
                  (r = e) &&
                  DataView.prototype.isPrototypeOf(r)
                    ? ((this._bodyArrayBuffer = bufferClone(e.buffer)),
                      (this._bodyInit = new Blob([this._bodyArrayBuffer])))
                    : t.arrayBuffer &&
                      (ArrayBuffer.prototype.isPrototypeOf(e) || n(e))
                    ? (this._bodyArrayBuffer = bufferClone(e))
                    : (this._bodyText = e = Object.prototype.toString.call(e));
                }
              } else this._bodyText = "";
              !this.headers.get("content-type") &&
                ("string" == typeof e
                  ? this.headers.set("content-type", "text/plain;charset=UTF-8")
                  : this._bodyBlob && this._bodyBlob.type
                  ? this.headers.set("content-type", this._bodyBlob.type)
                  : t.searchParams &&
                    URLSearchParams.prototype.isPrototypeOf(e) &&
                    this.headers.set(
                      "content-type",
                      "application/x-www-form-urlencoded;charset=UTF-8"
                    ));
            }),
            t.blob &&
              ((this.blob = function () {
                var e = consumed(this);
                if (e) return e;
                if (this._bodyBlob) return Promise.resolve(this._bodyBlob);
                if (this._bodyArrayBuffer)
                  return Promise.resolve(new Blob([this._bodyArrayBuffer]));
                if (!this._bodyFormData)
                  return Promise.resolve(new Blob([this._bodyText]));
                throw Error("could not read FormData body as blob");
              }),
              (this.arrayBuffer = function () {
                return this._bodyArrayBuffer
                  ? consumed(this) || Promise.resolve(this._bodyArrayBuffer)
                  : this.blob().then(readBlobAsArrayBuffer);
              })),
            (this.text = function () {
              var e,
                t,
                r,
                i = consumed(this);
              if (i) return i;
              if (this._bodyBlob)
                return (
                  (e = this._bodyBlob),
                  (r = fileReaderReady((t = new FileReader()))),
                  t.readAsText(e),
                  r
                );
              if (this._bodyArrayBuffer)
                return Promise.resolve(
                  (function (e) {
                    for (
                      var t = new Uint8Array(e), r = Array(t.length), i = 0;
                      i < t.length;
                      i++
                    )
                      r[i] = String.fromCharCode(t[i]);
                    return r.join("");
                  })(this._bodyArrayBuffer)
                );
              if (!this._bodyFormData) return Promise.resolve(this._bodyText);
              throw Error("could not read FormData body as text");
            }),
            t.formData &&
              (this.formData = function () {
                return this.text().then(decode);
              }),
            (this.json = function () {
              return this.text().then(JSON.parse);
            }),
            this
          );
        }
        (Headers.prototype.append = function (e, t) {
          (e = normalizeName(e)), (t = normalizeValue(t));
          var r = this.map[e];
          this.map[e] = r ? r + ", " + t : t;
        }),
          (Headers.prototype.delete = function (e) {
            delete this.map[normalizeName(e)];
          }),
          (Headers.prototype.get = function (e) {
            return (e = normalizeName(e)), this.has(e) ? this.map[e] : null;
          }),
          (Headers.prototype.has = function (e) {
            return this.map.hasOwnProperty(normalizeName(e));
          }),
          (Headers.prototype.set = function (e, t) {
            this.map[normalizeName(e)] = normalizeValue(t);
          }),
          (Headers.prototype.forEach = function (e, t) {
            for (var r in this.map)
              this.map.hasOwnProperty(r) && e.call(t, this.map[r], r, this);
          }),
          (Headers.prototype.keys = function () {
            var e = [];
            return (
              this.forEach(function (t, r) {
                e.push(r);
              }),
              iteratorFor(e)
            );
          }),
          (Headers.prototype.values = function () {
            var e = [];
            return (
              this.forEach(function (t) {
                e.push(t);
              }),
              iteratorFor(e)
            );
          }),
          (Headers.prototype.entries = function () {
            var e = [];
            return (
              this.forEach(function (t, r) {
                e.push([r, t]);
              }),
              iteratorFor(e)
            );
          }),
          t.iterable &&
            (Headers.prototype[Symbol.iterator] = Headers.prototype.entries);
        var s = ["DELETE", "GET", "HEAD", "OPTIONS", "POST", "PUT"];
        function Request(e, t) {
          var r,
            i,
            n = (t = t || {}).body;
          if (e instanceof Request) {
            if (e.bodyUsed) throw TypeError("Already read");
            (this.url = e.url),
              (this.credentials = e.credentials),
              t.headers || (this.headers = new Headers(e.headers)),
              (this.method = e.method),
              (this.mode = e.mode),
              (this.signal = e.signal),
              n ||
                null == e._bodyInit ||
                ((n = e._bodyInit), (e.bodyUsed = !0));
          } else this.url = String(e);
          if (
            ((this.credentials =
              t.credentials || this.credentials || "same-origin"),
            (t.headers || !this.headers) &&
              (this.headers = new Headers(t.headers)),
            (this.method =
              ((i = (r = t.method || this.method || "GET").toUpperCase()),
              s.indexOf(i) > -1 ? i : r)),
            (this.mode = t.mode || this.mode || null),
            (this.signal = t.signal || this.signal),
            (this.referrer = null),
            ("GET" === this.method || "HEAD" === this.method) && n)
          )
            throw TypeError("Body not allowed for GET or HEAD requests");
          this._initBody(n);
        }
        function decode(e) {
          var t = new FormData();
          return (
            e
              .trim()
              .split("&")
              .forEach(function (e) {
                if (e) {
                  var r = e.split("="),
                    i = r.shift().replace(/\+/g, " "),
                    n = r.join("=").replace(/\+/g, " ");
                  t.append(decodeURIComponent(i), decodeURIComponent(n));
                }
              }),
            t
          );
        }
        function Response(e, t) {
          t || (t = {}),
            (this.type = "default"),
            (this.status = void 0 === t.status ? 200 : t.status),
            (this.ok = this.status >= 200 && this.status < 300),
            (this.statusText = "statusText" in t ? t.statusText : "OK"),
            (this.headers = new Headers(t.headers)),
            (this.url = t.url || ""),
            this._initBody(e);
        }
        (Request.prototype.clone = function () {
          return new Request(this, { body: this._bodyInit });
        }),
          Body.call(Request.prototype),
          Body.call(Response.prototype),
          (Response.prototype.clone = function () {
            return new Response(this._bodyInit, {
              status: this.status,
              statusText: this.statusText,
              headers: new Headers(this.headers),
              url: this.url,
            });
          }),
          (Response.error = function () {
            var e = new Response(null, { status: 0, statusText: "" });
            return (e.type = "error"), e;
          });
        var o = [301, 302, 303, 307, 308];
        (Response.redirect = function (e, t) {
          if (-1 === o.indexOf(t)) throw RangeError("Invalid status code");
          return new Response(null, { status: t, headers: { location: e } });
        }),
          (e.DOMException = i.DOMException);
        try {
          new e.DOMException();
        } catch (t) {
          (e.DOMException = function (e, t) {
            (this.message = e), (this.name = t);
            var r = Error(e);
            this.stack = r.stack;
          }),
            (e.DOMException.prototype = Object.create(Error.prototype)),
            (e.DOMException.prototype.constructor = e.DOMException);
        }
        function fetch(r, i) {
          return new Promise(function (n, s) {
            var o = new Request(r, i);
            if (o.signal && o.signal.aborted)
              return s(new e.DOMException("Aborted", "AbortError"));
            var a = new XMLHttpRequest();
            function abortXhr() {
              a.abort();
            }
            (a.onload = function () {
              var e,
                t,
                r = {
                  status: a.status,
                  statusText: a.statusText,
                  headers:
                    ((e = a.getAllResponseHeaders() || ""),
                    (t = new Headers()),
                    e
                      .replace(/\r?\n[\t ]+/g, " ")
                      .split(/\r?\n/)
                      .forEach(function (e) {
                        var r = e.split(":"),
                          i = r.shift().trim();
                        if (i) {
                          var n = r.join(":").trim();
                          t.append(i, n);
                        }
                      }),
                    t),
                };
              r.url =
                "responseURL" in a
                  ? a.responseURL
                  : r.headers.get("X-Request-URL");
              var i = "response" in a ? a.response : a.responseText;
              n(new Response(i, r));
            }),
              (a.onerror = function () {
                s(TypeError("Network request failed"));
              }),
              (a.ontimeout = function () {
                s(TypeError("Network request failed"));
              }),
              (a.onabort = function () {
                s(new e.DOMException("Aborted", "AbortError"));
              }),
              a.open(o.method, o.url, !0),
              "include" === o.credentials
                ? (a.withCredentials = !0)
                : "omit" === o.credentials && (a.withCredentials = !1),
              "responseType" in a && t.blob && (a.responseType = "blob"),
              o.headers.forEach(function (e, t) {
                a.setRequestHeader(t, e);
              }),
              o.signal &&
                (o.signal.addEventListener("abort", abortXhr),
                (a.onreadystatechange = function () {
                  4 === a.readyState &&
                    o.signal.removeEventListener("abort", abortXhr);
                })),
              a.send(void 0 === o._bodyInit ? null : o._bodyInit);
          });
        }
        (fetch.polyfill = !0),
          i.fetch ||
            ((i.fetch = fetch),
            (i.Headers = Headers),
            (i.Request = Request),
            (i.Response = Response)),
          (e.Headers = Headers),
          (e.Request = Request),
          (e.Response = Response),
          (e.fetch = fetch),
          Object.defineProperty(e, "__esModule", { value: !0 });
      })({}),
        (i.fetch.ponyfill = !0),
        delete i.fetch.polyfill,
        ((t = i.fetch).default = i.fetch),
        (t.fetch = i.fetch),
        (t.Headers = i.Headers),
        (t.Request = i.Request),
        (t.Response = i.Response),
        (e.exports = t);
    },
    31365: function (e, t, r) {
      e.exports = r(62338);
    },
    80108: function (e, t, r) {
      "use strict";
      r.d(t, {
        g6: function () {
          return GraphQLClient;
        },
      });
      let i = JSON,
        uppercase = (e) => e.toUpperCase(),
        HeadersInstanceToPlainObject = (e) => {
          let t = {};
          return (
            e.forEach((e, r) => {
              t[r] = e;
            }),
            t
          );
        },
        parseRequestArgs = (e, t, r) =>
          e.document
            ? e
            : { document: e, variables: t, requestHeaders: r, signal: void 0 },
        parseRawRequestArgs = (e, t, r) =>
          e.query
            ? e
            : { query: e, variables: t, requestHeaders: r, signal: void 0 },
        parseBatchRequestArgs = (e, t) =>
          e.documents ? e : { documents: e, requestHeaders: t, signal: void 0 },
        n = /\r\n|[\n\r]/g;
      function getLocation(e, t) {
        let r = 0,
          i = 1;
        for (let s of e.body.matchAll(n)) {
          if (
            ("number" == typeof s.index ||
              (function (e, t) {
                if (!e)
                  throw Error(
                    null != t ? t : "Unexpected invariant triggered."
                  );
              })(!1),
            s.index >= t)
          )
            break;
          (r = s.index + s[0].length), (i += 1);
        }
        return { line: i, column: t + 1 - r };
      }
      function printSourceLocation(e, t) {
        let r = e.locationOffset.column - 1,
          i = "".padStart(r) + e.body,
          n = t.line - 1,
          s = e.locationOffset.line - 1,
          o = t.line + s,
          a = 1 === t.line ? r : 0,
          l = t.column + a,
          u = `${e.name}:${o}:${l}
`,
          c = i.split(/\r\n|[\n\r]/g),
          p = c[n];
        if (p.length > 120) {
          let e = Math.floor(l / 80),
            t = l % 80,
            r = [];
          for (let e = 0; e < p.length; e += 80) r.push(p.slice(e, e + 80));
          return (
            u +
            printPrefixedLines([
              [`${o} |`, r[0]],
              ...r.slice(1, e + 1).map((e) => ["|", e]),
              ["|", "^".padStart(t)],
              ["|", r[e + 1]],
            ])
          );
        }
        return (
          u +
          printPrefixedLines([
            [`${o - 1} |`, c[n - 1]],
            [`${o} |`, p],
            ["|", "^".padStart(l)],
            [`${o + 1} |`, c[n + 1]],
          ])
        );
      }
      function printPrefixedLines(e) {
        let t = e.filter(([e, t]) => void 0 !== t),
          r = Math.max(...t.map(([e]) => e.length));
        return t.map(([e, t]) => e.padStart(r) + (t ? " " + t : "")).join("\n");
      }
      let GraphQLError = class GraphQLError extends Error {
        constructor(e, ...t) {
          var r, i, n, s;
          let {
            nodes: o,
            source: a,
            positions: l,
            path: u,
            originalError: c,
            extensions: p,
          } = (function (e) {
            let t = e[0];
            return null == t || "kind" in t || "length" in t
              ? {
                  nodes: t,
                  source: e[1],
                  positions: e[2],
                  path: e[3],
                  originalError: e[4],
                  extensions: e[5],
                }
              : t;
          })(t);
          super(e),
            (this.name = "GraphQLError"),
            (this.path = null != u ? u : void 0),
            (this.originalError = null != c ? c : void 0),
            (this.nodes = undefinedIfEmpty(
              Array.isArray(o) ? o : o ? [o] : void 0
            ));
          let h = undefinedIfEmpty(
            null === (r = this.nodes) || void 0 === r
              ? void 0
              : r.map((e) => e.loc).filter((e) => null != e)
          );
          (this.source =
            null != a
              ? a
              : null == h
              ? void 0
              : null === (i = h[0]) || void 0 === i
              ? void 0
              : i.source),
            (this.positions =
              null != l ? l : null == h ? void 0 : h.map((e) => e.start)),
            (this.locations =
              l && a
                ? l.map((e) => getLocation(a, e))
                : null == h
                ? void 0
                : h.map((e) => getLocation(e.source, e.start)));
          let d =
            "object" == typeof (s = null == c ? void 0 : c.extensions) &&
            null !== s
              ? null == c
                ? void 0
                : c.extensions
              : void 0;
          (this.extensions =
            null !== (n = null != p ? p : d) && void 0 !== n
              ? n
              : Object.create(null)),
            Object.defineProperties(this, {
              message: { writable: !0, enumerable: !0 },
              name: { enumerable: !1 },
              nodes: { enumerable: !1 },
              source: { enumerable: !1 },
              positions: { enumerable: !1 },
              originalError: { enumerable: !1 },
            }),
            null != c && c.stack
              ? Object.defineProperty(this, "stack", {
                  value: c.stack,
                  writable: !0,
                  configurable: !0,
                })
              : Error.captureStackTrace
              ? Error.captureStackTrace(this, GraphQLError)
              : Object.defineProperty(this, "stack", {
                  value: Error().stack,
                  writable: !0,
                  configurable: !0,
                });
        }
        get [Symbol.toStringTag]() {
          return "GraphQLError";
        }
        toString() {
          let e = this.message;
          if (this.nodes) {
            for (let r of this.nodes)
              if (r.loc) {
                var t;
                e +=
                  "\n\n" +
                  printSourceLocation(
                    (t = r.loc).source,
                    getLocation(t.source, t.start)
                  );
              }
          } else if (this.source && this.locations)
            for (let t of this.locations)
              e += "\n\n" + printSourceLocation(this.source, t);
          return e;
        }
        toJSON() {
          let e = { message: this.message };
          return (
            null != this.locations && (e.locations = this.locations),
            null != this.path && (e.path = this.path),
            null != this.extensions &&
              Object.keys(this.extensions).length > 0 &&
              (e.extensions = this.extensions),
            e
          );
        }
      };
      function undefinedIfEmpty(e) {
        return void 0 === e || 0 === e.length ? void 0 : e;
      }
      function syntaxError(e, t, r) {
        return new GraphQLError(`Syntax Error: ${r}`, {
          source: e,
          positions: [t],
        });
      }
      let Location = class Location {
        constructor(e, t, r) {
          (this.start = e.start),
            (this.end = t.end),
            (this.startToken = e),
            (this.endToken = t),
            (this.source = r);
        }
        get [Symbol.toStringTag]() {
          return "Location";
        }
        toJSON() {
          return { start: this.start, end: this.end };
        }
      };
      let Token = class Token {
        constructor(e, t, r, i, n, s) {
          (this.kind = e),
            (this.start = t),
            (this.end = r),
            (this.line = i),
            (this.column = n),
            (this.value = s),
            (this.prev = null),
            (this.next = null);
        }
        get [Symbol.toStringTag]() {
          return "Token";
        }
        toJSON() {
          return {
            kind: this.kind,
            value: this.value,
            line: this.line,
            column: this.column,
          };
        }
      };
      let s = {
          Name: [],
          Document: ["definitions"],
          OperationDefinition: [
            "name",
            "variableDefinitions",
            "directives",
            "selectionSet",
          ],
          VariableDefinition: [
            "variable",
            "type",
            "defaultValue",
            "directives",
          ],
          Variable: ["name"],
          SelectionSet: ["selections"],
          Field: ["alias", "name", "arguments", "directives", "selectionSet"],
          Argument: ["name", "value"],
          FragmentSpread: ["name", "directives"],
          InlineFragment: ["typeCondition", "directives", "selectionSet"],
          FragmentDefinition: [
            "name",
            "variableDefinitions",
            "typeCondition",
            "directives",
            "selectionSet",
          ],
          IntValue: [],
          FloatValue: [],
          StringValue: [],
          BooleanValue: [],
          NullValue: [],
          EnumValue: [],
          ListValue: ["values"],
          ObjectValue: ["fields"],
          ObjectField: ["name", "value"],
          Directive: ["name", "arguments"],
          NamedType: ["name"],
          ListType: ["type"],
          NonNullType: ["type"],
          SchemaDefinition: ["description", "directives", "operationTypes"],
          OperationTypeDefinition: ["type"],
          ScalarTypeDefinition: ["description", "name", "directives"],
          ObjectTypeDefinition: [
            "description",
            "name",
            "interfaces",
            "directives",
            "fields",
          ],
          FieldDefinition: [
            "description",
            "name",
            "arguments",
            "type",
            "directives",
          ],
          InputValueDefinition: [
            "description",
            "name",
            "type",
            "defaultValue",
            "directives",
          ],
          InterfaceTypeDefinition: [
            "description",
            "name",
            "interfaces",
            "directives",
            "fields",
          ],
          UnionTypeDefinition: ["description", "name", "directives", "types"],
          EnumTypeDefinition: ["description", "name", "directives", "values"],
          EnumValueDefinition: ["description", "name", "directives"],
          InputObjectTypeDefinition: [
            "description",
            "name",
            "directives",
            "fields",
          ],
          DirectiveDefinition: [
            "description",
            "name",
            "arguments",
            "locations",
          ],
          SchemaExtension: ["directives", "operationTypes"],
          ScalarTypeExtension: ["name", "directives"],
          ObjectTypeExtension: ["name", "interfaces", "directives", "fields"],
          InterfaceTypeExtension: [
            "name",
            "interfaces",
            "directives",
            "fields",
          ],
          UnionTypeExtension: ["name", "directives", "types"],
          EnumTypeExtension: ["name", "directives", "values"],
          InputObjectTypeExtension: ["name", "directives", "fields"],
        },
        o = new Set(Object.keys(s));
      function isNode(e) {
        let t = null == e ? void 0 : e.kind;
        return "string" == typeof t && o.has(t);
      }
      function isWhiteSpace(e) {
        return 9 === e || 32 === e;
      }
      function isDigit(e) {
        return e >= 48 && e <= 57;
      }
      function isLetter(e) {
        return (e >= 97 && e <= 122) || (e >= 65 && e <= 90);
      }
      function isNameStart(e) {
        return isLetter(e) || 95 === e;
      }
      ((h = E || (E = {})).QUERY = "query"),
        (h.MUTATION = "mutation"),
        (h.SUBSCRIPTION = "subscription"),
        ((d = m || (m = {})).QUERY = "QUERY"),
        (d.MUTATION = "MUTATION"),
        (d.SUBSCRIPTION = "SUBSCRIPTION"),
        (d.FIELD = "FIELD"),
        (d.FRAGMENT_DEFINITION = "FRAGMENT_DEFINITION"),
        (d.FRAGMENT_SPREAD = "FRAGMENT_SPREAD"),
        (d.INLINE_FRAGMENT = "INLINE_FRAGMENT"),
        (d.VARIABLE_DEFINITION = "VARIABLE_DEFINITION"),
        (d.SCHEMA = "SCHEMA"),
        (d.SCALAR = "SCALAR"),
        (d.OBJECT = "OBJECT"),
        (d.FIELD_DEFINITION = "FIELD_DEFINITION"),
        (d.ARGUMENT_DEFINITION = "ARGUMENT_DEFINITION"),
        (d.INTERFACE = "INTERFACE"),
        (d.UNION = "UNION"),
        (d.ENUM = "ENUM"),
        (d.ENUM_VALUE = "ENUM_VALUE"),
        (d.INPUT_OBJECT = "INPUT_OBJECT"),
        (d.INPUT_FIELD_DEFINITION = "INPUT_FIELD_DEFINITION"),
        ((f = T || (T = {})).NAME = "Name"),
        (f.DOCUMENT = "Document"),
        (f.OPERATION_DEFINITION = "OperationDefinition"),
        (f.VARIABLE_DEFINITION = "VariableDefinition"),
        (f.SELECTION_SET = "SelectionSet"),
        (f.FIELD = "Field"),
        (f.ARGUMENT = "Argument"),
        (f.FRAGMENT_SPREAD = "FragmentSpread"),
        (f.INLINE_FRAGMENT = "InlineFragment"),
        (f.FRAGMENT_DEFINITION = "FragmentDefinition"),
        (f.VARIABLE = "Variable"),
        (f.INT = "IntValue"),
        (f.FLOAT = "FloatValue"),
        (f.STRING = "StringValue"),
        (f.BOOLEAN = "BooleanValue"),
        (f.NULL = "NullValue"),
        (f.ENUM = "EnumValue"),
        (f.LIST = "ListValue"),
        (f.OBJECT = "ObjectValue"),
        (f.OBJECT_FIELD = "ObjectField"),
        (f.DIRECTIVE = "Directive"),
        (f.NAMED_TYPE = "NamedType"),
        (f.LIST_TYPE = "ListType"),
        (f.NON_NULL_TYPE = "NonNullType"),
        (f.SCHEMA_DEFINITION = "SchemaDefinition"),
        (f.OPERATION_TYPE_DEFINITION = "OperationTypeDefinition"),
        (f.SCALAR_TYPE_DEFINITION = "ScalarTypeDefinition"),
        (f.OBJECT_TYPE_DEFINITION = "ObjectTypeDefinition"),
        (f.FIELD_DEFINITION = "FieldDefinition"),
        (f.INPUT_VALUE_DEFINITION = "InputValueDefinition"),
        (f.INTERFACE_TYPE_DEFINITION = "InterfaceTypeDefinition"),
        (f.UNION_TYPE_DEFINITION = "UnionTypeDefinition"),
        (f.ENUM_TYPE_DEFINITION = "EnumTypeDefinition"),
        (f.ENUM_VALUE_DEFINITION = "EnumValueDefinition"),
        (f.INPUT_OBJECT_TYPE_DEFINITION = "InputObjectTypeDefinition"),
        (f.DIRECTIVE_DEFINITION = "DirectiveDefinition"),
        (f.SCHEMA_EXTENSION = "SchemaExtension"),
        (f.SCALAR_TYPE_EXTENSION = "ScalarTypeExtension"),
        (f.OBJECT_TYPE_EXTENSION = "ObjectTypeExtension"),
        (f.INTERFACE_TYPE_EXTENSION = "InterfaceTypeExtension"),
        (f.UNION_TYPE_EXTENSION = "UnionTypeExtension"),
        (f.ENUM_TYPE_EXTENSION = "EnumTypeExtension"),
        (f.INPUT_OBJECT_TYPE_EXTENSION = "InputObjectTypeExtension"),
        ((y = v || (v = {})).SOF = "<SOF>"),
        (y.EOF = "<EOF>"),
        (y.BANG = "!"),
        (y.DOLLAR = "$"),
        (y.AMP = "&"),
        (y.PAREN_L = "("),
        (y.PAREN_R = ")"),
        (y.SPREAD = "..."),
        (y.COLON = ":"),
        (y.EQUALS = "="),
        (y.AT = "@"),
        (y.BRACKET_L = "["),
        (y.BRACKET_R = "]"),
        (y.BRACE_L = "{"),
        (y.PIPE = "|"),
        (y.BRACE_R = "}"),
        (y.NAME = "Name"),
        (y.INT = "Int"),
        (y.FLOAT = "Float"),
        (y.STRING = "String"),
        (y.BLOCK_STRING = "BlockString"),
        (y.COMMENT = "Comment");
      let Lexer = class Lexer {
        constructor(e) {
          let t = new Token(v.SOF, 0, 0, 0, 0);
          (this.source = e),
            (this.lastToken = t),
            (this.token = t),
            (this.line = 1),
            (this.lineStart = 0);
        }
        get [Symbol.toStringTag]() {
          return "Lexer";
        }
        advance() {
          this.lastToken = this.token;
          let e = (this.token = this.lookahead());
          return e;
        }
        lookahead() {
          let e = this.token;
          if (e.kind !== v.EOF)
            do
              if (e.next) e = e.next;
              else {
                let t = (function (e, t) {
                  let r = e.source.body,
                    i = r.length,
                    n = t;
                  for (; n < i; ) {
                    let t = r.charCodeAt(n);
                    switch (t) {
                      case 65279:
                      case 9:
                      case 32:
                      case 44:
                        ++n;
                        continue;
                      case 10:
                        ++n, ++e.line, (e.lineStart = n);
                        continue;
                      case 13:
                        10 === r.charCodeAt(n + 1) ? (n += 2) : ++n,
                          ++e.line,
                          (e.lineStart = n);
                        continue;
                      case 35:
                        return (function (e, t) {
                          let r = e.source.body,
                            i = r.length,
                            n = t + 1;
                          for (; n < i; ) {
                            let e = r.charCodeAt(n);
                            if (10 === e || 13 === e) break;
                            if (isUnicodeScalarValue(e)) ++n;
                            else if (isSupplementaryCodePoint(r, n)) n += 2;
                            else break;
                          }
                          return createToken(
                            e,
                            v.COMMENT,
                            t,
                            n,
                            r.slice(t + 1, n)
                          );
                        })(e, n);
                      case 33:
                        return createToken(e, v.BANG, n, n + 1);
                      case 36:
                        return createToken(e, v.DOLLAR, n, n + 1);
                      case 38:
                        return createToken(e, v.AMP, n, n + 1);
                      case 40:
                        return createToken(e, v.PAREN_L, n, n + 1);
                      case 41:
                        return createToken(e, v.PAREN_R, n, n + 1);
                      case 46:
                        if (
                          46 === r.charCodeAt(n + 1) &&
                          46 === r.charCodeAt(n + 2)
                        )
                          return createToken(e, v.SPREAD, n, n + 3);
                        break;
                      case 58:
                        return createToken(e, v.COLON, n, n + 1);
                      case 61:
                        return createToken(e, v.EQUALS, n, n + 1);
                      case 64:
                        return createToken(e, v.AT, n, n + 1);
                      case 91:
                        return createToken(e, v.BRACKET_L, n, n + 1);
                      case 93:
                        return createToken(e, v.BRACKET_R, n, n + 1);
                      case 123:
                        return createToken(e, v.BRACE_L, n, n + 1);
                      case 124:
                        return createToken(e, v.PIPE, n, n + 1);
                      case 125:
                        return createToken(e, v.BRACE_R, n, n + 1);
                      case 34:
                        if (
                          34 === r.charCodeAt(n + 1) &&
                          34 === r.charCodeAt(n + 2)
                        )
                          return (function (e, t) {
                            let r = e.source.body,
                              i = r.length,
                              n = e.lineStart,
                              s = t + 3,
                              o = s,
                              a = "",
                              l = [];
                            for (; s < i; ) {
                              let i = r.charCodeAt(s);
                              if (
                                34 === i &&
                                34 === r.charCodeAt(s + 1) &&
                                34 === r.charCodeAt(s + 2)
                              ) {
                                (a += r.slice(o, s)), l.push(a);
                                let i = createToken(
                                  e,
                                  v.BLOCK_STRING,
                                  t,
                                  s + 3,
                                  (function (e) {
                                    var t, r;
                                    let i = Number.MAX_SAFE_INTEGER,
                                      n = null,
                                      s = -1;
                                    for (let t = 0; t < e.length; ++t) {
                                      let o = e[t],
                                        a = (function (e) {
                                          let t = 0;
                                          for (
                                            ;
                                            t < e.length &&
                                            isWhiteSpace(e.charCodeAt(t));

                                          )
                                            ++t;
                                          return t;
                                        })(o);
                                      a !== o.length &&
                                        ((n =
                                          null !== (r = n) && void 0 !== r
                                            ? r
                                            : t),
                                        (s = t),
                                        0 !== t && a < i && (i = a));
                                    }
                                    return e
                                      .map((e, t) => (0 === t ? e : e.slice(i)))
                                      .slice(
                                        null !== (t = n) && void 0 !== t
                                          ? t
                                          : 0,
                                        s + 1
                                      );
                                  })(l).join("\n")
                                );
                                return (
                                  (e.line += l.length - 1), (e.lineStart = n), i
                                );
                              }
                              if (
                                92 === i &&
                                34 === r.charCodeAt(s + 1) &&
                                34 === r.charCodeAt(s + 2) &&
                                34 === r.charCodeAt(s + 3)
                              ) {
                                (a += r.slice(o, s)), (o = s + 1), (s += 4);
                                continue;
                              }
                              if (10 === i || 13 === i) {
                                (a += r.slice(o, s)),
                                  l.push(a),
                                  13 === i && 10 === r.charCodeAt(s + 1)
                                    ? (s += 2)
                                    : ++s,
                                  (a = ""),
                                  (o = s),
                                  (n = s);
                                continue;
                              }
                              if (isUnicodeScalarValue(i)) ++s;
                              else if (isSupplementaryCodePoint(r, s)) s += 2;
                              else
                                throw syntaxError(
                                  e.source,
                                  s,
                                  `Invalid character within String: ${printCodePointAt(
                                    e,
                                    s
                                  )}.`
                                );
                            }
                            throw syntaxError(
                              e.source,
                              s,
                              "Unterminated string."
                            );
                          })(e, n);
                        return (function (e, t) {
                          let r = e.source.body,
                            i = r.length,
                            n = t + 1,
                            s = n,
                            o = "";
                          for (; n < i; ) {
                            let i = r.charCodeAt(n);
                            if (34 === i)
                              return (
                                (o += r.slice(s, n)),
                                createToken(e, v.STRING, t, n + 1, o)
                              );
                            if (92 === i) {
                              o += r.slice(s, n);
                              let t =
                                117 === r.charCodeAt(n + 1)
                                  ? 123 === r.charCodeAt(n + 2)
                                    ? (function (e, t) {
                                        let r = e.source.body,
                                          i = 0,
                                          n = 3;
                                        for (; n < 12; ) {
                                          let e = r.charCodeAt(t + n++);
                                          if (125 === e) {
                                            if (
                                              n < 5 ||
                                              !isUnicodeScalarValue(i)
                                            )
                                              break;
                                            return {
                                              value: String.fromCodePoint(i),
                                              size: n,
                                            };
                                          }
                                          if (
                                            (i = (i << 4) | readHexDigit(e)) < 0
                                          )
                                            break;
                                        }
                                        throw syntaxError(
                                          e.source,
                                          t,
                                          `Invalid Unicode escape sequence: "${r.slice(
                                            t,
                                            t + n
                                          )}".`
                                        );
                                      })(e, n)
                                    : (function (e, t) {
                                        let r = e.source.body,
                                          i = read16BitHexCode(r, t + 2);
                                        if (isUnicodeScalarValue(i))
                                          return {
                                            value: String.fromCodePoint(i),
                                            size: 6,
                                          };
                                        if (
                                          isLeadingSurrogate(i) &&
                                          92 === r.charCodeAt(t + 6) &&
                                          117 === r.charCodeAt(t + 7)
                                        ) {
                                          let e = read16BitHexCode(r, t + 8);
                                          if (isTrailingSurrogate(e))
                                            return {
                                              value: String.fromCodePoint(i, e),
                                              size: 12,
                                            };
                                        }
                                        throw syntaxError(
                                          e.source,
                                          t,
                                          `Invalid Unicode escape sequence: "${r.slice(
                                            t,
                                            t + 6
                                          )}".`
                                        );
                                      })(e, n)
                                  : (function (e, t) {
                                      let r = e.source.body,
                                        i = r.charCodeAt(t + 1);
                                      switch (i) {
                                        case 34:
                                          return { value: '"', size: 2 };
                                        case 92:
                                          return { value: "\\", size: 2 };
                                        case 47:
                                          return { value: "/", size: 2 };
                                        case 98:
                                          return { value: "\b", size: 2 };
                                        case 102:
                                          return { value: "\f", size: 2 };
                                        case 110:
                                          return { value: "\n", size: 2 };
                                        case 114:
                                          return { value: "\r", size: 2 };
                                        case 116:
                                          return { value: "	", size: 2 };
                                      }
                                      throw syntaxError(
                                        e.source,
                                        t,
                                        `Invalid character escape sequence: "${r.slice(
                                          t,
                                          t + 2
                                        )}".`
                                      );
                                    })(e, n);
                              (o += t.value), (n += t.size), (s = n);
                              continue;
                            }
                            if (10 === i || 13 === i) break;
                            if (isUnicodeScalarValue(i)) ++n;
                            else if (isSupplementaryCodePoint(r, n)) n += 2;
                            else
                              throw syntaxError(
                                e.source,
                                n,
                                `Invalid character within String: ${printCodePointAt(
                                  e,
                                  n
                                )}.`
                              );
                          }
                          throw syntaxError(
                            e.source,
                            n,
                            "Unterminated string."
                          );
                        })(e, n);
                    }
                    if (isDigit(t) || 45 === t)
                      return (function (e, t, r) {
                        let i = e.source.body,
                          n = t,
                          s = r,
                          o = !1;
                        if ((45 === s && (s = i.charCodeAt(++n)), 48 === s)) {
                          if (isDigit((s = i.charCodeAt(++n))))
                            throw syntaxError(
                              e.source,
                              n,
                              `Invalid number, unexpected digit after 0: ${printCodePointAt(
                                e,
                                n
                              )}.`
                            );
                        } else (n = readDigits(e, n, s)), (s = i.charCodeAt(n));
                        if (
                          (46 === s &&
                            ((o = !0),
                            (s = i.charCodeAt(++n)),
                            (n = readDigits(e, n, s)),
                            (s = i.charCodeAt(n))),
                          (69 === s || 101 === s) &&
                            ((o = !0),
                            (43 === (s = i.charCodeAt(++n)) || 45 === s) &&
                              (s = i.charCodeAt(++n)),
                            (n = readDigits(e, n, s)),
                            (s = i.charCodeAt(n))),
                          46 === s || isNameStart(s))
                        )
                          throw syntaxError(
                            e.source,
                            n,
                            `Invalid number, expected digit but got: ${printCodePointAt(
                              e,
                              n
                            )}.`
                          );
                        return createToken(
                          e,
                          o ? v.FLOAT : v.INT,
                          t,
                          n,
                          i.slice(t, n)
                        );
                      })(e, n, t);
                    if (isNameStart(t))
                      return (function (e, t) {
                        let r = e.source.body,
                          i = r.length,
                          n = t + 1;
                        for (; n < i; ) {
                          let e = r.charCodeAt(n);
                          if (isLetter(e) || isDigit(e) || 95 === e) ++n;
                          else break;
                        }
                        return createToken(e, v.NAME, t, n, r.slice(t, n));
                      })(e, n);
                    throw syntaxError(
                      e.source,
                      n,
                      39 === t
                        ? "Unexpected single quote character ('), did you mean to use a double quote (\")?"
                        : isUnicodeScalarValue(t) ||
                          isSupplementaryCodePoint(r, n)
                        ? `Unexpected character: ${printCodePointAt(e, n)}.`
                        : `Invalid character: ${printCodePointAt(e, n)}.`
                    );
                  }
                  return createToken(e, v.EOF, i, i);
                })(this, e.end);
                (e.next = t), (t.prev = e), (e = t);
              }
            while (e.kind === v.COMMENT);
          return e;
        }
      };
      function isUnicodeScalarValue(e) {
        return (e >= 0 && e <= 55295) || (e >= 57344 && e <= 1114111);
      }
      function isSupplementaryCodePoint(e, t) {
        return (
          isLeadingSurrogate(e.charCodeAt(t)) &&
          isTrailingSurrogate(e.charCodeAt(t + 1))
        );
      }
      function isLeadingSurrogate(e) {
        return e >= 55296 && e <= 56319;
      }
      function isTrailingSurrogate(e) {
        return e >= 56320 && e <= 57343;
      }
      function printCodePointAt(e, t) {
        let r = e.source.body.codePointAt(t);
        if (void 0 === r) return v.EOF;
        if (r >= 32 && r <= 126) {
          let e = String.fromCodePoint(r);
          return '"' === e ? "'\"'" : `"${e}"`;
        }
        return "U+" + r.toString(16).toUpperCase().padStart(4, "0");
      }
      function createToken(e, t, r, i, n) {
        let s = e.line,
          o = 1 + r - e.lineStart;
        return new Token(t, r, i, s, o, n);
      }
      function readDigits(e, t, r) {
        if (!isDigit(r))
          throw syntaxError(
            e.source,
            t,
            `Invalid number, expected digit but got: ${printCodePointAt(e, t)}.`
          );
        let i = e.source.body,
          n = t + 1;
        for (; isDigit(i.charCodeAt(n)); ) ++n;
        return n;
      }
      function read16BitHexCode(e, t) {
        return (
          (readHexDigit(e.charCodeAt(t)) << 12) |
          (readHexDigit(e.charCodeAt(t + 1)) << 8) |
          (readHexDigit(e.charCodeAt(t + 2)) << 4) |
          readHexDigit(e.charCodeAt(t + 3))
        );
      }
      function readHexDigit(e) {
        return e >= 48 && e <= 57
          ? e - 48
          : e >= 65 && e <= 70
          ? e - 55
          : e >= 97 && e <= 102
          ? e - 87
          : -1;
      }
      function devAssert(e, t) {
        if (!e) throw Error(t);
      }
      function formatValue(e, t) {
        switch (typeof e) {
          case "string":
            return JSON.stringify(e);
          case "function":
            return e.name ? `[function ${e.name}]` : "[function]";
          case "object":
            return (function (e, t) {
              if (null === e) return "null";
              if (t.includes(e)) return "[Circular]";
              let r = [...t, e];
              if ("function" == typeof e.toJSON) {
                let t = e.toJSON();
                if (t !== e)
                  return "string" == typeof t ? t : formatValue(t, r);
              } else if (Array.isArray(e))
                return (function (e, t) {
                  if (0 === e.length) return "[]";
                  if (t.length > 2) return "[Array]";
                  let r = Math.min(10, e.length),
                    i = e.length - r,
                    n = [];
                  for (let i = 0; i < r; ++i) n.push(formatValue(e[i], t));
                  return (
                    1 === i
                      ? n.push("... 1 more item")
                      : i > 1 && n.push(`... ${i} more items`),
                    "[" + n.join(", ") + "]"
                  );
                })(e, r);
              return (function (e, t) {
                let r = Object.entries(e);
                if (0 === r.length) return "{}";
                if (t.length > 2)
                  return (
                    "[" +
                    (function (e) {
                      let t = Object.prototype.toString
                        .call(e)
                        .replace(/^\[object /, "")
                        .replace(/]$/, "");
                      if (
                        "Object" === t &&
                        "function" == typeof e.constructor
                      ) {
                        let t = e.constructor.name;
                        if ("string" == typeof t && "" !== t) return t;
                      }
                      return t;
                    })(e) +
                    "]"
                  );
                let i = r.map(([e, r]) => e + ": " + formatValue(r, t));
                return "{ " + i.join(", ") + " }";
              })(e, r);
            })(e, t);
          default:
            return String(e);
        }
      }
      let a =
        globalThis.process && "production" === globalThis.process.env.NODE_ENV
          ? function (e, t) {
              return e instanceof t;
            }
          : function (e, t) {
              if (e instanceof t) return !0;
              if ("object" == typeof e && null !== e) {
                var r;
                let i = t.prototype[Symbol.toStringTag],
                  n =
                    Symbol.toStringTag in e
                      ? e[Symbol.toStringTag]
                      : null === (r = e.constructor) || void 0 === r
                      ? void 0
                      : r.name;
                if (i === n) {
                  let t = formatValue(e, []);
                  throw Error(`Cannot use ${i} "${t}" from another module or realm.

Ensure that there is only one instance of "graphql" in the node_modules
directory. If different versions of "graphql" are the dependencies of other
relied on modules, use "resolutions" to ensure only one version is installed.

https://yarnpkg.com/en/docs/selective-version-resolutions

Duplicate "graphql" modules cannot be used at the same time since different
versions may have different capabilities and behavior. The data from one
version used in the function from another could produce confusing and
spurious results.`);
                }
              }
              return !1;
            };
      let Source = class Source {
        constructor(e, t = "GraphQL request", r = { line: 1, column: 1 }) {
          "string" == typeof e ||
            devAssert(
              !1,
              `Body must be a string. Received: ${formatValue(e, [])}.`
            ),
            (this.body = e),
            (this.name = t),
            (this.locationOffset = r),
            this.locationOffset.line > 0 ||
              devAssert(
                !1,
                "line in locationOffset is 1-indexed and must be positive."
              ),
            this.locationOffset.column > 0 ||
              devAssert(
                !1,
                "column in locationOffset is 1-indexed and must be positive."
              );
        }
        get [Symbol.toStringTag]() {
          return "Source";
        }
      };
      let Parser = class Parser {
        constructor(e, t = {}) {
          let r = a(e, Source) ? e : new Source(e);
          (this._lexer = new Lexer(r)),
            (this._options = t),
            (this._tokenCounter = 0);
        }
        parseName() {
          let e = this.expectToken(v.NAME);
          return this.node(e, { kind: T.NAME, value: e.value });
        }
        parseDocument() {
          return this.node(this._lexer.token, {
            kind: T.DOCUMENT,
            definitions: this.many(v.SOF, this.parseDefinition, v.EOF),
          });
        }
        parseDefinition() {
          if (this.peek(v.BRACE_L)) return this.parseOperationDefinition();
          let e = this.peekDescription(),
            t = e ? this._lexer.lookahead() : this._lexer.token;
          if (t.kind === v.NAME) {
            switch (t.value) {
              case "schema":
                return this.parseSchemaDefinition();
              case "scalar":
                return this.parseScalarTypeDefinition();
              case "type":
                return this.parseObjectTypeDefinition();
              case "interface":
                return this.parseInterfaceTypeDefinition();
              case "union":
                return this.parseUnionTypeDefinition();
              case "enum":
                return this.parseEnumTypeDefinition();
              case "input":
                return this.parseInputObjectTypeDefinition();
              case "directive":
                return this.parseDirectiveDefinition();
            }
            if (e)
              throw syntaxError(
                this._lexer.source,
                this._lexer.token.start,
                "Unexpected description, descriptions are supported only on type definitions."
              );
            switch (t.value) {
              case "query":
              case "mutation":
              case "subscription":
                return this.parseOperationDefinition();
              case "fragment":
                return this.parseFragmentDefinition();
              case "extend":
                return this.parseTypeSystemExtension();
            }
          }
          throw this.unexpected(t);
        }
        parseOperationDefinition() {
          let e;
          let t = this._lexer.token;
          if (this.peek(v.BRACE_L))
            return this.node(t, {
              kind: T.OPERATION_DEFINITION,
              operation: E.QUERY,
              name: void 0,
              variableDefinitions: [],
              directives: [],
              selectionSet: this.parseSelectionSet(),
            });
          let r = this.parseOperationType();
          return (
            this.peek(v.NAME) && (e = this.parseName()),
            this.node(t, {
              kind: T.OPERATION_DEFINITION,
              operation: r,
              name: e,
              variableDefinitions: this.parseVariableDefinitions(),
              directives: this.parseDirectives(!1),
              selectionSet: this.parseSelectionSet(),
            })
          );
        }
        parseOperationType() {
          let e = this.expectToken(v.NAME);
          switch (e.value) {
            case "query":
              return E.QUERY;
            case "mutation":
              return E.MUTATION;
            case "subscription":
              return E.SUBSCRIPTION;
          }
          throw this.unexpected(e);
        }
        parseVariableDefinitions() {
          return this.optionalMany(
            v.PAREN_L,
            this.parseVariableDefinition,
            v.PAREN_R
          );
        }
        parseVariableDefinition() {
          return this.node(this._lexer.token, {
            kind: T.VARIABLE_DEFINITION,
            variable: this.parseVariable(),
            type: (this.expectToken(v.COLON), this.parseTypeReference()),
            defaultValue: this.expectOptionalToken(v.EQUALS)
              ? this.parseConstValueLiteral()
              : void 0,
            directives: this.parseConstDirectives(),
          });
        }
        parseVariable() {
          let e = this._lexer.token;
          return (
            this.expectToken(v.DOLLAR),
            this.node(e, { kind: T.VARIABLE, name: this.parseName() })
          );
        }
        parseSelectionSet() {
          return this.node(this._lexer.token, {
            kind: T.SELECTION_SET,
            selections: this.many(v.BRACE_L, this.parseSelection, v.BRACE_R),
          });
        }
        parseSelection() {
          return this.peek(v.SPREAD) ? this.parseFragment() : this.parseField();
        }
        parseField() {
          let e, t;
          let r = this._lexer.token,
            i = this.parseName();
          return (
            this.expectOptionalToken(v.COLON)
              ? ((e = i), (t = this.parseName()))
              : (t = i),
            this.node(r, {
              kind: T.FIELD,
              alias: e,
              name: t,
              arguments: this.parseArguments(!1),
              directives: this.parseDirectives(!1),
              selectionSet: this.peek(v.BRACE_L)
                ? this.parseSelectionSet()
                : void 0,
            })
          );
        }
        parseArguments(e) {
          let t = e ? this.parseConstArgument : this.parseArgument;
          return this.optionalMany(v.PAREN_L, t, v.PAREN_R);
        }
        parseArgument(e = !1) {
          let t = this._lexer.token,
            r = this.parseName();
          return (
            this.expectToken(v.COLON),
            this.node(t, {
              kind: T.ARGUMENT,
              name: r,
              value: this.parseValueLiteral(e),
            })
          );
        }
        parseConstArgument() {
          return this.parseArgument(!0);
        }
        parseFragment() {
          let e = this._lexer.token;
          this.expectToken(v.SPREAD);
          let t = this.expectOptionalKeyword("on");
          return !t && this.peek(v.NAME)
            ? this.node(e, {
                kind: T.FRAGMENT_SPREAD,
                name: this.parseFragmentName(),
                directives: this.parseDirectives(!1),
              })
            : this.node(e, {
                kind: T.INLINE_FRAGMENT,
                typeCondition: t ? this.parseNamedType() : void 0,
                directives: this.parseDirectives(!1),
                selectionSet: this.parseSelectionSet(),
              });
        }
        parseFragmentDefinition() {
          let e = this._lexer.token;
          return (this.expectKeyword("fragment"),
          !0 === this._options.allowLegacyFragmentVariables)
            ? this.node(e, {
                kind: T.FRAGMENT_DEFINITION,
                name: this.parseFragmentName(),
                variableDefinitions: this.parseVariableDefinitions(),
                typeCondition:
                  (this.expectKeyword("on"), this.parseNamedType()),
                directives: this.parseDirectives(!1),
                selectionSet: this.parseSelectionSet(),
              })
            : this.node(e, {
                kind: T.FRAGMENT_DEFINITION,
                name: this.parseFragmentName(),
                typeCondition:
                  (this.expectKeyword("on"), this.parseNamedType()),
                directives: this.parseDirectives(!1),
                selectionSet: this.parseSelectionSet(),
              });
        }
        parseFragmentName() {
          if ("on" === this._lexer.token.value) throw this.unexpected();
          return this.parseName();
        }
        parseValueLiteral(e) {
          let t = this._lexer.token;
          switch (t.kind) {
            case v.BRACKET_L:
              return this.parseList(e);
            case v.BRACE_L:
              return this.parseObject(e);
            case v.INT:
              return (
                this.advanceLexer(),
                this.node(t, { kind: T.INT, value: t.value })
              );
            case v.FLOAT:
              return (
                this.advanceLexer(),
                this.node(t, { kind: T.FLOAT, value: t.value })
              );
            case v.STRING:
            case v.BLOCK_STRING:
              return this.parseStringLiteral();
            case v.NAME:
              switch ((this.advanceLexer(), t.value)) {
                case "true":
                  return this.node(t, { kind: T.BOOLEAN, value: !0 });
                case "false":
                  return this.node(t, { kind: T.BOOLEAN, value: !1 });
                case "null":
                  return this.node(t, { kind: T.NULL });
                default:
                  return this.node(t, { kind: T.ENUM, value: t.value });
              }
            case v.DOLLAR:
              if (e) {
                if (
                  (this.expectToken(v.DOLLAR),
                  this._lexer.token.kind === v.NAME)
                ) {
                  let e = this._lexer.token.value;
                  throw syntaxError(
                    this._lexer.source,
                    t.start,
                    `Unexpected variable "$${e}" in constant value.`
                  );
                }
                throw this.unexpected(t);
              }
              return this.parseVariable();
            default:
              throw this.unexpected();
          }
        }
        parseConstValueLiteral() {
          return this.parseValueLiteral(!0);
        }
        parseStringLiteral() {
          let e = this._lexer.token;
          return (
            this.advanceLexer(),
            this.node(e, {
              kind: T.STRING,
              value: e.value,
              block: e.kind === v.BLOCK_STRING,
            })
          );
        }
        parseList(e) {
          return this.node(this._lexer.token, {
            kind: T.LIST,
            values: this.any(
              v.BRACKET_L,
              () => this.parseValueLiteral(e),
              v.BRACKET_R
            ),
          });
        }
        parseObject(e) {
          return this.node(this._lexer.token, {
            kind: T.OBJECT,
            fields: this.any(
              v.BRACE_L,
              () => this.parseObjectField(e),
              v.BRACE_R
            ),
          });
        }
        parseObjectField(e) {
          let t = this._lexer.token,
            r = this.parseName();
          return (
            this.expectToken(v.COLON),
            this.node(t, {
              kind: T.OBJECT_FIELD,
              name: r,
              value: this.parseValueLiteral(e),
            })
          );
        }
        parseDirectives(e) {
          let t = [];
          for (; this.peek(v.AT); ) t.push(this.parseDirective(e));
          return t;
        }
        parseConstDirectives() {
          return this.parseDirectives(!0);
        }
        parseDirective(e) {
          let t = this._lexer.token;
          return (
            this.expectToken(v.AT),
            this.node(t, {
              kind: T.DIRECTIVE,
              name: this.parseName(),
              arguments: this.parseArguments(e),
            })
          );
        }
        parseTypeReference() {
          let e;
          let t = this._lexer.token;
          if (this.expectOptionalToken(v.BRACKET_L)) {
            let r = this.parseTypeReference();
            this.expectToken(v.BRACKET_R),
              (e = this.node(t, { kind: T.LIST_TYPE, type: r }));
          } else e = this.parseNamedType();
          return this.expectOptionalToken(v.BANG)
            ? this.node(t, { kind: T.NON_NULL_TYPE, type: e })
            : e;
        }
        parseNamedType() {
          return this.node(this._lexer.token, {
            kind: T.NAMED_TYPE,
            name: this.parseName(),
          });
        }
        peekDescription() {
          return this.peek(v.STRING) || this.peek(v.BLOCK_STRING);
        }
        parseDescription() {
          if (this.peekDescription()) return this.parseStringLiteral();
        }
        parseSchemaDefinition() {
          let e = this._lexer.token,
            t = this.parseDescription();
          this.expectKeyword("schema");
          let r = this.parseConstDirectives(),
            i = this.many(
              v.BRACE_L,
              this.parseOperationTypeDefinition,
              v.BRACE_R
            );
          return this.node(e, {
            kind: T.SCHEMA_DEFINITION,
            description: t,
            directives: r,
            operationTypes: i,
          });
        }
        parseOperationTypeDefinition() {
          let e = this._lexer.token,
            t = this.parseOperationType();
          this.expectToken(v.COLON);
          let r = this.parseNamedType();
          return this.node(e, {
            kind: T.OPERATION_TYPE_DEFINITION,
            operation: t,
            type: r,
          });
        }
        parseScalarTypeDefinition() {
          let e = this._lexer.token,
            t = this.parseDescription();
          this.expectKeyword("scalar");
          let r = this.parseName(),
            i = this.parseConstDirectives();
          return this.node(e, {
            kind: T.SCALAR_TYPE_DEFINITION,
            description: t,
            name: r,
            directives: i,
          });
        }
        parseObjectTypeDefinition() {
          let e = this._lexer.token,
            t = this.parseDescription();
          this.expectKeyword("type");
          let r = this.parseName(),
            i = this.parseImplementsInterfaces(),
            n = this.parseConstDirectives(),
            s = this.parseFieldsDefinition();
          return this.node(e, {
            kind: T.OBJECT_TYPE_DEFINITION,
            description: t,
            name: r,
            interfaces: i,
            directives: n,
            fields: s,
          });
        }
        parseImplementsInterfaces() {
          return this.expectOptionalKeyword("implements")
            ? this.delimitedMany(v.AMP, this.parseNamedType)
            : [];
        }
        parseFieldsDefinition() {
          return this.optionalMany(
            v.BRACE_L,
            this.parseFieldDefinition,
            v.BRACE_R
          );
        }
        parseFieldDefinition() {
          let e = this._lexer.token,
            t = this.parseDescription(),
            r = this.parseName(),
            i = this.parseArgumentDefs();
          this.expectToken(v.COLON);
          let n = this.parseTypeReference(),
            s = this.parseConstDirectives();
          return this.node(e, {
            kind: T.FIELD_DEFINITION,
            description: t,
            name: r,
            arguments: i,
            type: n,
            directives: s,
          });
        }
        parseArgumentDefs() {
          return this.optionalMany(
            v.PAREN_L,
            this.parseInputValueDef,
            v.PAREN_R
          );
        }
        parseInputValueDef() {
          let e;
          let t = this._lexer.token,
            r = this.parseDescription(),
            i = this.parseName();
          this.expectToken(v.COLON);
          let n = this.parseTypeReference();
          this.expectOptionalToken(v.EQUALS) &&
            (e = this.parseConstValueLiteral());
          let s = this.parseConstDirectives();
          return this.node(t, {
            kind: T.INPUT_VALUE_DEFINITION,
            description: r,
            name: i,
            type: n,
            defaultValue: e,
            directives: s,
          });
        }
        parseInterfaceTypeDefinition() {
          let e = this._lexer.token,
            t = this.parseDescription();
          this.expectKeyword("interface");
          let r = this.parseName(),
            i = this.parseImplementsInterfaces(),
            n = this.parseConstDirectives(),
            s = this.parseFieldsDefinition();
          return this.node(e, {
            kind: T.INTERFACE_TYPE_DEFINITION,
            description: t,
            name: r,
            interfaces: i,
            directives: n,
            fields: s,
          });
        }
        parseUnionTypeDefinition() {
          let e = this._lexer.token,
            t = this.parseDescription();
          this.expectKeyword("union");
          let r = this.parseName(),
            i = this.parseConstDirectives(),
            n = this.parseUnionMemberTypes();
          return this.node(e, {
            kind: T.UNION_TYPE_DEFINITION,
            description: t,
            name: r,
            directives: i,
            types: n,
          });
        }
        parseUnionMemberTypes() {
          return this.expectOptionalToken(v.EQUALS)
            ? this.delimitedMany(v.PIPE, this.parseNamedType)
            : [];
        }
        parseEnumTypeDefinition() {
          let e = this._lexer.token,
            t = this.parseDescription();
          this.expectKeyword("enum");
          let r = this.parseName(),
            i = this.parseConstDirectives(),
            n = this.parseEnumValuesDefinition();
          return this.node(e, {
            kind: T.ENUM_TYPE_DEFINITION,
            description: t,
            name: r,
            directives: i,
            values: n,
          });
        }
        parseEnumValuesDefinition() {
          return this.optionalMany(
            v.BRACE_L,
            this.parseEnumValueDefinition,
            v.BRACE_R
          );
        }
        parseEnumValueDefinition() {
          let e = this._lexer.token,
            t = this.parseDescription(),
            r = this.parseEnumValueName(),
            i = this.parseConstDirectives();
          return this.node(e, {
            kind: T.ENUM_VALUE_DEFINITION,
            description: t,
            name: r,
            directives: i,
          });
        }
        parseEnumValueName() {
          if (
            "true" === this._lexer.token.value ||
            "false" === this._lexer.token.value ||
            "null" === this._lexer.token.value
          )
            throw syntaxError(
              this._lexer.source,
              this._lexer.token.start,
              `${getTokenDesc(
                this._lexer.token
              )} is reserved and cannot be used for an enum value.`
            );
          return this.parseName();
        }
        parseInputObjectTypeDefinition() {
          let e = this._lexer.token,
            t = this.parseDescription();
          this.expectKeyword("input");
          let r = this.parseName(),
            i = this.parseConstDirectives(),
            n = this.parseInputFieldsDefinition();
          return this.node(e, {
            kind: T.INPUT_OBJECT_TYPE_DEFINITION,
            description: t,
            name: r,
            directives: i,
            fields: n,
          });
        }
        parseInputFieldsDefinition() {
          return this.optionalMany(
            v.BRACE_L,
            this.parseInputValueDef,
            v.BRACE_R
          );
        }
        parseTypeSystemExtension() {
          let e = this._lexer.lookahead();
          if (e.kind === v.NAME)
            switch (e.value) {
              case "schema":
                return this.parseSchemaExtension();
              case "scalar":
                return this.parseScalarTypeExtension();
              case "type":
                return this.parseObjectTypeExtension();
              case "interface":
                return this.parseInterfaceTypeExtension();
              case "union":
                return this.parseUnionTypeExtension();
              case "enum":
                return this.parseEnumTypeExtension();
              case "input":
                return this.parseInputObjectTypeExtension();
            }
          throw this.unexpected(e);
        }
        parseSchemaExtension() {
          let e = this._lexer.token;
          this.expectKeyword("extend"), this.expectKeyword("schema");
          let t = this.parseConstDirectives(),
            r = this.optionalMany(
              v.BRACE_L,
              this.parseOperationTypeDefinition,
              v.BRACE_R
            );
          if (0 === t.length && 0 === r.length) throw this.unexpected();
          return this.node(e, {
            kind: T.SCHEMA_EXTENSION,
            directives: t,
            operationTypes: r,
          });
        }
        parseScalarTypeExtension() {
          let e = this._lexer.token;
          this.expectKeyword("extend"), this.expectKeyword("scalar");
          let t = this.parseName(),
            r = this.parseConstDirectives();
          if (0 === r.length) throw this.unexpected();
          return this.node(e, {
            kind: T.SCALAR_TYPE_EXTENSION,
            name: t,
            directives: r,
          });
        }
        parseObjectTypeExtension() {
          let e = this._lexer.token;
          this.expectKeyword("extend"), this.expectKeyword("type");
          let t = this.parseName(),
            r = this.parseImplementsInterfaces(),
            i = this.parseConstDirectives(),
            n = this.parseFieldsDefinition();
          if (0 === r.length && 0 === i.length && 0 === n.length)
            throw this.unexpected();
          return this.node(e, {
            kind: T.OBJECT_TYPE_EXTENSION,
            name: t,
            interfaces: r,
            directives: i,
            fields: n,
          });
        }
        parseInterfaceTypeExtension() {
          let e = this._lexer.token;
          this.expectKeyword("extend"), this.expectKeyword("interface");
          let t = this.parseName(),
            r = this.parseImplementsInterfaces(),
            i = this.parseConstDirectives(),
            n = this.parseFieldsDefinition();
          if (0 === r.length && 0 === i.length && 0 === n.length)
            throw this.unexpected();
          return this.node(e, {
            kind: T.INTERFACE_TYPE_EXTENSION,
            name: t,
            interfaces: r,
            directives: i,
            fields: n,
          });
        }
        parseUnionTypeExtension() {
          let e = this._lexer.token;
          this.expectKeyword("extend"), this.expectKeyword("union");
          let t = this.parseName(),
            r = this.parseConstDirectives(),
            i = this.parseUnionMemberTypes();
          if (0 === r.length && 0 === i.length) throw this.unexpected();
          return this.node(e, {
            kind: T.UNION_TYPE_EXTENSION,
            name: t,
            directives: r,
            types: i,
          });
        }
        parseEnumTypeExtension() {
          let e = this._lexer.token;
          this.expectKeyword("extend"), this.expectKeyword("enum");
          let t = this.parseName(),
            r = this.parseConstDirectives(),
            i = this.parseEnumValuesDefinition();
          if (0 === r.length && 0 === i.length) throw this.unexpected();
          return this.node(e, {
            kind: T.ENUM_TYPE_EXTENSION,
            name: t,
            directives: r,
            values: i,
          });
        }
        parseInputObjectTypeExtension() {
          let e = this._lexer.token;
          this.expectKeyword("extend"), this.expectKeyword("input");
          let t = this.parseName(),
            r = this.parseConstDirectives(),
            i = this.parseInputFieldsDefinition();
          if (0 === r.length && 0 === i.length) throw this.unexpected();
          return this.node(e, {
            kind: T.INPUT_OBJECT_TYPE_EXTENSION,
            name: t,
            directives: r,
            fields: i,
          });
        }
        parseDirectiveDefinition() {
          let e = this._lexer.token,
            t = this.parseDescription();
          this.expectKeyword("directive"), this.expectToken(v.AT);
          let r = this.parseName(),
            i = this.parseArgumentDefs(),
            n = this.expectOptionalKeyword("repeatable");
          this.expectKeyword("on");
          let s = this.parseDirectiveLocations();
          return this.node(e, {
            kind: T.DIRECTIVE_DEFINITION,
            description: t,
            name: r,
            arguments: i,
            repeatable: n,
            locations: s,
          });
        }
        parseDirectiveLocations() {
          return this.delimitedMany(v.PIPE, this.parseDirectiveLocation);
        }
        parseDirectiveLocation() {
          let e = this._lexer.token,
            t = this.parseName();
          if (Object.prototype.hasOwnProperty.call(m, t.value)) return t;
          throw this.unexpected(e);
        }
        node(e, t) {
          return (
            !0 !== this._options.noLocation &&
              (t.loc = new Location(
                e,
                this._lexer.lastToken,
                this._lexer.source
              )),
            t
          );
        }
        peek(e) {
          return this._lexer.token.kind === e;
        }
        expectToken(e) {
          let t = this._lexer.token;
          if (t.kind === e) return this.advanceLexer(), t;
          throw syntaxError(
            this._lexer.source,
            t.start,
            `Expected ${getTokenKindDesc(e)}, found ${getTokenDesc(t)}.`
          );
        }
        expectOptionalToken(e) {
          let t = this._lexer.token;
          return t.kind === e && (this.advanceLexer(), !0);
        }
        expectKeyword(e) {
          let t = this._lexer.token;
          if (t.kind === v.NAME && t.value === e) this.advanceLexer();
          else
            throw syntaxError(
              this._lexer.source,
              t.start,
              `Expected "${e}", found ${getTokenDesc(t)}.`
            );
        }
        expectOptionalKeyword(e) {
          let t = this._lexer.token;
          return (
            t.kind === v.NAME && t.value === e && (this.advanceLexer(), !0)
          );
        }
        unexpected(e) {
          let t = null != e ? e : this._lexer.token;
          return syntaxError(
            this._lexer.source,
            t.start,
            `Unexpected ${getTokenDesc(t)}.`
          );
        }
        any(e, t, r) {
          this.expectToken(e);
          let i = [];
          for (; !this.expectOptionalToken(r); ) i.push(t.call(this));
          return i;
        }
        optionalMany(e, t, r) {
          if (this.expectOptionalToken(e)) {
            let e = [];
            do e.push(t.call(this));
            while (!this.expectOptionalToken(r));
            return e;
          }
          return [];
        }
        many(e, t, r) {
          this.expectToken(e);
          let i = [];
          do i.push(t.call(this));
          while (!this.expectOptionalToken(r));
          return i;
        }
        delimitedMany(e, t) {
          this.expectOptionalToken(e);
          let r = [];
          do r.push(t.call(this));
          while (this.expectOptionalToken(e));
          return r;
        }
        advanceLexer() {
          let { maxTokens: e } = this._options,
            t = this._lexer.advance();
          if (
            void 0 !== e &&
            t.kind !== v.EOF &&
            (++this._tokenCounter, this._tokenCounter > e)
          )
            throw syntaxError(
              this._lexer.source,
              t.start,
              `Document contains more that ${e} tokens. Parsing aborted.`
            );
        }
      };
      function getTokenDesc(e) {
        let t = e.value;
        return getTokenKindDesc(e.kind) + (null != t ? ` "${t}"` : "");
      }
      function getTokenKindDesc(e) {
        return e === v.BANG ||
          e === v.DOLLAR ||
          e === v.AMP ||
          e === v.PAREN_L ||
          e === v.PAREN_R ||
          e === v.SPREAD ||
          e === v.COLON ||
          e === v.EQUALS ||
          e === v.AT ||
          e === v.BRACKET_L ||
          e === v.BRACKET_R ||
          e === v.BRACE_L ||
          e === v.PIPE ||
          e === v.BRACE_R
          ? `"${e}"`
          : e;
      }
      let l = /[\x00-\x1f\x22\x5c\x7f-\x9f]/g;
      function escapedReplacer(e) {
        return u[e.charCodeAt(0)];
      }
      let u = [
          "\\u0000",
          "\\u0001",
          "\\u0002",
          "\\u0003",
          "\\u0004",
          "\\u0005",
          "\\u0006",
          "\\u0007",
          "\\b",
          "\\t",
          "\\n",
          "\\u000B",
          "\\f",
          "\\r",
          "\\u000E",
          "\\u000F",
          "\\u0010",
          "\\u0011",
          "\\u0012",
          "\\u0013",
          "\\u0014",
          "\\u0015",
          "\\u0016",
          "\\u0017",
          "\\u0018",
          "\\u0019",
          "\\u001A",
          "\\u001B",
          "\\u001C",
          "\\u001D",
          "\\u001E",
          "\\u001F",
          "",
          "",
          '\\"',
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "\\\\",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "",
          "\\u007F",
          "\\u0080",
          "\\u0081",
          "\\u0082",
          "\\u0083",
          "\\u0084",
          "\\u0085",
          "\\u0086",
          "\\u0087",
          "\\u0088",
          "\\u0089",
          "\\u008A",
          "\\u008B",
          "\\u008C",
          "\\u008D",
          "\\u008E",
          "\\u008F",
          "\\u0090",
          "\\u0091",
          "\\u0092",
          "\\u0093",
          "\\u0094",
          "\\u0095",
          "\\u0096",
          "\\u0097",
          "\\u0098",
          "\\u0099",
          "\\u009A",
          "\\u009B",
          "\\u009C",
          "\\u009D",
          "\\u009E",
          "\\u009F",
        ],
        c = Object.freeze({}),
        p = {
          Name: { leave: (e) => e.value },
          Variable: { leave: (e) => "$" + e.name },
          Document: { leave: (e) => join(e.definitions, "\n\n") },
          OperationDefinition: {
            leave(e) {
              let t = wrap("(", join(e.variableDefinitions, ", "), ")"),
                r = join(
                  [e.operation, join([e.name, t]), join(e.directives, " ")],
                  " "
                );
              return ("query" === r ? "" : r + " ") + e.selectionSet;
            },
          },
          VariableDefinition: {
            leave: ({ variable: e, type: t, defaultValue: r, directives: i }) =>
              e + ": " + t + wrap(" = ", r) + wrap(" ", join(i, " ")),
          },
          SelectionSet: { leave: ({ selections: e }) => block(e) },
          Field: {
            leave({
              alias: e,
              name: t,
              arguments: r,
              directives: i,
              selectionSet: n,
            }) {
              let s = wrap("", e, ": ") + t,
                o = s + wrap("(", join(r, ", "), ")");
              return (
                o.length > 80 &&
                  (o = s + wrap("(\n", indent(join(r, "\n")), "\n)")),
                join([o, join(i, " "), n], " ")
              );
            },
          },
          Argument: { leave: ({ name: e, value: t }) => e + ": " + t },
          FragmentSpread: {
            leave: ({ name: e, directives: t }) =>
              "..." + e + wrap(" ", join(t, " ")),
          },
          InlineFragment: {
            leave: ({ typeCondition: e, directives: t, selectionSet: r }) =>
              join(["...", wrap("on ", e), join(t, " "), r], " "),
          },
          FragmentDefinition: {
            leave: ({
              name: e,
              typeCondition: t,
              variableDefinitions: r,
              directives: i,
              selectionSet: n,
            }) =>
              `fragment ${e}${wrap("(", join(r, ", "), ")")} on ${t} ${wrap(
                "",
                join(i, " "),
                " "
              )}` + n,
          },
          IntValue: { leave: ({ value: e }) => e },
          FloatValue: { leave: ({ value: e }) => e },
          StringValue: {
            leave: ({ value: e, block: t }) =>
              t
                ? (function (e, t) {
                    let r = e.replace(/"""/g, '\\"""'),
                      i = r.split(/\r\n|[\n\r]/g),
                      n = 1 === i.length,
                      s =
                        i.length > 1 &&
                        i
                          .slice(1)
                          .every(
                            (e) =>
                              0 === e.length || isWhiteSpace(e.charCodeAt(0))
                          ),
                      o = r.endsWith('\\"""'),
                      a = e.endsWith('"') && !o,
                      l = e.endsWith("\\"),
                      u = a || l,
                      c =
                        !(null != t && t.minimize) &&
                        (!n || e.length > 70 || u || s || o),
                      p = "",
                      h = n && isWhiteSpace(e.charCodeAt(0));
                    return (
                      ((c && !h) || s) && (p += "\n"),
                      (p += r),
                      (c || u) && (p += "\n"),
                      '"""' + p + '"""'
                    );
                  })(e)
                : `"${e.replace(l, escapedReplacer)}"`,
          },
          BooleanValue: { leave: ({ value: e }) => (e ? "true" : "false") },
          NullValue: { leave: () => "null" },
          EnumValue: { leave: ({ value: e }) => e },
          ListValue: { leave: ({ values: e }) => "[" + join(e, ", ") + "]" },
          ObjectValue: { leave: ({ fields: e }) => "{" + join(e, ", ") + "}" },
          ObjectField: { leave: ({ name: e, value: t }) => e + ": " + t },
          Directive: {
            leave: ({ name: e, arguments: t }) =>
              "@" + e + wrap("(", join(t, ", "), ")"),
          },
          NamedType: { leave: ({ name: e }) => e },
          ListType: { leave: ({ type: e }) => "[" + e + "]" },
          NonNullType: { leave: ({ type: e }) => e + "!" },
          SchemaDefinition: {
            leave: ({ description: e, directives: t, operationTypes: r }) =>
              wrap("", e, "\n") + join(["schema", join(t, " "), block(r)], " "),
          },
          OperationTypeDefinition: {
            leave: ({ operation: e, type: t }) => e + ": " + t,
          },
          ScalarTypeDefinition: {
            leave: ({ description: e, name: t, directives: r }) =>
              wrap("", e, "\n") + join(["scalar", t, join(r, " ")], " "),
          },
          ObjectTypeDefinition: {
            leave: ({
              description: e,
              name: t,
              interfaces: r,
              directives: i,
              fields: n,
            }) =>
              wrap("", e, "\n") +
              join(
                [
                  "type",
                  t,
                  wrap("implements ", join(r, " & ")),
                  join(i, " "),
                  block(n),
                ],
                " "
              ),
          },
          FieldDefinition: {
            leave: ({
              description: e,
              name: t,
              arguments: r,
              type: i,
              directives: n,
            }) =>
              wrap("", e, "\n") +
              t +
              (hasMultilineItems(r)
                ? wrap("(\n", indent(join(r, "\n")), "\n)")
                : wrap("(", join(r, ", "), ")")) +
              ": " +
              i +
              wrap(" ", join(n, " ")),
          },
          InputValueDefinition: {
            leave: ({
              description: e,
              name: t,
              type: r,
              defaultValue: i,
              directives: n,
            }) =>
              wrap("", e, "\n") +
              join([t + ": " + r, wrap("= ", i), join(n, " ")], " "),
          },
          InterfaceTypeDefinition: {
            leave: ({
              description: e,
              name: t,
              interfaces: r,
              directives: i,
              fields: n,
            }) =>
              wrap("", e, "\n") +
              join(
                [
                  "interface",
                  t,
                  wrap("implements ", join(r, " & ")),
                  join(i, " "),
                  block(n),
                ],
                " "
              ),
          },
          UnionTypeDefinition: {
            leave: ({ description: e, name: t, directives: r, types: i }) =>
              wrap("", e, "\n") +
              join(["union", t, join(r, " "), wrap("= ", join(i, " | "))], " "),
          },
          EnumTypeDefinition: {
            leave: ({ description: e, name: t, directives: r, values: i }) =>
              wrap("", e, "\n") +
              join(["enum", t, join(r, " "), block(i)], " "),
          },
          EnumValueDefinition: {
            leave: ({ description: e, name: t, directives: r }) =>
              wrap("", e, "\n") + join([t, join(r, " ")], " "),
          },
          InputObjectTypeDefinition: {
            leave: ({ description: e, name: t, directives: r, fields: i }) =>
              wrap("", e, "\n") +
              join(["input", t, join(r, " "), block(i)], " "),
          },
          DirectiveDefinition: {
            leave: ({
              description: e,
              name: t,
              arguments: r,
              repeatable: i,
              locations: n,
            }) =>
              wrap("", e, "\n") +
              "directive @" +
              t +
              (hasMultilineItems(r)
                ? wrap("(\n", indent(join(r, "\n")), "\n)")
                : wrap("(", join(r, ", "), ")")) +
              (i ? " repeatable" : "") +
              " on " +
              join(n, " | "),
          },
          SchemaExtension: {
            leave: ({ directives: e, operationTypes: t }) =>
              join(["extend schema", join(e, " "), block(t)], " "),
          },
          ScalarTypeExtension: {
            leave: ({ name: e, directives: t }) =>
              join(["extend scalar", e, join(t, " ")], " "),
          },
          ObjectTypeExtension: {
            leave: ({ name: e, interfaces: t, directives: r, fields: i }) =>
              join(
                [
                  "extend type",
                  e,
                  wrap("implements ", join(t, " & ")),
                  join(r, " "),
                  block(i),
                ],
                " "
              ),
          },
          InterfaceTypeExtension: {
            leave: ({ name: e, interfaces: t, directives: r, fields: i }) =>
              join(
                [
                  "extend interface",
                  e,
                  wrap("implements ", join(t, " & ")),
                  join(r, " "),
                  block(i),
                ],
                " "
              ),
          },
          UnionTypeExtension: {
            leave: ({ name: e, directives: t, types: r }) =>
              join(
                ["extend union", e, join(t, " "), wrap("= ", join(r, " | "))],
                " "
              ),
          },
          EnumTypeExtension: {
            leave: ({ name: e, directives: t, values: r }) =>
              join(["extend enum", e, join(t, " "), block(r)], " "),
          },
          InputObjectTypeExtension: {
            leave: ({ name: e, directives: t, fields: r }) =>
              join(["extend input", e, join(t, " "), block(r)], " "),
          },
        };
      function join(e, t = "") {
        var r;
        return null !== (r = null == e ? void 0 : e.filter((e) => e).join(t)) &&
          void 0 !== r
          ? r
          : "";
      }
      function block(e) {
        return wrap("{\n", indent(join(e, "\n")), "\n}");
      }
      function wrap(e, t, r = "") {
        return null != t && "" !== t ? e + t + r : "";
      }
      function indent(e) {
        return wrap("  ", e.replace(/\n/g, "\n  "));
      }
      function hasMultilineItems(e) {
        var t;
        return (
          null !== (t = null == e ? void 0 : e.some((e) => e.includes("\n"))) &&
          void 0 !== t &&
          t
        );
      }
      let extractOperationName = (e) => {
          let t;
          let r = e.definitions.filter((e) => "OperationDefinition" === e.kind);
          return 1 === r.length && (t = r[0]?.name?.value), t;
        },
        resolveRequestDocument = (e) => {
          if ("string" == typeof e) {
            let t;
            try {
              let r = (function (e, t) {
                let r = new Parser(e, void 0);
                return r.parseDocument();
              })(e);
              t = extractOperationName(r);
            } catch (e) {}
            return { query: e, operationName: t };
          }
          let t = extractOperationName(e);
          return {
            query: (function (e, t, r = s) {
              let i, n, o;
              let a = new Map();
              for (let e of Object.values(T))
                a.set(
                  e,
                  (function (e, t) {
                    let r = e[t];
                    return "object" == typeof r
                      ? r
                      : "function" == typeof r
                      ? { enter: r, leave: void 0 }
                      : { enter: e.enter, leave: e.leave };
                  })(t, e)
                );
              let l = Array.isArray(e),
                u = [e],
                p = -1,
                h = [],
                d = e,
                f = [],
                y = [];
              do {
                var E, m, v;
                let e;
                p++;
                let s = p === u.length,
                  T = s && 0 !== h.length;
                if (s) {
                  if (
                    ((n = 0 === y.length ? void 0 : f[f.length - 1]),
                    (d = o),
                    (o = y.pop()),
                    T)
                  ) {
                    if (l) {
                      d = d.slice();
                      let e = 0;
                      for (let [t, r] of h) {
                        let i = t - e;
                        null === r ? (d.splice(i, 1), e++) : (d[i] = r);
                      }
                    } else
                      for (let [e, t] of ((d = Object.defineProperties(
                        {},
                        Object.getOwnPropertyDescriptors(d)
                      )),
                      h))
                        d[e] = t;
                  }
                  (p = i.index),
                    (u = i.keys),
                    (h = i.edits),
                    (l = i.inArray),
                    (i = i.prev);
                } else if (o) {
                  if (null == (d = o[(n = l ? p : u[p])])) continue;
                  f.push(n);
                }
                if (!Array.isArray(d)) {
                  isNode(d) ||
                    devAssert(!1, `Invalid AST Node: ${formatValue(d, [])}.`);
                  let r = s
                    ? null === (E = a.get(d.kind)) || void 0 === E
                      ? void 0
                      : E.leave
                    : null === (m = a.get(d.kind)) || void 0 === m
                    ? void 0
                    : m.enter;
                  if ((e = null == r ? void 0 : r.call(t, d, n, o, f, y)) === c)
                    break;
                  if (!1 === e) {
                    if (!s) {
                      f.pop();
                      continue;
                    }
                  } else if (void 0 !== e && (h.push([n, e]), !s)) {
                    if (isNode(e)) d = e;
                    else {
                      f.pop();
                      continue;
                    }
                  }
                }
                void 0 === e && T && h.push([n, d]),
                  s
                    ? f.pop()
                    : ((i = {
                        inArray: l,
                        index: p,
                        keys: u,
                        edits: h,
                        prev: i,
                      }),
                      (u = (l = Array.isArray(d))
                        ? d
                        : null !== (v = r[d.kind]) && void 0 !== v
                        ? v
                        : []),
                      (p = -1),
                      (h = []),
                      o && y.push(o),
                      (o = d));
              } while (void 0 !== i);
              return 0 !== h.length ? h[h.length - 1][1] : e;
            })(e, p),
            operationName: t,
          };
        };
      let ClientError = class ClientError extends Error {
        constructor(e, t) {
          let r = `${ClientError.extractMessage(e)}: ${JSON.stringify({
            response: e,
            request: t,
          })}`;
          super(r),
            Object.setPrototypeOf(this, ClientError.prototype),
            (this.response = e),
            (this.request = t),
            "function" == typeof Error.captureStackTrace &&
              Error.captureStackTrace(this, ClientError);
        }
        static extractMessage(e) {
          return e.errors?.[0]?.message ?? `GraphQL Error (Code: ${e.status})`;
        }
      };
      var h,
        d,
        f,
        y,
        E,
        m,
        T,
        v,
        N = r(54098),
        A = r.t(N, 2);
      let GraphQLWebSocketMessage = class GraphQLWebSocketMessage {
        get type() {
          return this._type;
        }
        get id() {
          return this._id;
        }
        get payload() {
          return this._payload;
        }
        constructor(e, t, r) {
          (this._type = e), (this._payload = t), (this._id = r);
        }
        get text() {
          let e = { type: this.type };
          return (
            null != this.id && void 0 != this.id && (e.id = this.id),
            null != this.payload &&
              void 0 != this.payload &&
              (e.payload = this.payload),
            JSON.stringify(e)
          );
        }
        static parse(e, t) {
          let { type: r, payload: i, id: n } = JSON.parse(e);
          return new GraphQLWebSocketMessage(r, t(i), n);
        }
      };
      let resolveHeaders = (e) => {
          let t = {};
          return (
            e &&
              (("undefined" != typeof Headers && e instanceof Headers) ||
              (A && N.Headers && e instanceof N.Headers)
                ? (t = HeadersInstanceToPlainObject(e))
                : Array.isArray(e)
                ? e.forEach(([e, r]) => {
                    e && void 0 !== r && (t[e] = r);
                  })
                : (t = e)),
            t
          );
        },
        cleanQuery = (e) => e.replace(/([\s,]|#[^\n\r]+)+/g, " ").trim(),
        buildRequestConfig = (e) => {
          if (!Array.isArray(e.query)) {
            let t = [`query=${encodeURIComponent(cleanQuery(e.query))}`];
            return (
              e.variables &&
                t.push(
                  `variables=${encodeURIComponent(
                    e.jsonSerializer.stringify(e.variables)
                  )}`
                ),
              e.operationName &&
                t.push(`operationName=${encodeURIComponent(e.operationName)}`),
              t.join("&")
            );
          }
          if (void 0 !== e.variables && !Array.isArray(e.variables))
            throw Error(
              "Cannot create query with given variable type, array expected"
            );
          let t = e.query.reduce(
            (t, r, i) => (
              t.push({
                query: cleanQuery(r),
                variables: e.variables
                  ? e.jsonSerializer.stringify(e.variables[i])
                  : void 0,
              }),
              t
            ),
            []
          );
          return `query=${encodeURIComponent(e.jsonSerializer.stringify(t))}`;
        },
        createHttpMethodFetcher = (e) => async (t) => {
          let r;
          let {
              url: n,
              query: s,
              variables: o,
              operationName: a,
              fetch: l,
              fetchOptions: u,
              middleware: c,
            } = t,
            p = { ...t.headers },
            h = "";
          "POST" === e
            ? "string" ==
                typeof (r = createRequestBody(s, o, a, u.jsonSerializer)) &&
              (p["Content-Type"] = "application/json")
            : (h = buildRequestConfig({
                query: s,
                variables: o,
                operationName: a,
                jsonSerializer: u.jsonSerializer ?? i,
              }));
          let d = { method: e, headers: p, body: r, ...u },
            f = n,
            y = d;
          if (c) {
            let e = await Promise.resolve(
                c({ ...d, url: n, operationName: a, variables: o })
              ),
              { url: t, ...r } = e;
            (f = t), (y = r);
          }
          return h && (f = `${f}?${h}`), await l(f, y);
        };
      let GraphQLClient = class GraphQLClient {
        constructor(e, t = {}) {
          (this.url = e),
            (this.requestConfig = t),
            (this.rawRequest = async (...e) => {
              let [t, r, i] = e,
                n = parseRawRequestArgs(t, r, i),
                {
                  headers: s,
                  fetch: o = N,
                  method: a = "POST",
                  requestMiddleware: l,
                  responseMiddleware: u,
                  ...c
                } = this.requestConfig,
                { url: p } = this;
              void 0 !== n.signal && (c.signal = n.signal);
              let { operationName: h } = resolveRequestDocument(n.query);
              return makeRequest({
                url: p,
                query: n.query,
                variables: n.variables,
                headers: {
                  ...resolveHeaders(callOrIdentity(s)),
                  ...resolveHeaders(n.requestHeaders),
                },
                operationName: h,
                fetch: o,
                method: a,
                fetchOptions: c,
                middleware: l,
              })
                .then((e) => (u && u(e), e))
                .catch((e) => {
                  throw (u && u(e), e);
                });
            });
        }
        async request(e, ...t) {
          let [r, i] = t,
            n = parseRequestArgs(e, r, i),
            {
              headers: s,
              fetch: o = N,
              method: a = "POST",
              requestMiddleware: l,
              responseMiddleware: u,
              ...c
            } = this.requestConfig,
            { url: p } = this;
          void 0 !== n.signal && (c.signal = n.signal);
          let { query: h, operationName: d } = resolveRequestDocument(
            n.document
          );
          return makeRequest({
            url: p,
            query: h,
            variables: n.variables,
            headers: {
              ...resolveHeaders(callOrIdentity(s)),
              ...resolveHeaders(n.requestHeaders),
            },
            operationName: d,
            fetch: o,
            method: a,
            fetchOptions: c,
            middleware: l,
          })
            .then((e) => (u && u(e), e.data))
            .catch((e) => {
              throw (u && u(e), e);
            });
        }
        batchRequests(e, t) {
          let r = parseBatchRequestArgs(e, t),
            { headers: i, ...n } = this.requestConfig;
          void 0 !== r.signal && (n.signal = r.signal);
          let s = r.documents.map(
              ({ document: e }) => resolveRequestDocument(e).query
            ),
            o = r.documents.map(({ variables: e }) => e);
          return makeRequest({
            url: this.url,
            query: s,
            variables: o,
            headers: {
              ...resolveHeaders(callOrIdentity(i)),
              ...resolveHeaders(r.requestHeaders),
            },
            operationName: void 0,
            fetch: this.requestConfig.fetch ?? N,
            method: this.requestConfig.method || "POST",
            fetchOptions: n,
            middleware: this.requestConfig.requestMiddleware,
          })
            .then(
              (e) => (
                this.requestConfig.responseMiddleware &&
                  this.requestConfig.responseMiddleware(e),
                e.data
              )
            )
            .catch((e) => {
              throw (
                (this.requestConfig.responseMiddleware &&
                  this.requestConfig.responseMiddleware(e),
                e)
              );
            });
        }
        setHeaders(e) {
          return (this.requestConfig.headers = e), this;
        }
        setHeader(e, t) {
          let { headers: r } = this.requestConfig;
          return (
            r ? (r[e] = t) : (this.requestConfig.headers = { [e]: t }), this
          );
        }
        setEndpoint(e) {
          return (this.url = e), this;
        }
      };
      let makeRequest = async (e) => {
          let { query: t, variables: r, fetchOptions: n } = e,
            s = createHttpMethodFetcher(uppercase(e.method ?? "post")),
            o = Array.isArray(e.query),
            a = await s(e),
            l = await getResult(a, n.jsonSerializer ?? i),
            u = Array.isArray(l) ? !l.some(({ data: e }) => !e) : !!l.data,
            c =
              Array.isArray(l) ||
              !l.errors ||
              (Array.isArray(l.errors) && !l.errors.length) ||
              "all" === n.errorPolicy ||
              "ignore" === n.errorPolicy;
          if (a.ok && c && u) {
            let { errors: e, ...t } = (Array.isArray(l), l),
              r = "ignore" === n.errorPolicy ? t : l;
            return {
              ...(o ? { data: r } : r),
              headers: a.headers,
              status: a.status,
            };
          }
          {
            let e = "string" == typeof l ? { error: l } : l;
            throw new ClientError(
              { ...e, status: a.status, headers: a.headers },
              { query: t, variables: r }
            );
          }
        },
        createRequestBody = (e, t, r, n) => {
          let s = n ?? i;
          if (!Array.isArray(e))
            return s.stringify({ query: e, variables: t, operationName: r });
          if (void 0 !== t && !Array.isArray(t))
            throw Error(
              "Cannot create request body with given variable type, array expected"
            );
          let o = e.reduce(
            (e, r, i) => (
              e.push({ query: r, variables: t ? t[i] : void 0 }), e
            ),
            []
          );
          return s.stringify(o);
        },
        getResult = async (e, t) => {
          let r;
          return (e.headers.forEach((e, t) => {
            "content-type" === t.toLowerCase() && (r = e);
          }),
          r &&
            (r.toLowerCase().startsWith("application/json") ||
              r.toLowerCase().startsWith("application/graphql+json") ||
              r.toLowerCase().startsWith("application/graphql-response+json")))
            ? t.parse(await e.text())
            : e.text();
        },
        callOrIdentity = (e) => ("function" == typeof e ? e() : e);
    },
  },
]);
