@noxickon/onyx 0.0.1 → 0.0.3

package/dist/chunks/index-DnVdNmco.js

@@ -0,0 +1,2129 @@
+import { _ as U } from "./index-Dgwp7JKP.js";
+function L(e, t) {
+  if (!!!e)
+    throw new Error(t);
+}
+function ee(e) {
+  return typeof e == "object" && e !== null;
+}
+function te(e, t) {
+  if (!!!e)
+    throw new Error(
+      "Unexpected invariant triggered."
+    );
+}
+const ne = /\r\n|[\n\r]/g;
+function F(e, t) {
+  let n = 0, s = 1;
+  for (const i of e.body.matchAll(ne)) {
+    if (typeof i.index == "number" || te(!1), i.index >= t)
+      break;
+    n = i.index + i[0].length, s += 1;
+  }
+  return {
+    line: s,
+    column: t + 1 - n
+  };
+}
+function ie(e) {
+  return G(
+    e.source,
+    F(e.source, e.start)
+  );
+}
+function G(e, t) {
+  const n = e.locationOffset.column - 1, s = "".padStart(n) + e.body, i = t.line - 1, r = e.locationOffset.line - 1, a = t.line + r, u = t.line === 1 ? n : 0, l = t.column + u, E = `${e.name}:${a}:${l}
+`, p = s.split(/\r\n|[\n\r]/g), N = p[i];
+  if (N.length > 120) {
+    const m = Math.floor(l / 80), b = l % 80, f = [];
+    for (let I = 0; I < N.length; I += 80)
+      f.push(N.slice(I, I + 80));
+    return E + V([
+      [`${a} |`, f[0]],
+      ...f.slice(1, m + 1).map((I) => ["|", I]),
+      ["|", "^".padStart(b)],
+      ["|", f[m + 1]]
+    ]);
+  }
+  return E + V([
+    // Lines specified like this: ["prefix", "string"],
+    [`${a - 1} |`, p[i - 1]],
+    [`${a} |`, N],
+    ["|", "^".padStart(l)],
+    [`${a + 1} |`, p[i + 1]]
+  ]);
+}
+function V(e) {
+  const t = e.filter(([s, i]) => i !== void 0), n = Math.max(...t.map(([s]) => s.length));
+  return t.map(([s, i]) => s.padStart(n) + (i ? " " + i : "")).join(`
+`);
+}
+function se(e) {
+  const t = e[0];
+  return t == null || "kind" in t || "length" in t ? {
+    nodes: t,
+    source: e[1],
+    positions: e[2],
+    path: e[3],
+    originalError: e[4],
+    extensions: e[5]
+  } : t;
+}
+class M extends Error {
+  /**
+   * An array of `{ line, column }` locations within the source GraphQL document
+   * which correspond to this error.
+   *
+   * Errors during validation often contain multiple locations, for example to
+   * point out two things with the same name. Errors during execution include a
+   * single location, the field which produced the error.
+   *
+   * Enumerable, and appears in the result of JSON.stringify().
+   */
+  /**
+   * An array describing the JSON-path into the execution response which
+   * corresponds to this error. Only included for errors during execution.
+   *
+   * Enumerable, and appears in the result of JSON.stringify().
+   */
+  /**
+   * An array of GraphQL AST Nodes corresponding to this error.
+   */
+  /**
+   * The source GraphQL document for the first location of this error.
+   *
+   * Note that if this Error represents more than one node, the source may not
+   * represent nodes after the first node.
+   */
+  /**
+   * An array of character offsets within the source GraphQL document
+   * which correspond to this error.
+   */
+  /**
+   * The original error thrown from a field resolver during execution.
+   */
+  /**
+   * Extension fields to add to the formatted error.
+   */
+  /**
+   * @deprecated Please use the `GraphQLErrorOptions` constructor overload instead.
+   */
+  constructor(t, ...n) {
+    var s, i, r;
+    const { nodes: a, source: u, positions: l, path: E, originalError: p, extensions: N } = se(n);
+    super(t), this.name = "GraphQLError", this.path = E ?? void 0, this.originalError = p ?? void 0, this.nodes = B(
+      Array.isArray(a) ? a : a ? [a] : void 0
+    );
+    const m = B(
+      (s = this.nodes) === null || s === void 0 ? void 0 : s.map((f) => f.loc).filter((f) => f != null)
+    );
+    this.source = u ?? (m == null || (i = m[0]) === null || i === void 0 ? void 0 : i.source), this.positions = l ?? (m == null ? void 0 : m.map((f) => f.start)), this.locations = l && u ? l.map((f) => F(u, f)) : m == null ? void 0 : m.map((f) => F(f.source, f.start));
+    const b = ee(
+      p == null ? void 0 : p.extensions
+    ) ? p == null ? void 0 : p.extensions : void 0;
+    this.extensions = (r = N ?? b) !== null && r !== void 0 ? r : /* @__PURE__ */ 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
+      }
+    }), p != null && p.stack ? Object.defineProperty(this, "stack", {
+      value: p.stack,
+      writable: !0,
+      configurable: !0
+    }) : Error.captureStackTrace ? Error.captureStackTrace(this, M) : Object.defineProperty(this, "stack", {
+      value: Error().stack,
+      writable: !0,
+      configurable: !0
+    });
+  }
+  get [Symbol.toStringTag]() {
+    return "GraphQLError";
+  }
+  toString() {
+    let t = this.message;
+    if (this.nodes)
+      for (const n of this.nodes)
+        n.loc && (t += `
+
+` + ie(n.loc));
+    else if (this.source && this.locations)
+      for (const n of this.locations)
+        t += `
+
+` + G(this.source, n);
+    return t;
+  }
+  toJSON() {
+    const t = {
+      message: this.message
+    };
+    return this.locations != null && (t.locations = this.locations), this.path != null && (t.path = this.path), this.extensions != null && Object.keys(this.extensions).length > 0 && (t.extensions = this.extensions), t;
+  }
+}
+function B(e) {
+  return e === void 0 || e.length === 0 ? void 0 : e;
+}
+function d(e, t, n) {
+  return new M(`Syntax Error: ${n}`, {
+    source: e,
+    positions: [t]
+  });
+}
+class re {
+  /**
+   * The character offset at which this Node begins.
+   */
+  /**
+   * The character offset at which this Node ends.
+   */
+  /**
+   * The Token at which this Node begins.
+   */
+  /**
+   * The Token at which this Node ends.
+   */
+  /**
+   * The Source document the AST represents.
+   */
+  constructor(t, n, s) {
+    this.start = t.start, this.end = n.end, this.startToken = t, this.endToken = n, this.source = s;
+  }
+  get [Symbol.toStringTag]() {
+    return "Location";
+  }
+  toJSON() {
+    return {
+      start: this.start,
+      end: this.end
+    };
+  }
+}
+class Y {
+  /**
+   * The kind of Token.
+   */
+  /**
+   * The character offset at which this Node begins.
+   */
+  /**
+   * The character offset at which this Node ends.
+   */
+  /**
+   * The 1-indexed line number on which this Token appears.
+   */
+  /**
+   * The 1-indexed column number at which this Token begins.
+   */
+  /**
+   * For non-punctuation tokens, represents the interpreted value of the token.
+   *
+   * Note: is undefined for punctuation tokens, but typed as string for
+   * convenience in the parser.
+   */
+  /**
+   * Tokens exist as nodes in a double-linked-list amongst all tokens
+   * including ignored tokens. <SOF> is always the first node and <EOF>
+   * the last.
+   */
+  constructor(t, n, s, i, r, a) {
+    this.kind = t, this.start = n, this.end = s, this.line = i, this.column = r, this.value = a, 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
+    };
+  }
+}
+const oe = {
+  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",
+    // Note: fragment variable definitions are deprecated and will removed in v17.0.0
+    "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"]
+};
+new Set(Object.keys(oe));
+var x;
+(function(e) {
+  e.QUERY = "query", e.MUTATION = "mutation", e.SUBSCRIPTION = "subscription";
+})(x || (x = {}));
+var w;
+(function(e) {
+  e.QUERY = "QUERY", e.MUTATION = "MUTATION", e.SUBSCRIPTION = "SUBSCRIPTION", e.FIELD = "FIELD", e.FRAGMENT_DEFINITION = "FRAGMENT_DEFINITION", e.FRAGMENT_SPREAD = "FRAGMENT_SPREAD", e.INLINE_FRAGMENT = "INLINE_FRAGMENT", e.VARIABLE_DEFINITION = "VARIABLE_DEFINITION", e.SCHEMA = "SCHEMA", e.SCALAR = "SCALAR", e.OBJECT = "OBJECT", e.FIELD_DEFINITION = "FIELD_DEFINITION", e.ARGUMENT_DEFINITION = "ARGUMENT_DEFINITION", e.INTERFACE = "INTERFACE", e.UNION = "UNION", e.ENUM = "ENUM", e.ENUM_VALUE = "ENUM_VALUE", e.INPUT_OBJECT = "INPUT_OBJECT", e.INPUT_FIELD_DEFINITION = "INPUT_FIELD_DEFINITION";
+})(w || (w = {}));
+var c;
+(function(e) {
+  e.NAME = "Name", e.DOCUMENT = "Document", e.OPERATION_DEFINITION = "OperationDefinition", e.VARIABLE_DEFINITION = "VariableDefinition", e.SELECTION_SET = "SelectionSet", e.FIELD = "Field", e.ARGUMENT = "Argument", e.FRAGMENT_SPREAD = "FragmentSpread", e.INLINE_FRAGMENT = "InlineFragment", e.FRAGMENT_DEFINITION = "FragmentDefinition", e.VARIABLE = "Variable", e.INT = "IntValue", e.FLOAT = "FloatValue", e.STRING = "StringValue", e.BOOLEAN = "BooleanValue", e.NULL = "NullValue", e.ENUM = "EnumValue", e.LIST = "ListValue", e.OBJECT = "ObjectValue", e.OBJECT_FIELD = "ObjectField", e.DIRECTIVE = "Directive", e.NAMED_TYPE = "NamedType", e.LIST_TYPE = "ListType", e.NON_NULL_TYPE = "NonNullType", e.SCHEMA_DEFINITION = "SchemaDefinition", e.OPERATION_TYPE_DEFINITION = "OperationTypeDefinition", e.SCALAR_TYPE_DEFINITION = "ScalarTypeDefinition", e.OBJECT_TYPE_DEFINITION = "ObjectTypeDefinition", e.FIELD_DEFINITION = "FieldDefinition", e.INPUT_VALUE_DEFINITION = "InputValueDefinition", e.INTERFACE_TYPE_DEFINITION = "InterfaceTypeDefinition", e.UNION_TYPE_DEFINITION = "UnionTypeDefinition", e.ENUM_TYPE_DEFINITION = "EnumTypeDefinition", e.ENUM_VALUE_DEFINITION = "EnumValueDefinition", e.INPUT_OBJECT_TYPE_DEFINITION = "InputObjectTypeDefinition", e.DIRECTIVE_DEFINITION = "DirectiveDefinition", e.SCHEMA_EXTENSION = "SchemaExtension", e.SCALAR_TYPE_EXTENSION = "ScalarTypeExtension", e.OBJECT_TYPE_EXTENSION = "ObjectTypeExtension", e.INTERFACE_TYPE_EXTENSION = "InterfaceTypeExtension", e.UNION_TYPE_EXTENSION = "UnionTypeExtension", e.ENUM_TYPE_EXTENSION = "EnumTypeExtension", e.INPUT_OBJECT_TYPE_EXTENSION = "InputObjectTypeExtension";
+})(c || (c = {}));
+function ae(e) {
+  return e === 9 || e === 32;
+}
+function y(e) {
+  return e >= 48 && e <= 57;
+}
+function $(e) {
+  return e >= 97 && e <= 122 || // A-Z
+  e >= 65 && e <= 90;
+}
+function J(e) {
+  return $(e) || e === 95;
+}
+function ce(e) {
+  return $(e) || y(e) || e === 95;
+}
+function ue(e) {
+  var t;
+  let n = Number.MAX_SAFE_INTEGER, s = null, i = -1;
+  for (let a = 0; a < e.length; ++a) {
+    var r;
+    const u = e[a], l = le(u);
+    l !== u.length && (s = (r = s) !== null && r !== void 0 ? r : a, i = a, a !== 0 && l < n && (n = l));
+  }
+  return e.map((a, u) => u === 0 ? a : a.slice(n)).slice(
+    (t = s) !== null && t !== void 0 ? t : 0,
+    i + 1
+  );
+}
+function le(e) {
+  let t = 0;
+  for (; t < e.length && ae(e.charCodeAt(t)); )
+    ++t;
+  return t;
+}
+var o;
+(function(e) {
+  e.SOF = "<SOF>", e.EOF = "<EOF>", e.BANG = "!", e.DOLLAR = "$", e.AMP = "&", e.PAREN_L = "(", e.PAREN_R = ")", e.SPREAD = "...", e.COLON = ":", e.EQUALS = "=", e.AT = "@", e.BRACKET_L = "[", e.BRACKET_R = "]", e.BRACE_L = "{", e.PIPE = "|", e.BRACE_R = "}", e.NAME = "Name", e.INT = "Int", e.FLOAT = "Float", e.STRING = "String", e.BLOCK_STRING = "BlockString", e.COMMENT = "Comment";
+})(o || (o = {}));
+class he {
+  /**
+   * The previously focused non-ignored token.
+   */
+  /**
+   * The currently focused non-ignored token.
+   */
+  /**
+   * The (1-indexed) line containing the current token.
+   */
+  /**
+   * The character offset at which the current line begins.
+   */
+  constructor(t) {
+    const n = new Y(o.SOF, 0, 0, 0, 0);
+    this.source = t, this.lastToken = n, this.token = n, this.line = 1, this.lineStart = 0;
+  }
+  get [Symbol.toStringTag]() {
+    return "Lexer";
+  }
+  /**
+   * Advances the token stream to the next non-ignored token.
+   */
+  advance() {
+    return this.lastToken = this.token, this.token = this.lookahead();
+  }
+  /**
+   * Looks ahead and returns the next non-ignored token, but does not change
+   * the state of Lexer.
+   */
+  lookahead() {
+    let t = this.token;
+    if (t.kind !== o.EOF)
+      do
+        if (t.next)
+          t = t.next;
+        else {
+          const n = de(this, t.end);
+          t.next = n, n.prev = t, t = n;
+        }
+      while (t.kind === o.COMMENT);
+    return t;
+  }
+}
+function pe(e) {
+  return e === o.BANG || e === o.DOLLAR || e === o.AMP || e === o.PAREN_L || e === o.PAREN_R || e === o.SPREAD || e === o.COLON || e === o.EQUALS || e === o.AT || e === o.BRACKET_L || e === o.BRACKET_R || e === o.BRACE_L || e === o.PIPE || e === o.BRACE_R;
+}
+function O(e) {
+  return e >= 0 && e <= 55295 || e >= 57344 && e <= 1114111;
+}
+function C(e, t) {
+  return X(e.charCodeAt(t)) && Q(e.charCodeAt(t + 1));
+}
+function X(e) {
+  return e >= 55296 && e <= 56319;
+}
+function Q(e) {
+  return e >= 56320 && e <= 57343;
+}
+function T(e, t) {
+  const n = e.source.body.codePointAt(t);
+  if (n === void 0)
+    return o.EOF;
+  if (n >= 32 && n <= 126) {
+    const s = String.fromCodePoint(n);
+    return s === '"' ? `'"'` : `"${s}"`;
+  }
+  return "U+" + n.toString(16).toUpperCase().padStart(4, "0");
+}
+function h(e, t, n, s, i) {
+  const r = e.line, a = 1 + n - e.lineStart;
+  return new Y(t, n, s, r, a, i);
+}
+function de(e, t) {
+  const n = e.source.body, s = n.length;
+  let i = t;
+  for (; i < s; ) {
+    const r = n.charCodeAt(i);
+    switch (r) {
+      // Ignored ::
+      //   - UnicodeBOM
+      //   - WhiteSpace
+      //   - LineTerminator
+      //   - Comment
+      //   - Comma
+      //
+      // UnicodeBOM :: "Byte Order Mark (U+FEFF)"
+      //
+      // WhiteSpace ::
+      //   - "Horizontal Tab (U+0009)"
+      //   - "Space (U+0020)"
+      //
+      // Comma :: ,
+      case 65279:
+      // <BOM>
+      case 9:
+      // \t
+      case 32:
+      // <space>
+      case 44:
+        ++i;
+        continue;
+      // LineTerminator ::
+      //   - "New Line (U+000A)"
+      //   - "Carriage Return (U+000D)" [lookahead != "New Line (U+000A)"]
+      //   - "Carriage Return (U+000D)" "New Line (U+000A)"
+      case 10:
+        ++i, ++e.line, e.lineStart = i;
+        continue;
+      case 13:
+        n.charCodeAt(i + 1) === 10 ? i += 2 : ++i, ++e.line, e.lineStart = i;
+        continue;
+      // Comment
+      case 35:
+        return fe(e, i);
+      // Token ::
+      //   - Punctuator
+      //   - Name
+      //   - IntValue
+      //   - FloatValue
+      //   - StringValue
+      //
+      // Punctuator :: one of ! $ & ( ) ... : = @ [ ] { | }
+      case 33:
+        return h(e, o.BANG, i, i + 1);
+      case 36:
+        return h(e, o.DOLLAR, i, i + 1);
+      case 38:
+        return h(e, o.AMP, i, i + 1);
+      case 40:
+        return h(e, o.PAREN_L, i, i + 1);
+      case 41:
+        return h(e, o.PAREN_R, i, i + 1);
+      case 46:
+        if (n.charCodeAt(i + 1) === 46 && n.charCodeAt(i + 2) === 46)
+          return h(e, o.SPREAD, i, i + 3);
+        break;
+      case 58:
+        return h(e, o.COLON, i, i + 1);
+      case 61:
+        return h(e, o.EQUALS, i, i + 1);
+      case 64:
+        return h(e, o.AT, i, i + 1);
+      case 91:
+        return h(e, o.BRACKET_L, i, i + 1);
+      case 93:
+        return h(e, o.BRACKET_R, i, i + 1);
+      case 123:
+        return h(e, o.BRACE_L, i, i + 1);
+      case 124:
+        return h(e, o.PIPE, i, i + 1);
+      case 125:
+        return h(e, o.BRACE_R, i, i + 1);
+      // StringValue
+      case 34:
+        return n.charCodeAt(i + 1) === 34 && n.charCodeAt(i + 2) === 34 ? xe(e, i) : me(e, i);
+    }
+    if (y(r) || r === 45)
+      return Ee(e, i, r);
+    if (J(r))
+      return Oe(e, i);
+    throw d(
+      e.source,
+      i,
+      r === 39 ? `Unexpected single quote character ('), did you mean to use a double quote (")?` : O(r) || C(n, i) ? `Unexpected character: ${T(e, i)}.` : `Invalid character: ${T(e, i)}.`
+    );
+  }
+  return h(e, o.EOF, s, s);
+}
+function fe(e, t) {
+  const n = e.source.body, s = n.length;
+  let i = t + 1;
+  for (; i < s; ) {
+    const r = n.charCodeAt(i);
+    if (r === 10 || r === 13)
+      break;
+    if (O(r))
+      ++i;
+    else if (C(n, i))
+      i += 2;
+    else
+      break;
+  }
+  return h(
+    e,
+    o.COMMENT,
+    t,
+    i,
+    n.slice(t + 1, i)
+  );
+}
+function Ee(e, t, n) {
+  const s = e.source.body;
+  let i = t, r = n, a = !1;
+  if (r === 45 && (r = s.charCodeAt(++i)), r === 48) {
+    if (r = s.charCodeAt(++i), y(r))
+      throw d(
+        e.source,
+        i,
+        `Invalid number, unexpected digit after 0: ${T(
+          e,
+          i
+        )}.`
+      );
+  } else
+    i = R(e, i, r), r = s.charCodeAt(i);
+  if (r === 46 && (a = !0, r = s.charCodeAt(++i), i = R(e, i, r), r = s.charCodeAt(i)), (r === 69 || r === 101) && (a = !0, r = s.charCodeAt(++i), (r === 43 || r === 45) && (r = s.charCodeAt(++i)), i = R(e, i, r), r = s.charCodeAt(i)), r === 46 || J(r))
+    throw d(
+      e.source,
+      i,
+      `Invalid number, expected digit but got: ${T(
+        e,
+        i
+      )}.`
+    );
+  return h(
+    e,
+    a ? o.FLOAT : o.INT,
+    t,
+    i,
+    s.slice(t, i)
+  );
+}
+function R(e, t, n) {
+  if (!y(n))
+    throw d(
+      e.source,
+      t,
+      `Invalid number, expected digit but got: ${T(
+        e,
+        t
+      )}.`
+    );
+  const s = e.source.body;
+  let i = t + 1;
+  for (; y(s.charCodeAt(i)); )
+    ++i;
+  return i;
+}
+function me(e, t) {
+  const n = e.source.body, s = n.length;
+  let i = t + 1, r = i, a = "";
+  for (; i < s; ) {
+    const u = n.charCodeAt(i);
+    if (u === 34)
+      return a += n.slice(r, i), h(e, o.STRING, t, i + 1, a);
+    if (u === 92) {
+      a += n.slice(r, i);
+      const l = n.charCodeAt(i + 1) === 117 ? n.charCodeAt(i + 2) === 123 ? Ne(e, i) : Te(e, i) : Ie(e, i);
+      a += l.value, i += l.size, r = i;
+      continue;
+    }
+    if (u === 10 || u === 13)
+      break;
+    if (O(u))
+      ++i;
+    else if (C(n, i))
+      i += 2;
+    else
+      throw d(
+        e.source,
+        i,
+        `Invalid character within String: ${T(
+          e,
+          i
+        )}.`
+      );
+  }
+  throw d(e.source, i, "Unterminated string.");
+}
+function Ne(e, t) {
+  const n = e.source.body;
+  let s = 0, i = 3;
+  for (; i < 12; ) {
+    const r = n.charCodeAt(t + i++);
+    if (r === 125) {
+      if (i < 5 || !O(s))
+        break;
+      return {
+        value: String.fromCodePoint(s),
+        size: i
+      };
+    }
+    if (s = s << 4 | A(r), s < 0)
+      break;
+  }
+  throw d(
+    e.source,
+    t,
+    `Invalid Unicode escape sequence: "${n.slice(
+      t,
+      t + i
+    )}".`
+  );
+}
+function Te(e, t) {
+  const n = e.source.body, s = j(n, t + 2);
+  if (O(s))
+    return {
+      value: String.fromCodePoint(s),
+      size: 6
+    };
+  if (X(s) && n.charCodeAt(t + 6) === 92 && n.charCodeAt(t + 7) === 117) {
+    const i = j(n, t + 8);
+    if (Q(i))
+      return {
+        value: String.fromCodePoint(s, i),
+        size: 12
+      };
+  }
+  throw d(
+    e.source,
+    t,
+    `Invalid Unicode escape sequence: "${n.slice(t, t + 6)}".`
+  );
+}
+function j(e, t) {
+  return A(e.charCodeAt(t)) << 12 | A(e.charCodeAt(t + 1)) << 8 | A(e.charCodeAt(t + 2)) << 4 | A(e.charCodeAt(t + 3));
+}
+function A(e) {
+  return e >= 48 && e <= 57 ? e - 48 : e >= 65 && e <= 70 ? e - 55 : e >= 97 && e <= 102 ? e - 87 : -1;
+}
+function Ie(e, t) {
+  const n = e.source.body;
+  switch (n.charCodeAt(t + 1)) {
+    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: `
+`,
+        size: 2
+      };
+    case 114:
+      return {
+        value: "\r",
+        size: 2
+      };
+    case 116:
+      return {
+        value: "	",
+        size: 2
+      };
+  }
+  throw d(
+    e.source,
+    t,
+    `Invalid character escape sequence: "${n.slice(
+      t,
+      t + 2
+    )}".`
+  );
+}
+function xe(e, t) {
+  const n = e.source.body, s = n.length;
+  let i = e.lineStart, r = t + 3, a = r, u = "";
+  const l = [];
+  for (; r < s; ) {
+    const E = n.charCodeAt(r);
+    if (E === 34 && n.charCodeAt(r + 1) === 34 && n.charCodeAt(r + 2) === 34) {
+      u += n.slice(a, r), l.push(u);
+      const p = h(
+        e,
+        o.BLOCK_STRING,
+        t,
+        r + 3,
+        // Return a string of the lines joined with U+000A.
+        ue(l).join(`
+`)
+      );
+      return e.line += l.length - 1, e.lineStart = i, p;
+    }
+    if (E === 92 && n.charCodeAt(r + 1) === 34 && n.charCodeAt(r + 2) === 34 && n.charCodeAt(r + 3) === 34) {
+      u += n.slice(a, r), a = r + 1, r += 4;
+      continue;
+    }
+    if (E === 10 || E === 13) {
+      u += n.slice(a, r), l.push(u), E === 13 && n.charCodeAt(r + 1) === 10 ? r += 2 : ++r, u = "", a = r, i = r;
+      continue;
+    }
+    if (O(E))
+      ++r;
+    else if (C(n, r))
+      r += 2;
+    else
+      throw d(
+        e.source,
+        r,
+        `Invalid character within String: ${T(
+          e,
+          r
+        )}.`
+      );
+  }
+  throw d(e.source, r, "Unterminated string.");
+}
+function Oe(e, t) {
+  const n = e.source.body, s = n.length;
+  let i = t + 1;
+  for (; i < s; ) {
+    const r = n.charCodeAt(i);
+    if (ce(r))
+      ++i;
+    else
+      break;
+  }
+  return h(
+    e,
+    o.NAME,
+    t,
+    i,
+    n.slice(t, i)
+  );
+}
+const _e = 10, q = 2;
+function z(e) {
+  return S(e, []);
+}
+function S(e, t) {
+  switch (typeof e) {
+    case "string":
+      return JSON.stringify(e);
+    case "function":
+      return e.name ? `[function ${e.name}]` : "[function]";
+    case "object":
+      return Ae(e, t);
+    default:
+      return String(e);
+  }
+}
+function Ae(e, t) {
+  if (e === null)
+    return "null";
+  if (t.includes(e))
+    return "[Circular]";
+  const n = [...t, e];
+  if (ye(e)) {
+    const s = e.toJSON();
+    if (s !== e)
+      return typeof s == "string" ? s : S(s, n);
+  } else if (Array.isArray(e))
+    return ve(e, n);
+  return De(e, n);
+}
+function ye(e) {
+  return typeof e.toJSON == "function";
+}
+function De(e, t) {
+  const n = Object.entries(e);
+  return n.length === 0 ? "{}" : t.length > q ? "[" + ge(e) + "]" : "{ " + n.map(
+    ([i, r]) => i + ": " + S(r, t)
+  ).join(", ") + " }";
+}
+function ve(e, t) {
+  if (e.length === 0)
+    return "[]";
+  if (t.length > q)
+    return "[Array]";
+  const n = Math.min(_e, e.length), s = e.length - n, i = [];
+  for (let r = 0; r < n; ++r)
+    i.push(S(e[r], t));
+  return s === 1 ? i.push("... 1 more item") : s > 1 && i.push(`... ${s} more items`), "[" + i.join(", ") + "]";
+}
+function ge(e) {
+  const t = Object.prototype.toString.call(e).replace(/^\[object /, "").replace(/]$/, "");
+  if (t === "Object" && typeof e.constructor == "function") {
+    const n = e.constructor.name;
+    if (typeof n == "string" && n !== "")
+      return n;
+  }
+  return t;
+}
+const ke = globalThis.process && // eslint-disable-next-line no-undef
+process.env.NODE_ENV === "production", Ce = (
+  /* c8 ignore next 6 */
+  // FIXME: https://github.com/graphql/graphql-js/issues/2317
+  ke ? function(t, n) {
+    return t instanceof n;
+  } : function(t, n) {
+    if (t instanceof n)
+      return !0;
+    if (typeof t == "object" && t !== null) {
+      var s;
+      const i = n.prototype[Symbol.toStringTag], r = (
+        // We still need to support constructor's name to detect conflicts with older versions of this library.
+        Symbol.toStringTag in t ? t[Symbol.toStringTag] : (s = t.constructor) === null || s === void 0 ? void 0 : s.name
+      );
+      if (i === r) {
+        const a = z(t);
+        throw new Error(`Cannot use ${i} "${a}" 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;
+  }
+);
+class H {
+  constructor(t, n = "GraphQL request", s = {
+    line: 1,
+    column: 1
+  }) {
+    typeof t == "string" || L(!1, `Body must be a string. Received: ${z(t)}.`), this.body = t, this.name = n, this.locationOffset = s, this.locationOffset.line > 0 || L(
+      !1,
+      "line in locationOffset is 1-indexed and must be positive."
+    ), this.locationOffset.column > 0 || L(
+      !1,
+      "column in locationOffset is 1-indexed and must be positive."
+    );
+  }
+  get [Symbol.toStringTag]() {
+    return "Source";
+  }
+}
+function Se(e) {
+  return Ce(e, H);
+}
+function be(e, t) {
+  const n = new Le(e, t), s = n.parseDocument();
+  return Object.defineProperty(s, "tokenCount", {
+    enumerable: !1,
+    value: n.tokenCount
+  }), s;
+}
+class Le {
+  constructor(t, n = {}) {
+    const s = Se(t) ? t : new H(t);
+    this._lexer = new he(s), this._options = n, this._tokenCounter = 0;
+  }
+  get tokenCount() {
+    return this._tokenCounter;
+  }
+  /**
+   * Converts a name lex token into a name parse node.
+   */
+  parseName() {
+    const t = this.expectToken(o.NAME);
+    return this.node(t, {
+      kind: c.NAME,
+      value: t.value
+    });
+  }
+  // Implements the parsing rules in the Document section.
+  /**
+   * Document : Definition+
+   */
+  parseDocument() {
+    return this.node(this._lexer.token, {
+      kind: c.DOCUMENT,
+      definitions: this.many(
+        o.SOF,
+        this.parseDefinition,
+        o.EOF
+      )
+    });
+  }
+  /**
+   * Definition :
+   *   - ExecutableDefinition
+   *   - TypeSystemDefinition
+   *   - TypeSystemExtension
+   *
+   * ExecutableDefinition :
+   *   - OperationDefinition
+   *   - FragmentDefinition
+   *
+   * TypeSystemDefinition :
+   *   - SchemaDefinition
+   *   - TypeDefinition
+   *   - DirectiveDefinition
+   *
+   * TypeDefinition :
+   *   - ScalarTypeDefinition
+   *   - ObjectTypeDefinition
+   *   - InterfaceTypeDefinition
+   *   - UnionTypeDefinition
+   *   - EnumTypeDefinition
+   *   - InputObjectTypeDefinition
+   */
+  parseDefinition() {
+    if (this.peek(o.BRACE_L))
+      return this.parseOperationDefinition();
+    const t = this.peekDescription(), n = t ? this._lexer.lookahead() : this._lexer.token;
+    if (n.kind === o.NAME) {
+      switch (n.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 (t)
+        throw d(
+          this._lexer.source,
+          this._lexer.token.start,
+          "Unexpected description, descriptions are supported only on type definitions."
+        );
+      switch (n.value) {
+        case "query":
+        case "mutation":
+        case "subscription":
+          return this.parseOperationDefinition();
+        case "fragment":
+          return this.parseFragmentDefinition();
+        case "extend":
+          return this.parseTypeSystemExtension();
+      }
+    }
+    throw this.unexpected(n);
+  }
+  // Implements the parsing rules in the Operations section.
+  /**
+   * OperationDefinition :
+   *  - SelectionSet
+   *  - OperationType Name? VariableDefinitions? Directives? SelectionSet
+   */
+  parseOperationDefinition() {
+    const t = this._lexer.token;
+    if (this.peek(o.BRACE_L))
+      return this.node(t, {
+        kind: c.OPERATION_DEFINITION,
+        operation: x.QUERY,
+        name: void 0,
+        variableDefinitions: [],
+        directives: [],
+        selectionSet: this.parseSelectionSet()
+      });
+    const n = this.parseOperationType();
+    let s;
+    return this.peek(o.NAME) && (s = this.parseName()), this.node(t, {
+      kind: c.OPERATION_DEFINITION,
+      operation: n,
+      name: s,
+      variableDefinitions: this.parseVariableDefinitions(),
+      directives: this.parseDirectives(!1),
+      selectionSet: this.parseSelectionSet()
+    });
+  }
+  /**
+   * OperationType : one of query mutation subscription
+   */
+  parseOperationType() {
+    const t = this.expectToken(o.NAME);
+    switch (t.value) {
+      case "query":
+        return x.QUERY;
+      case "mutation":
+        return x.MUTATION;
+      case "subscription":
+        return x.SUBSCRIPTION;
+    }
+    throw this.unexpected(t);
+  }
+  /**
+   * VariableDefinitions : ( VariableDefinition+ )
+   */
+  parseVariableDefinitions() {
+    return this.optionalMany(
+      o.PAREN_L,
+      this.parseVariableDefinition,
+      o.PAREN_R
+    );
+  }
+  /**
+   * VariableDefinition : Variable : Type DefaultValue? Directives[Const]?
+   */
+  parseVariableDefinition() {
+    return this.node(this._lexer.token, {
+      kind: c.VARIABLE_DEFINITION,
+      variable: this.parseVariable(),
+      type: (this.expectToken(o.COLON), this.parseTypeReference()),
+      defaultValue: this.expectOptionalToken(o.EQUALS) ? this.parseConstValueLiteral() : void 0,
+      directives: this.parseConstDirectives()
+    });
+  }
+  /**
+   * Variable : $ Name
+   */
+  parseVariable() {
+    const t = this._lexer.token;
+    return this.expectToken(o.DOLLAR), this.node(t, {
+      kind: c.VARIABLE,
+      name: this.parseName()
+    });
+  }
+  /**
+   * ```
+   * SelectionSet : { Selection+ }
+   * ```
+   */
+  parseSelectionSet() {
+    return this.node(this._lexer.token, {
+      kind: c.SELECTION_SET,
+      selections: this.many(
+        o.BRACE_L,
+        this.parseSelection,
+        o.BRACE_R
+      )
+    });
+  }
+  /**
+   * Selection :
+   *   - Field
+   *   - FragmentSpread
+   *   - InlineFragment
+   */
+  parseSelection() {
+    return this.peek(o.SPREAD) ? this.parseFragment() : this.parseField();
+  }
+  /**
+   * Field : Alias? Name Arguments? Directives? SelectionSet?
+   *
+   * Alias : Name :
+   */
+  parseField() {
+    const t = this._lexer.token, n = this.parseName();
+    let s, i;
+    return this.expectOptionalToken(o.COLON) ? (s = n, i = this.parseName()) : i = n, this.node(t, {
+      kind: c.FIELD,
+      alias: s,
+      name: i,
+      arguments: this.parseArguments(!1),
+      directives: this.parseDirectives(!1),
+      selectionSet: this.peek(o.BRACE_L) ? this.parseSelectionSet() : void 0
+    });
+  }
+  /**
+   * Arguments[Const] : ( Argument[?Const]+ )
+   */
+  parseArguments(t) {
+    const n = t ? this.parseConstArgument : this.parseArgument;
+    return this.optionalMany(o.PAREN_L, n, o.PAREN_R);
+  }
+  /**
+   * Argument[Const] : Name : Value[?Const]
+   */
+  parseArgument(t = !1) {
+    const n = this._lexer.token, s = this.parseName();
+    return this.expectToken(o.COLON), this.node(n, {
+      kind: c.ARGUMENT,
+      name: s,
+      value: this.parseValueLiteral(t)
+    });
+  }
+  parseConstArgument() {
+    return this.parseArgument(!0);
+  }
+  // Implements the parsing rules in the Fragments section.
+  /**
+   * Corresponds to both FragmentSpread and InlineFragment in the spec.
+   *
+   * FragmentSpread : ... FragmentName Directives?
+   *
+   * InlineFragment : ... TypeCondition? Directives? SelectionSet
+   */
+  parseFragment() {
+    const t = this._lexer.token;
+    this.expectToken(o.SPREAD);
+    const n = this.expectOptionalKeyword("on");
+    return !n && this.peek(o.NAME) ? this.node(t, {
+      kind: c.FRAGMENT_SPREAD,
+      name: this.parseFragmentName(),
+      directives: this.parseDirectives(!1)
+    }) : this.node(t, {
+      kind: c.INLINE_FRAGMENT,
+      typeCondition: n ? this.parseNamedType() : void 0,
+      directives: this.parseDirectives(!1),
+      selectionSet: this.parseSelectionSet()
+    });
+  }
+  /**
+   * FragmentDefinition :
+   *   - fragment FragmentName on TypeCondition Directives? SelectionSet
+   *
+   * TypeCondition : NamedType
+   */
+  parseFragmentDefinition() {
+    const t = this._lexer.token;
+    return this.expectKeyword("fragment"), this._options.allowLegacyFragmentVariables === !0 ? this.node(t, {
+      kind: c.FRAGMENT_DEFINITION,
+      name: this.parseFragmentName(),
+      variableDefinitions: this.parseVariableDefinitions(),
+      typeCondition: (this.expectKeyword("on"), this.parseNamedType()),
+      directives: this.parseDirectives(!1),
+      selectionSet: this.parseSelectionSet()
+    }) : this.node(t, {
+      kind: c.FRAGMENT_DEFINITION,
+      name: this.parseFragmentName(),
+      typeCondition: (this.expectKeyword("on"), this.parseNamedType()),
+      directives: this.parseDirectives(!1),
+      selectionSet: this.parseSelectionSet()
+    });
+  }
+  /**
+   * FragmentName : Name but not `on`
+   */
+  parseFragmentName() {
+    if (this._lexer.token.value === "on")
+      throw this.unexpected();
+    return this.parseName();
+  }
+  // Implements the parsing rules in the Values section.
+  /**
+   * Value[Const] :
+   *   - [~Const] Variable
+   *   - IntValue
+   *   - FloatValue
+   *   - StringValue
+   *   - BooleanValue
+   *   - NullValue
+   *   - EnumValue
+   *   - ListValue[?Const]
+   *   - ObjectValue[?Const]
+   *
+   * BooleanValue : one of `true` `false`
+   *
+   * NullValue : `null`
+   *
+   * EnumValue : Name but not `true`, `false` or `null`
+   */
+  parseValueLiteral(t) {
+    const n = this._lexer.token;
+    switch (n.kind) {
+      case o.BRACKET_L:
+        return this.parseList(t);
+      case o.BRACE_L:
+        return this.parseObject(t);
+      case o.INT:
+        return this.advanceLexer(), this.node(n, {
+          kind: c.INT,
+          value: n.value
+        });
+      case o.FLOAT:
+        return this.advanceLexer(), this.node(n, {
+          kind: c.FLOAT,
+          value: n.value
+        });
+      case o.STRING:
+      case o.BLOCK_STRING:
+        return this.parseStringLiteral();
+      case o.NAME:
+        switch (this.advanceLexer(), n.value) {
+          case "true":
+            return this.node(n, {
+              kind: c.BOOLEAN,
+              value: !0
+            });
+          case "false":
+            return this.node(n, {
+              kind: c.BOOLEAN,
+              value: !1
+            });
+          case "null":
+            return this.node(n, {
+              kind: c.NULL
+            });
+          default:
+            return this.node(n, {
+              kind: c.ENUM,
+              value: n.value
+            });
+        }
+      case o.DOLLAR:
+        if (t)
+          if (this.expectToken(o.DOLLAR), this._lexer.token.kind === o.NAME) {
+            const s = this._lexer.token.value;
+            throw d(
+              this._lexer.source,
+              n.start,
+              `Unexpected variable "$${s}" in constant value.`
+            );
+          } else
+            throw this.unexpected(n);
+        return this.parseVariable();
+      default:
+        throw this.unexpected();
+    }
+  }
+  parseConstValueLiteral() {
+    return this.parseValueLiteral(!0);
+  }
+  parseStringLiteral() {
+    const t = this._lexer.token;
+    return this.advanceLexer(), this.node(t, {
+      kind: c.STRING,
+      value: t.value,
+      block: t.kind === o.BLOCK_STRING
+    });
+  }
+  /**
+   * ListValue[Const] :
+   *   - [ ]
+   *   - [ Value[?Const]+ ]
+   */
+  parseList(t) {
+    const n = () => this.parseValueLiteral(t);
+    return this.node(this._lexer.token, {
+      kind: c.LIST,
+      values: this.any(o.BRACKET_L, n, o.BRACKET_R)
+    });
+  }
+  /**
+   * ```
+   * ObjectValue[Const] :
+   *   - { }
+   *   - { ObjectField[?Const]+ }
+   * ```
+   */
+  parseObject(t) {
+    const n = () => this.parseObjectField(t);
+    return this.node(this._lexer.token, {
+      kind: c.OBJECT,
+      fields: this.any(o.BRACE_L, n, o.BRACE_R)
+    });
+  }
+  /**
+   * ObjectField[Const] : Name : Value[?Const]
+   */
+  parseObjectField(t) {
+    const n = this._lexer.token, s = this.parseName();
+    return this.expectToken(o.COLON), this.node(n, {
+      kind: c.OBJECT_FIELD,
+      name: s,
+      value: this.parseValueLiteral(t)
+    });
+  }
+  // Implements the parsing rules in the Directives section.
+  /**
+   * Directives[Const] : Directive[?Const]+
+   */
+  parseDirectives(t) {
+    const n = [];
+    for (; this.peek(o.AT); )
+      n.push(this.parseDirective(t));
+    return n;
+  }
+  parseConstDirectives() {
+    return this.parseDirectives(!0);
+  }
+  /**
+   * ```
+   * Directive[Const] : @ Name Arguments[?Const]?
+   * ```
+   */
+  parseDirective(t) {
+    const n = this._lexer.token;
+    return this.expectToken(o.AT), this.node(n, {
+      kind: c.DIRECTIVE,
+      name: this.parseName(),
+      arguments: this.parseArguments(t)
+    });
+  }
+  // Implements the parsing rules in the Types section.
+  /**
+   * Type :
+   *   - NamedType
+   *   - ListType
+   *   - NonNullType
+   */
+  parseTypeReference() {
+    const t = this._lexer.token;
+    let n;
+    if (this.expectOptionalToken(o.BRACKET_L)) {
+      const s = this.parseTypeReference();
+      this.expectToken(o.BRACKET_R), n = this.node(t, {
+        kind: c.LIST_TYPE,
+        type: s
+      });
+    } else
+      n = this.parseNamedType();
+    return this.expectOptionalToken(o.BANG) ? this.node(t, {
+      kind: c.NON_NULL_TYPE,
+      type: n
+    }) : n;
+  }
+  /**
+   * NamedType : Name
+   */
+  parseNamedType() {
+    return this.node(this._lexer.token, {
+      kind: c.NAMED_TYPE,
+      name: this.parseName()
+    });
+  }
+  // Implements the parsing rules in the Type Definition section.
+  peekDescription() {
+    return this.peek(o.STRING) || this.peek(o.BLOCK_STRING);
+  }
+  /**
+   * Description : StringValue
+   */
+  parseDescription() {
+    if (this.peekDescription())
+      return this.parseStringLiteral();
+  }
+  /**
+   * ```
+   * SchemaDefinition : Description? schema Directives[Const]? { OperationTypeDefinition+ }
+   * ```
+   */
+  parseSchemaDefinition() {
+    const t = this._lexer.token, n = this.parseDescription();
+    this.expectKeyword("schema");
+    const s = this.parseConstDirectives(), i = this.many(
+      o.BRACE_L,
+      this.parseOperationTypeDefinition,
+      o.BRACE_R
+    );
+    return this.node(t, {
+      kind: c.SCHEMA_DEFINITION,
+      description: n,
+      directives: s,
+      operationTypes: i
+    });
+  }
+  /**
+   * OperationTypeDefinition : OperationType : NamedType
+   */
+  parseOperationTypeDefinition() {
+    const t = this._lexer.token, n = this.parseOperationType();
+    this.expectToken(o.COLON);
+    const s = this.parseNamedType();
+    return this.node(t, {
+      kind: c.OPERATION_TYPE_DEFINITION,
+      operation: n,
+      type: s
+    });
+  }
+  /**
+   * ScalarTypeDefinition : Description? scalar Name Directives[Const]?
+   */
+  parseScalarTypeDefinition() {
+    const t = this._lexer.token, n = this.parseDescription();
+    this.expectKeyword("scalar");
+    const s = this.parseName(), i = this.parseConstDirectives();
+    return this.node(t, {
+      kind: c.SCALAR_TYPE_DEFINITION,
+      description: n,
+      name: s,
+      directives: i
+    });
+  }
+  /**
+   * ObjectTypeDefinition :
+   *   Description?
+   *   type Name ImplementsInterfaces? Directives[Const]? FieldsDefinition?
+   */
+  parseObjectTypeDefinition() {
+    const t = this._lexer.token, n = this.parseDescription();
+    this.expectKeyword("type");
+    const s = this.parseName(), i = this.parseImplementsInterfaces(), r = this.parseConstDirectives(), a = this.parseFieldsDefinition();
+    return this.node(t, {
+      kind: c.OBJECT_TYPE_DEFINITION,
+      description: n,
+      name: s,
+      interfaces: i,
+      directives: r,
+      fields: a
+    });
+  }
+  /**
+   * ImplementsInterfaces :
+   *   - implements `&`? NamedType
+   *   - ImplementsInterfaces & NamedType
+   */
+  parseImplementsInterfaces() {
+    return this.expectOptionalKeyword("implements") ? this.delimitedMany(o.AMP, this.parseNamedType) : [];
+  }
+  /**
+   * ```
+   * FieldsDefinition : { FieldDefinition+ }
+   * ```
+   */
+  parseFieldsDefinition() {
+    return this.optionalMany(
+      o.BRACE_L,
+      this.parseFieldDefinition,
+      o.BRACE_R
+    );
+  }
+  /**
+   * FieldDefinition :
+   *   - Description? Name ArgumentsDefinition? : Type Directives[Const]?
+   */
+  parseFieldDefinition() {
+    const t = this._lexer.token, n = this.parseDescription(), s = this.parseName(), i = this.parseArgumentDefs();
+    this.expectToken(o.COLON);
+    const r = this.parseTypeReference(), a = this.parseConstDirectives();
+    return this.node(t, {
+      kind: c.FIELD_DEFINITION,
+      description: n,
+      name: s,
+      arguments: i,
+      type: r,
+      directives: a
+    });
+  }
+  /**
+   * ArgumentsDefinition : ( InputValueDefinition+ )
+   */
+  parseArgumentDefs() {
+    return this.optionalMany(
+      o.PAREN_L,
+      this.parseInputValueDef,
+      o.PAREN_R
+    );
+  }
+  /**
+   * InputValueDefinition :
+   *   - Description? Name : Type DefaultValue? Directives[Const]?
+   */
+  parseInputValueDef() {
+    const t = this._lexer.token, n = this.parseDescription(), s = this.parseName();
+    this.expectToken(o.COLON);
+    const i = this.parseTypeReference();
+    let r;
+    this.expectOptionalToken(o.EQUALS) && (r = this.parseConstValueLiteral());
+    const a = this.parseConstDirectives();
+    return this.node(t, {
+      kind: c.INPUT_VALUE_DEFINITION,
+      description: n,
+      name: s,
+      type: i,
+      defaultValue: r,
+      directives: a
+    });
+  }
+  /**
+   * InterfaceTypeDefinition :
+   *   - Description? interface Name Directives[Const]? FieldsDefinition?
+   */
+  parseInterfaceTypeDefinition() {
+    const t = this._lexer.token, n = this.parseDescription();
+    this.expectKeyword("interface");
+    const s = this.parseName(), i = this.parseImplementsInterfaces(), r = this.parseConstDirectives(), a = this.parseFieldsDefinition();
+    return this.node(t, {
+      kind: c.INTERFACE_TYPE_DEFINITION,
+      description: n,
+      name: s,
+      interfaces: i,
+      directives: r,
+      fields: a
+    });
+  }
+  /**
+   * UnionTypeDefinition :
+   *   - Description? union Name Directives[Const]? UnionMemberTypes?
+   */
+  parseUnionTypeDefinition() {
+    const t = this._lexer.token, n = this.parseDescription();
+    this.expectKeyword("union");
+    const s = this.parseName(), i = this.parseConstDirectives(), r = this.parseUnionMemberTypes();
+    return this.node(t, {
+      kind: c.UNION_TYPE_DEFINITION,
+      description: n,
+      name: s,
+      directives: i,
+      types: r
+    });
+  }
+  /**
+   * UnionMemberTypes :
+   *   - = `|`? NamedType
+   *   - UnionMemberTypes | NamedType
+   */
+  parseUnionMemberTypes() {
+    return this.expectOptionalToken(o.EQUALS) ? this.delimitedMany(o.PIPE, this.parseNamedType) : [];
+  }
+  /**
+   * EnumTypeDefinition :
+   *   - Description? enum Name Directives[Const]? EnumValuesDefinition?
+   */
+  parseEnumTypeDefinition() {
+    const t = this._lexer.token, n = this.parseDescription();
+    this.expectKeyword("enum");
+    const s = this.parseName(), i = this.parseConstDirectives(), r = this.parseEnumValuesDefinition();
+    return this.node(t, {
+      kind: c.ENUM_TYPE_DEFINITION,
+      description: n,
+      name: s,
+      directives: i,
+      values: r
+    });
+  }
+  /**
+   * ```
+   * EnumValuesDefinition : { EnumValueDefinition+ }
+   * ```
+   */
+  parseEnumValuesDefinition() {
+    return this.optionalMany(
+      o.BRACE_L,
+      this.parseEnumValueDefinition,
+      o.BRACE_R
+    );
+  }
+  /**
+   * EnumValueDefinition : Description? EnumValue Directives[Const]?
+   */
+  parseEnumValueDefinition() {
+    const t = this._lexer.token, n = this.parseDescription(), s = this.parseEnumValueName(), i = this.parseConstDirectives();
+    return this.node(t, {
+      kind: c.ENUM_VALUE_DEFINITION,
+      description: n,
+      name: s,
+      directives: i
+    });
+  }
+  /**
+   * EnumValue : Name but not `true`, `false` or `null`
+   */
+  parseEnumValueName() {
+    if (this._lexer.token.value === "true" || this._lexer.token.value === "false" || this._lexer.token.value === "null")
+      throw d(
+        this._lexer.source,
+        this._lexer.token.start,
+        `${v(
+          this._lexer.token
+        )} is reserved and cannot be used for an enum value.`
+      );
+    return this.parseName();
+  }
+  /**
+   * InputObjectTypeDefinition :
+   *   - Description? input Name Directives[Const]? InputFieldsDefinition?
+   */
+  parseInputObjectTypeDefinition() {
+    const t = this._lexer.token, n = this.parseDescription();
+    this.expectKeyword("input");
+    const s = this.parseName(), i = this.parseConstDirectives(), r = this.parseInputFieldsDefinition();
+    return this.node(t, {
+      kind: c.INPUT_OBJECT_TYPE_DEFINITION,
+      description: n,
+      name: s,
+      directives: i,
+      fields: r
+    });
+  }
+  /**
+   * ```
+   * InputFieldsDefinition : { InputValueDefinition+ }
+   * ```
+   */
+  parseInputFieldsDefinition() {
+    return this.optionalMany(
+      o.BRACE_L,
+      this.parseInputValueDef,
+      o.BRACE_R
+    );
+  }
+  /**
+   * TypeSystemExtension :
+   *   - SchemaExtension
+   *   - TypeExtension
+   *
+   * TypeExtension :
+   *   - ScalarTypeExtension
+   *   - ObjectTypeExtension
+   *   - InterfaceTypeExtension
+   *   - UnionTypeExtension
+   *   - EnumTypeExtension
+   *   - InputObjectTypeDefinition
+   */
+  parseTypeSystemExtension() {
+    const t = this._lexer.lookahead();
+    if (t.kind === o.NAME)
+      switch (t.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(t);
+  }
+  /**
+   * ```
+   * SchemaExtension :
+   *  - extend schema Directives[Const]? { OperationTypeDefinition+ }
+   *  - extend schema Directives[Const]
+   * ```
+   */
+  parseSchemaExtension() {
+    const t = this._lexer.token;
+    this.expectKeyword("extend"), this.expectKeyword("schema");
+    const n = this.parseConstDirectives(), s = this.optionalMany(
+      o.BRACE_L,
+      this.parseOperationTypeDefinition,
+      o.BRACE_R
+    );
+    if (n.length === 0 && s.length === 0)
+      throw this.unexpected();
+    return this.node(t, {
+      kind: c.SCHEMA_EXTENSION,
+      directives: n,
+      operationTypes: s
+    });
+  }
+  /**
+   * ScalarTypeExtension :
+   *   - extend scalar Name Directives[Const]
+   */
+  parseScalarTypeExtension() {
+    const t = this._lexer.token;
+    this.expectKeyword("extend"), this.expectKeyword("scalar");
+    const n = this.parseName(), s = this.parseConstDirectives();
+    if (s.length === 0)
+      throw this.unexpected();
+    return this.node(t, {
+      kind: c.SCALAR_TYPE_EXTENSION,
+      name: n,
+      directives: s
+    });
+  }
+  /**
+   * ObjectTypeExtension :
+   *  - extend type Name ImplementsInterfaces? Directives[Const]? FieldsDefinition
+   *  - extend type Name ImplementsInterfaces? Directives[Const]
+   *  - extend type Name ImplementsInterfaces
+   */
+  parseObjectTypeExtension() {
+    const t = this._lexer.token;
+    this.expectKeyword("extend"), this.expectKeyword("type");
+    const n = this.parseName(), s = this.parseImplementsInterfaces(), i = this.parseConstDirectives(), r = this.parseFieldsDefinition();
+    if (s.length === 0 && i.length === 0 && r.length === 0)
+      throw this.unexpected();
+    return this.node(t, {
+      kind: c.OBJECT_TYPE_EXTENSION,
+      name: n,
+      interfaces: s,
+      directives: i,
+      fields: r
+    });
+  }
+  /**
+   * InterfaceTypeExtension :
+   *  - extend interface Name ImplementsInterfaces? Directives[Const]? FieldsDefinition
+   *  - extend interface Name ImplementsInterfaces? Directives[Const]
+   *  - extend interface Name ImplementsInterfaces
+   */
+  parseInterfaceTypeExtension() {
+    const t = this._lexer.token;
+    this.expectKeyword("extend"), this.expectKeyword("interface");
+    const n = this.parseName(), s = this.parseImplementsInterfaces(), i = this.parseConstDirectives(), r = this.parseFieldsDefinition();
+    if (s.length === 0 && i.length === 0 && r.length === 0)
+      throw this.unexpected();
+    return this.node(t, {
+      kind: c.INTERFACE_TYPE_EXTENSION,
+      name: n,
+      interfaces: s,
+      directives: i,
+      fields: r
+    });
+  }
+  /**
+   * UnionTypeExtension :
+   *   - extend union Name Directives[Const]? UnionMemberTypes
+   *   - extend union Name Directives[Const]
+   */
+  parseUnionTypeExtension() {
+    const t = this._lexer.token;
+    this.expectKeyword("extend"), this.expectKeyword("union");
+    const n = this.parseName(), s = this.parseConstDirectives(), i = this.parseUnionMemberTypes();
+    if (s.length === 0 && i.length === 0)
+      throw this.unexpected();
+    return this.node(t, {
+      kind: c.UNION_TYPE_EXTENSION,
+      name: n,
+      directives: s,
+      types: i
+    });
+  }
+  /**
+   * EnumTypeExtension :
+   *   - extend enum Name Directives[Const]? EnumValuesDefinition
+   *   - extend enum Name Directives[Const]
+   */
+  parseEnumTypeExtension() {
+    const t = this._lexer.token;
+    this.expectKeyword("extend"), this.expectKeyword("enum");
+    const n = this.parseName(), s = this.parseConstDirectives(), i = this.parseEnumValuesDefinition();
+    if (s.length === 0 && i.length === 0)
+      throw this.unexpected();
+    return this.node(t, {
+      kind: c.ENUM_TYPE_EXTENSION,
+      name: n,
+      directives: s,
+      values: i
+    });
+  }
+  /**
+   * InputObjectTypeExtension :
+   *   - extend input Name Directives[Const]? InputFieldsDefinition
+   *   - extend input Name Directives[Const]
+   */
+  parseInputObjectTypeExtension() {
+    const t = this._lexer.token;
+    this.expectKeyword("extend"), this.expectKeyword("input");
+    const n = this.parseName(), s = this.parseConstDirectives(), i = this.parseInputFieldsDefinition();
+    if (s.length === 0 && i.length === 0)
+      throw this.unexpected();
+    return this.node(t, {
+      kind: c.INPUT_OBJECT_TYPE_EXTENSION,
+      name: n,
+      directives: s,
+      fields: i
+    });
+  }
+  /**
+   * ```
+   * DirectiveDefinition :
+   *   - Description? directive @ Name ArgumentsDefinition? `repeatable`? on DirectiveLocations
+   * ```
+   */
+  parseDirectiveDefinition() {
+    const t = this._lexer.token, n = this.parseDescription();
+    this.expectKeyword("directive"), this.expectToken(o.AT);
+    const s = this.parseName(), i = this.parseArgumentDefs(), r = this.expectOptionalKeyword("repeatable");
+    this.expectKeyword("on");
+    const a = this.parseDirectiveLocations();
+    return this.node(t, {
+      kind: c.DIRECTIVE_DEFINITION,
+      description: n,
+      name: s,
+      arguments: i,
+      repeatable: r,
+      locations: a
+    });
+  }
+  /**
+   * DirectiveLocations :
+   *   - `|`? DirectiveLocation
+   *   - DirectiveLocations | DirectiveLocation
+   */
+  parseDirectiveLocations() {
+    return this.delimitedMany(o.PIPE, this.parseDirectiveLocation);
+  }
+  /*
+   * DirectiveLocation :
+   *   - ExecutableDirectiveLocation
+   *   - TypeSystemDirectiveLocation
+   *
+   * ExecutableDirectiveLocation : one of
+   *   `QUERY`
+   *   `MUTATION`
+   *   `SUBSCRIPTION`
+   *   `FIELD`
+   *   `FRAGMENT_DEFINITION`
+   *   `FRAGMENT_SPREAD`
+   *   `INLINE_FRAGMENT`
+   *
+   * TypeSystemDirectiveLocation : one of
+   *   `SCHEMA`
+   *   `SCALAR`
+   *   `OBJECT`
+   *   `FIELD_DEFINITION`
+   *   `ARGUMENT_DEFINITION`
+   *   `INTERFACE`
+   *   `UNION`
+   *   `ENUM`
+   *   `ENUM_VALUE`
+   *   `INPUT_OBJECT`
+   *   `INPUT_FIELD_DEFINITION`
+   */
+  parseDirectiveLocation() {
+    const t = this._lexer.token, n = this.parseName();
+    if (Object.prototype.hasOwnProperty.call(w, n.value))
+      return n;
+    throw this.unexpected(t);
+  }
+  // Core parsing utility functions
+  /**
+   * Returns a node that, if configured to do so, sets a "loc" field as a
+   * location object, used to identify the place in the source that created a
+   * given parsed object.
+   */
+  node(t, n) {
+    return this._options.noLocation !== !0 && (n.loc = new re(
+      t,
+      this._lexer.lastToken,
+      this._lexer.source
+    )), n;
+  }
+  /**
+   * Determines if the next token is of a given kind
+   */
+  peek(t) {
+    return this._lexer.token.kind === t;
+  }
+  /**
+   * If the next token is of the given kind, return that token after advancing the lexer.
+   * Otherwise, do not change the parser state and throw an error.
+   */
+  expectToken(t) {
+    const n = this._lexer.token;
+    if (n.kind === t)
+      return this.advanceLexer(), n;
+    throw d(
+      this._lexer.source,
+      n.start,
+      `Expected ${W(t)}, found ${v(n)}.`
+    );
+  }
+  /**
+   * If the next token is of the given kind, return "true" after advancing the lexer.
+   * Otherwise, do not change the parser state and return "false".
+   */
+  expectOptionalToken(t) {
+    return this._lexer.token.kind === t ? (this.advanceLexer(), !0) : !1;
+  }
+  /**
+   * If the next token is a given keyword, advance the lexer.
+   * Otherwise, do not change the parser state and throw an error.
+   */
+  expectKeyword(t) {
+    const n = this._lexer.token;
+    if (n.kind === o.NAME && n.value === t)
+      this.advanceLexer();
+    else
+      throw d(
+        this._lexer.source,
+        n.start,
+        `Expected "${t}", found ${v(n)}.`
+      );
+  }
+  /**
+   * If the next token is a given keyword, return "true" after advancing the lexer.
+   * Otherwise, do not change the parser state and return "false".
+   */
+  expectOptionalKeyword(t) {
+    const n = this._lexer.token;
+    return n.kind === o.NAME && n.value === t ? (this.advanceLexer(), !0) : !1;
+  }
+  /**
+   * Helper function for creating an error when an unexpected lexed token is encountered.
+   */
+  unexpected(t) {
+    const n = t ?? this._lexer.token;
+    return d(
+      this._lexer.source,
+      n.start,
+      `Unexpected ${v(n)}.`
+    );
+  }
+  /**
+   * Returns a possibly empty list of parse nodes, determined by the parseFn.
+   * This list begins with a lex token of openKind and ends with a lex token of closeKind.
+   * Advances the parser to the next lex token after the closing token.
+   */
+  any(t, n, s) {
+    this.expectToken(t);
+    const i = [];
+    for (; !this.expectOptionalToken(s); )
+      i.push(n.call(this));
+    return i;
+  }
+  /**
+   * Returns a list of parse nodes, determined by the parseFn.
+   * It can be empty only if open token is missing otherwise it will always return non-empty list
+   * that begins with a lex token of openKind and ends with a lex token of closeKind.
+   * Advances the parser to the next lex token after the closing token.
+   */
+  optionalMany(t, n, s) {
+    if (this.expectOptionalToken(t)) {
+      const i = [];
+      do
+        i.push(n.call(this));
+      while (!this.expectOptionalToken(s));
+      return i;
+    }
+    return [];
+  }
+  /**
+   * Returns a non-empty list of parse nodes, determined by the parseFn.
+   * This list begins with a lex token of openKind and ends with a lex token of closeKind.
+   * Advances the parser to the next lex token after the closing token.
+   */
+  many(t, n, s) {
+    this.expectToken(t);
+    const i = [];
+    do
+      i.push(n.call(this));
+    while (!this.expectOptionalToken(s));
+    return i;
+  }
+  /**
+   * Returns a non-empty list of parse nodes, determined by the parseFn.
+   * This list may begin with a lex token of delimiterKind followed by items separated by lex tokens of tokenKind.
+   * Advances the parser to the next lex token after last item in the list.
+   */
+  delimitedMany(t, n) {
+    this.expectOptionalToken(t);
+    const s = [];
+    do
+      s.push(n.call(this));
+    while (this.expectOptionalToken(t));
+    return s;
+  }
+  advanceLexer() {
+    const { maxTokens: t } = this._options, n = this._lexer.advance();
+    if (n.kind !== o.EOF && (++this._tokenCounter, t !== void 0 && this._tokenCounter > t))
+      throw d(
+        this._lexer.source,
+        n.start,
+        `Document contains more that ${t} tokens. Parsing aborted.`
+      );
+  }
+}
+function v(e) {
+  const t = e.value;
+  return W(e.kind) + (t != null ? ` "${t}"` : "");
+}
+function W(e) {
+  return pe(e) ? `"${e}"` : e;
+}
+var g = /* @__PURE__ */ new Map(), P = /* @__PURE__ */ new Map(), Z = !0, k = !1;
+function K(e) {
+  return e.replace(/[\s,]+/g, " ").trim();
+}
+function Re(e) {
+  return K(e.source.body.substring(e.start, e.end));
+}
+function Fe(e) {
+  var t = /* @__PURE__ */ new Set(), n = [];
+  return e.definitions.forEach(function(s) {
+    if (s.kind === "FragmentDefinition") {
+      var i = s.name.value, r = Re(s.loc), a = P.get(i);
+      a && !a.has(r) ? Z && console.warn("Warning: fragment with name " + i + ` already exists.
+graphql-tag enforces all fragment names across your application to be unique; read more about
+this in the docs: http://dev.apollodata.com/core/fragments.html#unique-names`) : a || P.set(i, a = /* @__PURE__ */ new Set()), a.add(r), t.has(r) || (t.add(r), n.push(s));
+    } else
+      n.push(s);
+  }), U(U({}, e), { definitions: n });
+}
+function we(e) {
+  var t = new Set(e.definitions);
+  t.forEach(function(s) {
+    s.loc && delete s.loc, Object.keys(s).forEach(function(i) {
+      var r = s[i];
+      r && typeof r == "object" && t.add(r);
+    });
+  });
+  var n = e.loc;
+  return n && (delete n.startToken, delete n.endToken), e;
+}
+function Pe(e) {
+  var t = K(e);
+  if (!g.has(t)) {
+    var n = be(e, {
+      experimentalFragmentVariables: k,
+      allowLegacyFragmentVariables: k
+    });
+    if (!n || n.kind !== "Document")
+      throw new Error("Not a valid GraphQL document.");
+    g.set(t, we(Fe(n)));
+  }
+  return g.get(t);
+}
+function D(e) {
+  for (var t = [], n = 1; n < arguments.length; n++)
+    t[n - 1] = arguments[n];
+  typeof e == "string" && (e = [e]);
+  var s = e[0];
+  return t.forEach(function(i, r) {
+    i && i.kind === "Document" ? s += i.loc.source.body : s += i, s += e[r + 1];
+  }), Pe(s);
+}
+function Me() {
+  g.clear(), P.clear();
+}
+function Ue() {
+  Z = !1;
+}
+function Ve() {
+  k = !0;
+}
+function Be() {
+  k = !1;
+}
+var _ = {
+  gql: D,
+  resetCaches: Me,
+  disableFragmentWarnings: Ue,
+  enableExperimentalFragmentVariables: Ve,
+  disableExperimentalFragmentVariables: Be
+};
+(function(e) {
+  e.gql = _.gql, e.resetCaches = _.resetCaches, e.disableFragmentWarnings = _.disableFragmentWarnings, e.enableExperimentalFragmentVariables = _.enableExperimentalFragmentVariables, e.disableExperimentalFragmentVariables = _.disableExperimentalFragmentVariables;
+})(D || (D = {}));
+D.default = D;
+export {
+  D as g
+};