@redocly/replay 0.26.0-next.5 → 0.26.0-next.7

package/dist/replay-lint-graphql-f9UVRzKF.js

@@ -0,0 +1,1956 @@
+import { M as R, T as L, N as k, O as g, P as B, Q as M, R as A, S as U, U as V, V as a, W as T, X as K, Y as G, Z as v, _ as $, $ as Y, a0 as j } from "./replay-index-C-dfM8Rr.js";
+function u(n, t, e) {
+  return new R(`Syntax Error: ${e}`, {
+    source: n,
+    positions: [t]
+  });
+}
+var r;
+(function(n) {
+  n.SOF = "<SOF>", n.EOF = "<EOF>", n.BANG = "!", n.DOLLAR = "$", n.AMP = "&", n.PAREN_L = "(", n.PAREN_R = ")", n.DOT = ".", n.SPREAD = "...", n.COLON = ":", n.EQUALS = "=", n.AT = "@", n.BRACKET_L = "[", n.BRACKET_R = "]", n.BRACE_L = "{", n.PIPE = "|", n.BRACE_R = "}", n.NAME = "Name", n.INT = "Int", n.FLOAT = "Float", n.STRING = "String", n.BLOCK_STRING = "BlockString", n.COMMENT = "Comment";
+})(r || (r = {}));
+class q {
+  /** Source document used to derive error locations. */
+  /** Most recent non-ignored token returned by the lexer. */
+  /** Current non-ignored token at the lexer cursor. */
+  /** The (1-indexed) line containing the current token. */
+  /** Character offset where the current line starts. */
+  /**
+   * Creates a Lexer instance.
+   * @param source - Source document used to derive error locations.
+   * @example
+   * ```ts
+   * import { Lexer, Source, TokenKind } from 'graphql/language';
+   *
+   * const lexer = new Lexer(new Source('{ hello }'));
+   *
+   * lexer.token.kind; // => TokenKind.SOF
+   * lexer.advance().kind; // => TokenKind.BRACE_L
+   * lexer.advance().value; // => 'hello'
+   * lexer.advance().kind; // => TokenKind.BRACE_R
+   * ```
+   */
+  constructor(t) {
+    const e = new L(r.SOF, 0, 0, 0, 0);
+    this.source = t, this.lastToken = e, this.token = e, this.line = 1, this.lineStart = 0;
+  }
+  /**
+   * Returns the value used by `Object.prototype.toString`.
+   * @returns The built-in string tag for this object.
+   */
+  get [Symbol.toStringTag]() {
+    return "Lexer";
+  }
+  /**
+   * Advances the token stream to the next non-ignored token.
+   * @returns The next non-ignored token.
+   * @example
+   * ```ts
+   * import { Lexer, Source } from 'graphql/language';
+   *
+   * const lexer = new Lexer(new Source('{ hello }'));
+   * const token = lexer.advance();
+   *
+   * token.kind; // => '{'
+   * lexer.token; // => 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.
+   * @returns The next non-ignored token without advancing the lexer.
+   * @example
+   * ```ts
+   * import { Lexer, Source } from 'graphql/language';
+   *
+   * const lexer = new Lexer(new Source('{ hello }'));
+   * const token = lexer.lookahead();
+   *
+   * token.kind; // => '{'
+   * lexer.token.kind; // => '<SOF>'
+   * ```
+   */
+  lookahead() {
+    let t = this.token;
+    if (t.kind !== r.EOF)
+      do
+        if (t.next)
+          t = t.next;
+        else {
+          const e = z(this, t.end);
+          t.next = e, e.prev = t, t = e;
+        }
+      while (t.kind === r.COMMENT);
+    return t;
+  }
+}
+function Q(n) {
+  return n === r.BANG || n === r.DOLLAR || n === r.AMP || n === r.PAREN_L || n === r.PAREN_R || n === r.DOT || n === r.SPREAD || n === r.COLON || n === r.EQUALS || n === r.AT || n === r.BRACKET_L || n === r.BRACKET_R || n === r.BRACE_L || n === r.PIPE || n === r.BRACE_R;
+}
+function E(n) {
+  return n >= 0 && n <= 55295 || n >= 57344 && n <= 1114111;
+}
+function _(n, t) {
+  return S(n.charCodeAt(t)) && w(n.charCodeAt(t + 1));
+}
+function S(n) {
+  return n >= 55296 && n <= 56319;
+}
+function w(n) {
+  return n >= 56320 && n <= 57343;
+}
+function x(n, t) {
+  const e = n.source.body.codePointAt(t);
+  if (e === void 0)
+    return r.EOF;
+  if (e >= 32 && e <= 126) {
+    const i = String.fromCodePoint(e);
+    return i === '"' ? `'"'` : `"${i}"`;
+  }
+  return "U+" + e.toString(16).toUpperCase().padStart(4, "0");
+}
+function h(n, t, e, i, s) {
+  const o = n.line, c = 1 + e - n.lineStart;
+  return new L(t, e, i, o, c, s);
+}
+function z(n, t) {
+  const e = n.source.body, i = e.length;
+  let s = t;
+  for (; s < i; ) {
+    const o = e.charCodeAt(s);
+    switch (o) {
+      // 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:
+        ++s;
+        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:
+        ++s, ++n.line, n.lineStart = s;
+        continue;
+      case 13:
+        e.charCodeAt(s + 1) === 10 ? s += 2 : ++s, ++n.line, n.lineStart = s;
+        continue;
+      // Comment
+      case 35:
+        return X(n, s);
+      // Token ::
+      //   - Punctuator
+      //   - Name
+      //   - IntValue
+      //   - FloatValue
+      //   - StringValue
+      //
+      // Punctuator :: one of ! $ & ( ) ... : = @ [ ] { | }
+      case 33:
+        return h(n, r.BANG, s, s + 1);
+      case 36:
+        return h(n, r.DOLLAR, s, s + 1);
+      case 38:
+        return h(n, r.AMP, s, s + 1);
+      case 40:
+        return h(n, r.PAREN_L, s, s + 1);
+      case 41:
+        return h(n, r.PAREN_R, s, s + 1);
+      case 46:
+        if (e.charCodeAt(s + 1) === 46 && e.charCodeAt(s + 2) === 46)
+          return h(n, r.SPREAD, s, s + 3);
+        break;
+      case 58:
+        return h(n, r.COLON, s, s + 1);
+      case 61:
+        return h(n, r.EQUALS, s, s + 1);
+      case 64:
+        return h(n, r.AT, s, s + 1);
+      case 91:
+        return h(n, r.BRACKET_L, s, s + 1);
+      case 93:
+        return h(n, r.BRACKET_R, s, s + 1);
+      case 123:
+        return h(n, r.BRACE_L, s, s + 1);
+      case 124:
+        return h(n, r.PIPE, s, s + 1);
+      case 125:
+        return h(n, r.BRACE_R, s, s + 1);
+      // StringValue
+      case 34:
+        return e.charCodeAt(s + 1) === 34 && e.charCodeAt(s + 2) === 34 ? te(n, s) : H(n, s);
+    }
+    if (k(o) || o === 45)
+      return J(n, s, o);
+    if (g(o))
+      return se(n, s);
+    throw u(
+      n.source,
+      s,
+      o === 39 ? `Unexpected single quote character ('), did you mean to use a double quote (")?` : E(o) || _(e, s) ? `Unexpected character: ${x(n, s)}.` : `Invalid character: ${x(n, s)}.`
+    );
+  }
+  return h(n, r.EOF, i, i);
+}
+function X(n, t) {
+  const e = n.source.body, i = e.length;
+  let s = t + 1;
+  for (; s < i; ) {
+    const o = e.charCodeAt(s);
+    if (o === 10 || o === 13)
+      break;
+    if (E(o))
+      ++s;
+    else if (_(e, s))
+      s += 2;
+    else
+      break;
+  }
+  return h(
+    n,
+    r.COMMENT,
+    t,
+    s,
+    e.slice(t + 1, s)
+  );
+}
+function J(n, t, e) {
+  const i = n.source.body;
+  let s = t, o = e, c = !1;
+  if (o === 45 && (o = i.charCodeAt(++s)), o === 48) {
+    if (o = i.charCodeAt(++s), k(o))
+      throw u(
+        n.source,
+        s,
+        `Invalid number, unexpected digit after 0: ${x(
+          n,
+          s
+        )}.`
+      );
+  } else
+    s = D(n, s, o), o = i.charCodeAt(s);
+  if (o === 46 && (c = !0, o = i.charCodeAt(++s), s = D(n, s, o), o = i.charCodeAt(s)), (o === 69 || o === 101) && (c = !0, o = i.charCodeAt(++s), (o === 43 || o === 45) && (o = i.charCodeAt(++s)), s = D(n, s, o), o = i.charCodeAt(s)), o === 46 || g(o))
+    throw u(
+      n.source,
+      s,
+      `Invalid number, expected digit but got: ${x(
+        n,
+        s
+      )}.`
+    );
+  return h(
+    n,
+    c ? r.FLOAT : r.INT,
+    t,
+    s,
+    i.slice(t, s)
+  );
+}
+function D(n, t, e) {
+  if (!k(e))
+    throw u(
+      n.source,
+      t,
+      `Invalid number, expected digit but got: ${x(
+        n,
+        t
+      )}.`
+    );
+  const i = n.source.body;
+  let s = t + 1;
+  for (; k(i.charCodeAt(s)); )
+    ++s;
+  return s;
+}
+function H(n, t) {
+  const e = n.source.body, i = e.length;
+  let s = t + 1, o = s, c = "";
+  for (; s < i; ) {
+    const p = e.charCodeAt(s);
+    if (p === 34)
+      return c += e.slice(o, s), h(n, r.STRING, t, s + 1, c);
+    if (p === 92) {
+      c += e.slice(o, s);
+      const d = e.charCodeAt(s + 1) === 117 ? e.charCodeAt(s + 2) === 123 ? W(n, s) : Z(n, s) : ee(n, s);
+      c += d.value, s += d.size, o = s;
+      continue;
+    }
+    if (p === 10 || p === 13)
+      break;
+    if (E(p))
+      ++s;
+    else if (_(e, s))
+      s += 2;
+    else
+      throw u(
+        n.source,
+        s,
+        `Invalid character within String: ${x(
+          n,
+          s
+        )}.`
+      );
+  }
+  throw u(n.source, s, "Unterminated string.");
+}
+function W(n, t) {
+  const e = n.source.body;
+  let i = 0, s = 3;
+  for (; s < 12; ) {
+    const o = e.charCodeAt(t + s++);
+    if (o === 125) {
+      if (s < 5 || !E(i))
+        break;
+      return {
+        value: String.fromCodePoint(i),
+        size: s
+      };
+    }
+    if (i = i << 4 | m(o), i < 0)
+      break;
+  }
+  throw u(
+    n.source,
+    t,
+    `Invalid Unicode escape sequence: "${e.slice(
+      t,
+      t + s
+    )}".`
+  );
+}
+function Z(n, t) {
+  const e = n.source.body, i = C(e, t + 2);
+  if (E(i))
+    return {
+      value: String.fromCodePoint(i),
+      size: 6
+    };
+  if (S(i) && e.charCodeAt(t + 6) === 92 && e.charCodeAt(t + 7) === 117) {
+    const s = C(e, t + 8);
+    if (w(s))
+      return {
+        value: String.fromCodePoint(i, s),
+        size: 12
+      };
+  }
+  throw u(
+    n.source,
+    t,
+    `Invalid Unicode escape sequence: "${e.slice(t, t + 6)}".`
+  );
+}
+function C(n, t) {
+  return m(n.charCodeAt(t)) << 12 | m(n.charCodeAt(t + 1)) << 8 | m(n.charCodeAt(t + 2)) << 4 | m(n.charCodeAt(t + 3));
+}
+function m(n) {
+  return n >= 48 && n <= 57 ? n - 48 : n >= 65 && n <= 70 ? n - 55 : n >= 97 && n <= 102 ? n - 87 : -1;
+}
+function ee(n, t) {
+  const e = n.source.body;
+  switch (e.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 u(
+    n.source,
+    t,
+    `Invalid character escape sequence: "${e.slice(
+      t,
+      t + 2
+    )}".`
+  );
+}
+function te(n, t) {
+  const e = n.source.body, i = e.length;
+  let s = n.lineStart, o = t + 3, c = o, p = "";
+  const d = [];
+  for (; o < i; ) {
+    const f = e.charCodeAt(o);
+    if (f === 34 && e.charCodeAt(o + 1) === 34 && e.charCodeAt(o + 2) === 34) {
+      p += e.slice(c, o), d.push(p);
+      const l = h(
+        n,
+        r.BLOCK_STRING,
+        t,
+        o + 3,
+        // Return a string of the lines joined with U+000A.
+        B(d).join(`
+`)
+      );
+      return n.line += d.length - 1, n.lineStart = s, l;
+    }
+    if (f === 92 && e.charCodeAt(o + 1) === 34 && e.charCodeAt(o + 2) === 34 && e.charCodeAt(o + 3) === 34) {
+      p += e.slice(c, o), c = o + 1, o += 4;
+      continue;
+    }
+    if (f === 10 || f === 13) {
+      p += e.slice(c, o), d.push(p), f === 13 && e.charCodeAt(o + 1) === 10 ? o += 2 : ++o, p = "", c = o, s = o;
+      continue;
+    }
+    if (E(f))
+      ++o;
+    else if (_(e, o))
+      o += 2;
+    else
+      throw u(
+        n.source,
+        o,
+        `Invalid character within String: ${x(
+          n,
+          o
+        )}.`
+      );
+  }
+  throw u(n.source, o, "Unterminated string.");
+}
+function se(n, t) {
+  const e = n.source.body, i = e.length;
+  let s = t + 1;
+  for (; s < i; ) {
+    const o = e.charCodeAt(s);
+    if (M(o))
+      ++s;
+    else
+      break;
+  }
+  return h(
+    n,
+    r.NAME,
+    t,
+    s,
+    e.slice(t, s)
+  );
+}
+class y {
+  /** The GraphQL source text. */
+  /** Name used in diagnostics for this source, such as a file path or request name. */
+  /** One-indexed line and column where this source begins. */
+  /**
+   * Creates a Source instance.
+   * @param body - The GraphQL source text.
+   * @param name - Name used in diagnostics for this source.
+   * @param locationOffset - One-indexed line and column where this source begins.
+   * @example
+   * ```ts
+   * import { Source } from 'graphql/language';
+   *
+   * const source = new Source(
+   *   'type Query { greeting: String }',
+   *   'schema.graphql',
+   *   { line: 10, column: 1 },
+   * );
+   *
+   * source.body; // => 'type Query { greeting: String }'
+   * source.name; // => 'schema.graphql'
+   * source.locationOffset; // => { line: 10, column: 1 }
+   * ```
+   */
+  constructor(t, e = "GraphQL request", i = {
+    line: 1,
+    column: 1
+  }) {
+    typeof t == "string" || A(!1, `Body must be a string. Received: ${U(t)}.`), this.body = t, this.name = e, this.locationOffset = i, this.locationOffset.line > 0 || A(
+      !1,
+      "line in locationOffset is 1-indexed and must be positive."
+    ), this.locationOffset.column > 0 || A(
+      !1,
+      "column in locationOffset is 1-indexed and must be positive."
+    );
+  }
+  /**
+   * Returns the value used by `Object.prototype.toString`.
+   * @returns The built-in string tag for this object.
+   */
+  get [Symbol.toStringTag]() {
+    return "Source";
+  }
+}
+function ne(n) {
+  return V(n, y);
+}
+function ie(n, t) {
+  const e = new re(n, t), i = e.parseDocument();
+  return Object.defineProperty(i, "tokenCount", {
+    enumerable: !1,
+    value: e.tokenCount
+  }), i;
+}
+class re {
+  constructor(t, e = {}) {
+    const { lexer: i, ...s } = e;
+    if (i)
+      this._lexer = i;
+    else {
+      const o = ne(t) ? t : new y(t);
+      this._lexer = new q(o);
+    }
+    this._options = s, this._tokenCounter = 0;
+  }
+  get tokenCount() {
+    return this._tokenCounter;
+  }
+  /**
+   * Converts a name lex token into a name parse node.
+   *
+   * @internal
+   */
+  parseName() {
+    const t = this.expectToken(r.NAME);
+    return this.node(t, {
+      kind: a.NAME,
+      value: t.value
+    });
+  }
+  // Implements the parsing rules in the Document section.
+  /**
+   * Document : Definition+
+   *
+   * @internal
+   */
+  parseDocument() {
+    return this.node(this._lexer.token, {
+      kind: a.DOCUMENT,
+      definitions: this.many(
+        r.SOF,
+        this.parseDefinition,
+        r.EOF
+      )
+    });
+  }
+  /**
+   * Definition :
+   *   - ExecutableDefinition
+   *   - TypeSystemDefinition
+   *   - TypeSystemExtension
+   *
+   * ExecutableDefinition :
+   *   - OperationDefinition
+   *   - FragmentDefinition
+   *
+   * TypeSystemDefinition :
+   *   - SchemaDefinition
+   *   - TypeDefinition
+   *   - DirectiveDefinition
+   *
+   * TypeDefinition :
+   *   - ScalarTypeDefinition
+   *   - ObjectTypeDefinition
+   *   - InterfaceTypeDefinition
+   *   - UnionTypeDefinition
+   *   - EnumTypeDefinition
+   *   - InputObjectTypeDefinition
+   *
+   * @internal
+   */
+  parseDefinition() {
+    if (this.peek(r.BRACE_L))
+      return this.parseOperationDefinition();
+    const t = this.peekDescription(), e = t ? this._lexer.lookahead() : this._lexer.token;
+    if (t && e.kind === r.BRACE_L)
+      throw u(
+        this._lexer.source,
+        this._lexer.token.start,
+        "Unexpected description, descriptions are not supported on shorthand queries."
+      );
+    if (e.kind === r.NAME) {
+      switch (e.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();
+      }
+      switch (e.value) {
+        case "query":
+        case "mutation":
+        case "subscription":
+          return this.parseOperationDefinition();
+        case "fragment":
+          return this.parseFragmentDefinition();
+      }
+      if (t)
+        throw u(
+          this._lexer.source,
+          this._lexer.token.start,
+          "Unexpected description, only GraphQL definitions support descriptions."
+        );
+      if (e.value === "extend")
+        return this.parseTypeSystemExtension();
+    }
+    throw this.unexpected(e);
+  }
+  // Implements the parsing rules in the Operations section.
+  /**
+   * OperationDefinition :
+   *  - SelectionSet
+   *  - OperationType Name? VariableDefinitions? Directives? SelectionSet
+   *
+   * @internal
+   */
+  parseOperationDefinition() {
+    const t = this._lexer.token;
+    if (this.peek(r.BRACE_L))
+      return this.node(t, {
+        kind: a.OPERATION_DEFINITION,
+        operation: T.QUERY,
+        description: void 0,
+        name: void 0,
+        variableDefinitions: [],
+        directives: [],
+        selectionSet: this.parseSelectionSet()
+      });
+    const e = this.parseDescription(), i = this.parseOperationType();
+    let s;
+    return this.peek(r.NAME) && (s = this.parseName()), this.node(t, {
+      kind: a.OPERATION_DEFINITION,
+      operation: i,
+      description: e,
+      name: s,
+      variableDefinitions: this.parseVariableDefinitions(),
+      directives: this.parseDirectives(!1),
+      selectionSet: this.parseSelectionSet()
+    });
+  }
+  /**
+   * OperationType : one of query mutation subscription
+   *
+   * @internal
+   */
+  parseOperationType() {
+    const t = this.expectToken(r.NAME);
+    switch (t.value) {
+      case "query":
+        return T.QUERY;
+      case "mutation":
+        return T.MUTATION;
+      case "subscription":
+        return T.SUBSCRIPTION;
+    }
+    throw this.unexpected(t);
+  }
+  /**
+   * VariableDefinitions : ( VariableDefinition+ )
+   *
+   * @internal
+   */
+  parseVariableDefinitions() {
+    return this.optionalMany(
+      r.PAREN_L,
+      this.parseVariableDefinition,
+      r.PAREN_R
+    );
+  }
+  /**
+   * VariableDefinition : Variable : Type DefaultValue? Directives[Const]?
+   *
+   * @internal
+   */
+  parseVariableDefinition() {
+    return this.node(this._lexer.token, {
+      kind: a.VARIABLE_DEFINITION,
+      description: this.parseDescription(),
+      variable: this.parseVariable(),
+      type: (this.expectToken(r.COLON), this.parseTypeReference()),
+      defaultValue: this.expectOptionalToken(r.EQUALS) ? this.parseConstValueLiteral() : void 0,
+      directives: this.parseConstDirectives()
+    });
+  }
+  /**
+   * Variable : $ Name
+   *
+   * @internal
+   */
+  parseVariable() {
+    const t = this._lexer.token;
+    return this.expectToken(r.DOLLAR), this.node(t, {
+      kind: a.VARIABLE,
+      name: this.parseName()
+    });
+  }
+  /**
+   * ```
+   * SelectionSet : { Selection+ }
+   * ```
+   *
+   * @internal
+   */
+  parseSelectionSet() {
+    return this.node(this._lexer.token, {
+      kind: a.SELECTION_SET,
+      selections: this.many(
+        r.BRACE_L,
+        this.parseSelection,
+        r.BRACE_R
+      )
+    });
+  }
+  /**
+   * Selection :
+   *   - Field
+   *   - FragmentSpread
+   *   - InlineFragment
+   *
+   * @internal
+   */
+  parseSelection() {
+    return this.peek(r.SPREAD) ? this.parseFragment() : this.parseField();
+  }
+  /**
+   * Field : Alias? Name Arguments? Directives? SelectionSet?
+   *
+   * Alias : Name :
+   *
+   * @internal
+   */
+  parseField() {
+    const t = this._lexer.token, e = this.parseName();
+    let i, s;
+    return this.expectOptionalToken(r.COLON) ? (i = e, s = this.parseName()) : s = e, this.node(t, {
+      kind: a.FIELD,
+      alias: i,
+      name: s,
+      arguments: this.parseArguments(!1),
+      directives: this.parseDirectives(!1),
+      selectionSet: this.peek(r.BRACE_L) ? this.parseSelectionSet() : void 0
+    });
+  }
+  /**
+   * Arguments[Const] : ( Argument[?Const]+ )
+   *
+   * @internal
+   */
+  parseArguments(t) {
+    const e = t ? this.parseConstArgument : this.parseArgument;
+    return this.optionalMany(r.PAREN_L, e, r.PAREN_R);
+  }
+  /**
+   * Argument[Const] : Name : Value[?Const]
+   *
+   * @internal
+   */
+  parseArgument(t = !1) {
+    const e = this._lexer.token, i = this.parseName();
+    return this.expectToken(r.COLON), this.node(e, {
+      kind: a.ARGUMENT,
+      name: i,
+      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
+   *
+   * @internal
+   */
+  parseFragment() {
+    const t = this._lexer.token;
+    this.expectToken(r.SPREAD);
+    const e = this.expectOptionalKeyword("on");
+    return !e && this.peek(r.NAME) ? this.node(t, {
+      kind: a.FRAGMENT_SPREAD,
+      name: this.parseFragmentName(),
+      directives: this.parseDirectives(!1)
+    }) : this.node(t, {
+      kind: a.INLINE_FRAGMENT,
+      typeCondition: e ? this.parseNamedType() : void 0,
+      directives: this.parseDirectives(!1),
+      selectionSet: this.parseSelectionSet()
+    });
+  }
+  /**
+   * FragmentDefinition :
+   *   - fragment FragmentName on TypeCondition Directives? SelectionSet
+   *
+   * TypeCondition : NamedType
+   *
+   * @internal
+   */
+  parseFragmentDefinition() {
+    const t = this._lexer.token, e = this.parseDescription();
+    return this.expectKeyword("fragment"), this._options.allowLegacyFragmentVariables === !0 ? this.node(t, {
+      kind: a.FRAGMENT_DEFINITION,
+      description: e,
+      name: this.parseFragmentName(),
+      variableDefinitions: this.parseVariableDefinitions(),
+      typeCondition: (this.expectKeyword("on"), this.parseNamedType()),
+      directives: this.parseDirectives(!1),
+      selectionSet: this.parseSelectionSet()
+    }) : this.node(t, {
+      kind: a.FRAGMENT_DEFINITION,
+      description: e,
+      name: this.parseFragmentName(),
+      typeCondition: (this.expectKeyword("on"), this.parseNamedType()),
+      directives: this.parseDirectives(!1),
+      selectionSet: this.parseSelectionSet()
+    });
+  }
+  /**
+   * FragmentName : Name but not `on`
+   *
+   * @internal
+   */
+  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`
+   *
+   * @internal
+   */
+  parseValueLiteral(t) {
+    const e = this._lexer.token;
+    switch (e.kind) {
+      case r.BRACKET_L:
+        return this.parseList(t);
+      case r.BRACE_L:
+        return this.parseObject(t);
+      case r.INT:
+        return this.advanceLexer(), this.node(e, {
+          kind: a.INT,
+          value: e.value
+        });
+      case r.FLOAT:
+        return this.advanceLexer(), this.node(e, {
+          kind: a.FLOAT,
+          value: e.value
+        });
+      case r.STRING:
+      case r.BLOCK_STRING:
+        return this.parseStringLiteral();
+      case r.NAME:
+        switch (this.advanceLexer(), e.value) {
+          case "true":
+            return this.node(e, {
+              kind: a.BOOLEAN,
+              value: !0
+            });
+          case "false":
+            return this.node(e, {
+              kind: a.BOOLEAN,
+              value: !1
+            });
+          case "null":
+            return this.node(e, {
+              kind: a.NULL
+            });
+          default:
+            return this.node(e, {
+              kind: a.ENUM,
+              value: e.value
+            });
+        }
+      case r.DOLLAR:
+        if (t)
+          if (this.expectToken(r.DOLLAR), this._lexer.token.kind === r.NAME) {
+            const i = this._lexer.token.value;
+            throw u(
+              this._lexer.source,
+              e.start,
+              `Unexpected variable "$${i}" in constant value.`
+            );
+          } else
+            throw this.unexpected(e);
+        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: a.STRING,
+      value: t.value,
+      block: t.kind === r.BLOCK_STRING
+    });
+  }
+  /**
+   * ListValue[Const] :
+   *   - [ ]
+   *   - [ Value[?Const]+ ]
+   *
+   * @internal
+   */
+  parseList(t) {
+    const e = () => this.parseValueLiteral(t);
+    return this.node(this._lexer.token, {
+      kind: a.LIST,
+      values: this.any(r.BRACKET_L, e, r.BRACKET_R)
+    });
+  }
+  /**
+   * ```
+   * ObjectValue[Const] :
+   *   - { }
+   *   - { ObjectField[?Const]+ }
+   * ```
+   *
+   * @internal
+   */
+  parseObject(t) {
+    const e = () => this.parseObjectField(t);
+    return this.node(this._lexer.token, {
+      kind: a.OBJECT,
+      fields: this.any(r.BRACE_L, e, r.BRACE_R)
+    });
+  }
+  /**
+   * ObjectField[Const] : Name : Value[?Const]
+   *
+   * @internal
+   */
+  parseObjectField(t) {
+    const e = this._lexer.token, i = this.parseName();
+    return this.expectToken(r.COLON), this.node(e, {
+      kind: a.OBJECT_FIELD,
+      name: i,
+      value: this.parseValueLiteral(t)
+    });
+  }
+  // Implements the parsing rules in the Directives section.
+  /**
+   * Directives[Const] : Directive[?Const]+
+   *
+   * @internal
+   */
+  parseDirectives(t) {
+    const e = [];
+    for (; this.peek(r.AT); )
+      e.push(this.parseDirective(t));
+    return e;
+  }
+  parseConstDirectives() {
+    return this.parseDirectives(!0);
+  }
+  /**
+   * ```
+   * Directive[Const] : @ Name Arguments[?Const]?
+   * ```
+   *
+   * @internal
+   */
+  parseDirective(t) {
+    const e = this._lexer.token;
+    return this.expectToken(r.AT), this.node(e, {
+      kind: a.DIRECTIVE,
+      name: this.parseName(),
+      arguments: this.parseArguments(t)
+    });
+  }
+  // Implements the parsing rules in the Types section.
+  /**
+   * Type :
+   *   - NamedType
+   *   - ListType
+   *   - NonNullType
+   *
+   * @internal
+   */
+  parseTypeReference() {
+    const t = this._lexer.token;
+    let e;
+    if (this.expectOptionalToken(r.BRACKET_L)) {
+      const i = this.parseTypeReference();
+      this.expectToken(r.BRACKET_R), e = this.node(t, {
+        kind: a.LIST_TYPE,
+        type: i
+      });
+    } else
+      e = this.parseNamedType();
+    return this.expectOptionalToken(r.BANG) ? this.node(t, {
+      kind: a.NON_NULL_TYPE,
+      type: e
+    }) : e;
+  }
+  /**
+   * NamedType : Name
+   *
+   * @internal
+   */
+  parseNamedType() {
+    return this.node(this._lexer.token, {
+      kind: a.NAMED_TYPE,
+      name: this.parseName()
+    });
+  }
+  // Implements the parsing rules in the Type Definition section.
+  peekDescription() {
+    return this.peek(r.STRING) || this.peek(r.BLOCK_STRING);
+  }
+  /**
+   * Description : StringValue
+   *
+   * @internal
+   */
+  parseDescription() {
+    if (this.peekDescription())
+      return this.parseStringLiteral();
+  }
+  /**
+   * ```
+   * SchemaDefinition : Description? schema Directives[Const]? { OperationTypeDefinition+ }
+   * ```
+   *
+   * @internal
+   */
+  parseSchemaDefinition() {
+    const t = this._lexer.token, e = this.parseDescription();
+    this.expectKeyword("schema");
+    const i = this.parseConstDirectives(), s = this.many(
+      r.BRACE_L,
+      this.parseOperationTypeDefinition,
+      r.BRACE_R
+    );
+    return this.node(t, {
+      kind: a.SCHEMA_DEFINITION,
+      description: e,
+      directives: i,
+      operationTypes: s
+    });
+  }
+  /**
+   * OperationTypeDefinition : OperationType : NamedType
+   *
+   * @internal
+   */
+  parseOperationTypeDefinition() {
+    const t = this._lexer.token, e = this.parseOperationType();
+    this.expectToken(r.COLON);
+    const i = this.parseNamedType();
+    return this.node(t, {
+      kind: a.OPERATION_TYPE_DEFINITION,
+      operation: e,
+      type: i
+    });
+  }
+  /**
+   * ScalarTypeDefinition : Description? scalar Name Directives[Const]?
+   *
+   * @internal
+   */
+  parseScalarTypeDefinition() {
+    const t = this._lexer.token, e = this.parseDescription();
+    this.expectKeyword("scalar");
+    const i = this.parseName(), s = this.parseConstDirectives();
+    return this.node(t, {
+      kind: a.SCALAR_TYPE_DEFINITION,
+      description: e,
+      name: i,
+      directives: s
+    });
+  }
+  /**
+   * ObjectTypeDefinition :
+   *   Description?
+   *   type Name ImplementsInterfaces? Directives[Const]? FieldsDefinition?
+   *
+   * @internal
+   */
+  parseObjectTypeDefinition() {
+    const t = this._lexer.token, e = this.parseDescription();
+    this.expectKeyword("type");
+    const i = this.parseName(), s = this.parseImplementsInterfaces(), o = this.parseConstDirectives(), c = this.parseFieldsDefinition();
+    return this.node(t, {
+      kind: a.OBJECT_TYPE_DEFINITION,
+      description: e,
+      name: i,
+      interfaces: s,
+      directives: o,
+      fields: c
+    });
+  }
+  /**
+   * ImplementsInterfaces :
+   *   - implements `&`? NamedType
+   *   - ImplementsInterfaces & NamedType
+   *
+   * @internal
+   */
+  parseImplementsInterfaces() {
+    return this.expectOptionalKeyword("implements") ? this.delimitedMany(r.AMP, this.parseNamedType) : [];
+  }
+  /**
+   * ```
+   * FieldsDefinition : { FieldDefinition+ }
+   * ```
+   *
+   * @internal
+   */
+  parseFieldsDefinition() {
+    return this.optionalMany(
+      r.BRACE_L,
+      this.parseFieldDefinition,
+      r.BRACE_R
+    );
+  }
+  /**
+   * FieldDefinition :
+   *   - Description? Name ArgumentsDefinition? : Type Directives[Const]?
+   *
+   * @internal
+   */
+  parseFieldDefinition() {
+    const t = this._lexer.token, e = this.parseDescription(), i = this.parseName(), s = this.parseArgumentDefs();
+    this.expectToken(r.COLON);
+    const o = this.parseTypeReference(), c = this.parseConstDirectives();
+    return this.node(t, {
+      kind: a.FIELD_DEFINITION,
+      description: e,
+      name: i,
+      arguments: s,
+      type: o,
+      directives: c
+    });
+  }
+  /**
+   * ArgumentsDefinition : ( InputValueDefinition+ )
+   *
+   * @internal
+   */
+  parseArgumentDefs() {
+    return this.optionalMany(
+      r.PAREN_L,
+      this.parseInputValueDef,
+      r.PAREN_R
+    );
+  }
+  /**
+   * InputValueDefinition :
+   *   - Description? Name : Type DefaultValue? Directives[Const]?
+   *
+   * @internal
+   */
+  parseInputValueDef() {
+    const t = this._lexer.token, e = this.parseDescription(), i = this.parseName();
+    this.expectToken(r.COLON);
+    const s = this.parseTypeReference();
+    let o;
+    this.expectOptionalToken(r.EQUALS) && (o = this.parseConstValueLiteral());
+    const c = this.parseConstDirectives();
+    return this.node(t, {
+      kind: a.INPUT_VALUE_DEFINITION,
+      description: e,
+      name: i,
+      type: s,
+      defaultValue: o,
+      directives: c
+    });
+  }
+  /**
+   * InterfaceTypeDefinition :
+   *   - Description? interface Name Directives[Const]? FieldsDefinition?
+   *
+   * @internal
+   */
+  parseInterfaceTypeDefinition() {
+    const t = this._lexer.token, e = this.parseDescription();
+    this.expectKeyword("interface");
+    const i = this.parseName(), s = this.parseImplementsInterfaces(), o = this.parseConstDirectives(), c = this.parseFieldsDefinition();
+    return this.node(t, {
+      kind: a.INTERFACE_TYPE_DEFINITION,
+      description: e,
+      name: i,
+      interfaces: s,
+      directives: o,
+      fields: c
+    });
+  }
+  /**
+   * UnionTypeDefinition :
+   *   - Description? union Name Directives[Const]? UnionMemberTypes?
+   *
+   * @internal
+   */
+  parseUnionTypeDefinition() {
+    const t = this._lexer.token, e = this.parseDescription();
+    this.expectKeyword("union");
+    const i = this.parseName(), s = this.parseConstDirectives(), o = this.parseUnionMemberTypes();
+    return this.node(t, {
+      kind: a.UNION_TYPE_DEFINITION,
+      description: e,
+      name: i,
+      directives: s,
+      types: o
+    });
+  }
+  /**
+   * UnionMemberTypes :
+   *   - = `|`? NamedType
+   *   - UnionMemberTypes | NamedType
+   *
+   * @internal
+   */
+  parseUnionMemberTypes() {
+    return this.expectOptionalToken(r.EQUALS) ? this.delimitedMany(r.PIPE, this.parseNamedType) : [];
+  }
+  /**
+   * EnumTypeDefinition :
+   *   - Description? enum Name Directives[Const]? EnumValuesDefinition?
+   *
+   * @internal
+   */
+  parseEnumTypeDefinition() {
+    const t = this._lexer.token, e = this.parseDescription();
+    this.expectKeyword("enum");
+    const i = this.parseName(), s = this.parseConstDirectives(), o = this.parseEnumValuesDefinition();
+    return this.node(t, {
+      kind: a.ENUM_TYPE_DEFINITION,
+      description: e,
+      name: i,
+      directives: s,
+      values: o
+    });
+  }
+  /**
+   * ```
+   * EnumValuesDefinition : { EnumValueDefinition+ }
+   * ```
+   *
+   * @internal
+   */
+  parseEnumValuesDefinition() {
+    return this.optionalMany(
+      r.BRACE_L,
+      this.parseEnumValueDefinition,
+      r.BRACE_R
+    );
+  }
+  /**
+   * EnumValueDefinition : Description? EnumValue Directives[Const]?
+   *
+   * @internal
+   */
+  parseEnumValueDefinition() {
+    const t = this._lexer.token, e = this.parseDescription(), i = this.parseEnumValueName(), s = this.parseConstDirectives();
+    return this.node(t, {
+      kind: a.ENUM_VALUE_DEFINITION,
+      description: e,
+      name: i,
+      directives: s
+    });
+  }
+  /**
+   * EnumValue : Name but not `true`, `false` or `null`
+   *
+   * @internal
+   */
+  parseEnumValueName() {
+    if (this._lexer.token.value === "true" || this._lexer.token.value === "false" || this._lexer.token.value === "null")
+      throw u(
+        this._lexer.source,
+        this._lexer.token.start,
+        `${N(
+          this._lexer.token
+        )} is reserved and cannot be used for an enum value.`
+      );
+    return this.parseName();
+  }
+  /**
+   * InputObjectTypeDefinition :
+   *   - Description? input Name Directives[Const]? InputFieldsDefinition?
+   *
+   * @internal
+   */
+  parseInputObjectTypeDefinition() {
+    const t = this._lexer.token, e = this.parseDescription();
+    this.expectKeyword("input");
+    const i = this.parseName(), s = this.parseConstDirectives(), o = this.parseInputFieldsDefinition();
+    return this.node(t, {
+      kind: a.INPUT_OBJECT_TYPE_DEFINITION,
+      description: e,
+      name: i,
+      directives: s,
+      fields: o
+    });
+  }
+  /**
+   * ```
+   * InputFieldsDefinition : { InputValueDefinition+ }
+   * ```
+   *
+   * @internal
+   */
+  parseInputFieldsDefinition() {
+    return this.optionalMany(
+      r.BRACE_L,
+      this.parseInputValueDef,
+      r.BRACE_R
+    );
+  }
+  /**
+   * TypeSystemExtension :
+   *   - SchemaExtension
+   *   - TypeExtension
+   *
+   * TypeExtension :
+   *   - ScalarTypeExtension
+   *   - ObjectTypeExtension
+   *   - InterfaceTypeExtension
+   *   - UnionTypeExtension
+   *   - EnumTypeExtension
+   *   - InputObjectTypeDefinition
+   *   - DirectiveDefinitionExtension
+   *
+   * @internal
+   */
+  parseTypeSystemExtension() {
+    const t = this._lexer.lookahead();
+    if (t.kind === r.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();
+        case "directive":
+          if (this._options.experimentalDirectivesOnDirectiveDefinitions)
+            return this.parseDirectiveDefinitionExtension();
+          break;
+      }
+    throw this.unexpected(t);
+  }
+  /**
+   * ```
+   * SchemaExtension :
+   *  - extend schema Directives[Const]? { OperationTypeDefinition+ }
+   *  - extend schema Directives[Const]
+   * ```
+   *
+   * @internal
+   */
+  parseSchemaExtension() {
+    const t = this._lexer.token;
+    this.expectKeyword("extend"), this.expectKeyword("schema");
+    const e = this.parseConstDirectives(), i = this.optionalMany(
+      r.BRACE_L,
+      this.parseOperationTypeDefinition,
+      r.BRACE_R
+    );
+    if (e.length === 0 && i.length === 0)
+      throw this.unexpected();
+    return this.node(t, {
+      kind: a.SCHEMA_EXTENSION,
+      directives: e,
+      operationTypes: i
+    });
+  }
+  /**
+   * ScalarTypeExtension :
+   *   - extend scalar Name Directives[Const]
+   *
+   * @internal
+   */
+  parseScalarTypeExtension() {
+    const t = this._lexer.token;
+    this.expectKeyword("extend"), this.expectKeyword("scalar");
+    const e = this.parseName(), i = this.parseConstDirectives();
+    if (i.length === 0)
+      throw this.unexpected();
+    return this.node(t, {
+      kind: a.SCALAR_TYPE_EXTENSION,
+      name: e,
+      directives: i
+    });
+  }
+  /**
+   * ObjectTypeExtension :
+   *  - extend type Name ImplementsInterfaces? Directives[Const]? FieldsDefinition
+   *  - extend type Name ImplementsInterfaces? Directives[Const]
+   *  - extend type Name ImplementsInterfaces
+   *
+   * @internal
+   */
+  parseObjectTypeExtension() {
+    const t = this._lexer.token;
+    this.expectKeyword("extend"), this.expectKeyword("type");
+    const e = this.parseName(), i = this.parseImplementsInterfaces(), s = this.parseConstDirectives(), o = this.parseFieldsDefinition();
+    if (i.length === 0 && s.length === 0 && o.length === 0)
+      throw this.unexpected();
+    return this.node(t, {
+      kind: a.OBJECT_TYPE_EXTENSION,
+      name: e,
+      interfaces: i,
+      directives: s,
+      fields: o
+    });
+  }
+  /**
+   * InterfaceTypeExtension :
+   *  - extend interface Name ImplementsInterfaces? Directives[Const]? FieldsDefinition
+   *  - extend interface Name ImplementsInterfaces? Directives[Const]
+   *  - extend interface Name ImplementsInterfaces
+   *
+   * @internal
+   */
+  parseInterfaceTypeExtension() {
+    const t = this._lexer.token;
+    this.expectKeyword("extend"), this.expectKeyword("interface");
+    const e = this.parseName(), i = this.parseImplementsInterfaces(), s = this.parseConstDirectives(), o = this.parseFieldsDefinition();
+    if (i.length === 0 && s.length === 0 && o.length === 0)
+      throw this.unexpected();
+    return this.node(t, {
+      kind: a.INTERFACE_TYPE_EXTENSION,
+      name: e,
+      interfaces: i,
+      directives: s,
+      fields: o
+    });
+  }
+  /**
+   * UnionTypeExtension :
+   *   - extend union Name Directives[Const]? UnionMemberTypes
+   *   - extend union Name Directives[Const]
+   *
+   * @internal
+   */
+  parseUnionTypeExtension() {
+    const t = this._lexer.token;
+    this.expectKeyword("extend"), this.expectKeyword("union");
+    const e = this.parseName(), i = this.parseConstDirectives(), s = this.parseUnionMemberTypes();
+    if (i.length === 0 && s.length === 0)
+      throw this.unexpected();
+    return this.node(t, {
+      kind: a.UNION_TYPE_EXTENSION,
+      name: e,
+      directives: i,
+      types: s
+    });
+  }
+  /**
+   * EnumTypeExtension :
+   *   - extend enum Name Directives[Const]? EnumValuesDefinition
+   *   - extend enum Name Directives[Const]
+   *
+   * @internal
+   */
+  parseEnumTypeExtension() {
+    const t = this._lexer.token;
+    this.expectKeyword("extend"), this.expectKeyword("enum");
+    const e = this.parseName(), i = this.parseConstDirectives(), s = this.parseEnumValuesDefinition();
+    if (i.length === 0 && s.length === 0)
+      throw this.unexpected();
+    return this.node(t, {
+      kind: a.ENUM_TYPE_EXTENSION,
+      name: e,
+      directives: i,
+      values: s
+    });
+  }
+  /**
+   * InputObjectTypeExtension :
+   *   - extend input Name Directives[Const]? InputFieldsDefinition
+   *   - extend input Name Directives[Const]
+   *
+   * @internal
+   */
+  parseInputObjectTypeExtension() {
+    const t = this._lexer.token;
+    this.expectKeyword("extend"), this.expectKeyword("input");
+    const e = this.parseName(), i = this.parseConstDirectives(), s = this.parseInputFieldsDefinition();
+    if (i.length === 0 && s.length === 0)
+      throw this.unexpected();
+    return this.node(t, {
+      kind: a.INPUT_OBJECT_TYPE_EXTENSION,
+      name: e,
+      directives: i,
+      fields: s
+    });
+  }
+  parseDirectiveDefinitionExtension() {
+    const t = this._lexer.token;
+    this.expectKeyword("extend"), this.expectKeyword("directive"), this.expectToken(r.AT);
+    const e = this.parseName(), i = this.parseConstDirectives();
+    if (i.length === 0)
+      throw this.unexpected();
+    return this.node(t, {
+      kind: a.DIRECTIVE_EXTENSION,
+      name: e,
+      directives: i
+    });
+  }
+  /**
+   * ```
+   * DirectiveDefinition :
+   *   - Description? directive @ Name ArgumentsDefinition? `repeatable`? on DirectiveLocations
+   * ```
+   *
+   * @internal
+   */
+  parseDirectiveDefinition() {
+    const t = this._lexer.token, e = this.parseDescription();
+    this.expectKeyword("directive"), this.expectToken(r.AT);
+    const i = this.parseName(), s = this.parseArgumentDefs(), o = this._options.experimentalDirectivesOnDirectiveDefinitions ? this.parseConstDirectives() : [], c = this.expectOptionalKeyword("repeatable");
+    this.expectKeyword("on");
+    const p = this.parseDirectiveLocations();
+    return this.node(t, {
+      kind: a.DIRECTIVE_DEFINITION,
+      description: e,
+      name: i,
+      arguments: s,
+      directives: o,
+      repeatable: c,
+      locations: p
+    });
+  }
+  /**
+   * DirectiveLocations :
+   *   - `|`? DirectiveLocation
+   *   - DirectiveLocations | DirectiveLocation
+   *
+   * @internal
+   */
+  parseDirectiveLocations() {
+    return this.delimitedMany(r.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`
+   *   `DIRECTIVE_DEFINITION`
+   */
+  parseDirectiveLocation() {
+    const t = this._lexer.token, e = this.parseName();
+    if (Object.prototype.hasOwnProperty.call(K, e.value))
+      return e;
+    throw this.unexpected(t);
+  }
+  // Schema Coordinates
+  /**
+   * SchemaCoordinate :
+   *   - Name
+   *   - Name . Name
+   *   - Name . Name ( Name : )
+   *   - \@ Name
+   *   - \@ Name ( Name : )
+   * @returns Parsed schema coordinate AST.
+   * @example
+   * ```ts
+   * import { Parser, Source } from 'graphql/language';
+   *
+   * const typeCoordinate = new Parser(new Source('User.name')).parseSchemaCoordinate();
+   * const directiveCoordinate = new Parser(new Source('@include(if:)')).parseSchemaCoordinate();
+   *
+   * typeCoordinate.name.value; // => 'User'
+   * typeCoordinate.memberName?.value; // => 'name'
+   * directiveCoordinate.name.value; // => 'deprecated'
+   * directiveCoordinate.argumentName?.value; // => 'reason'
+   * ```
+   */
+  parseSchemaCoordinate() {
+    const t = this._lexer.token, e = this.expectOptionalToken(r.AT), i = this.parseName();
+    let s;
+    !e && this.expectOptionalToken(r.DOT) && (s = this.parseName());
+    let o;
+    return (e || s) && this.expectOptionalToken(r.PAREN_L) && (o = this.parseName(), this.expectToken(r.COLON), this.expectToken(r.PAREN_R)), e ? o ? this.node(t, {
+      kind: a.DIRECTIVE_ARGUMENT_COORDINATE,
+      name: i,
+      argumentName: o
+    }) : this.node(t, {
+      kind: a.DIRECTIVE_COORDINATE,
+      name: i
+    }) : s ? o ? this.node(t, {
+      kind: a.ARGUMENT_COORDINATE,
+      name: i,
+      fieldName: s,
+      argumentName: o
+    }) : this.node(t, {
+      kind: a.MEMBER_COORDINATE,
+      name: i,
+      memberName: s
+    }) : this.node(t, {
+      kind: a.TYPE_COORDINATE,
+      name: i
+    });
+  }
+  // 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.
+   *
+   * @internal
+   */
+  node(t, e) {
+    return this._options.noLocation !== !0 && (e.loc = new G(
+      t,
+      this._lexer.lastToken,
+      this._lexer.source
+    )), e;
+  }
+  /**
+   * Determines if the next token is of a given kind
+   *
+   * @internal
+   */
+  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.
+   *
+   * @internal
+   */
+  expectToken(t) {
+    const e = this._lexer.token;
+    if (e.kind === t)
+      return this.advanceLexer(), e;
+    throw u(
+      this._lexer.source,
+      e.start,
+      `Expected ${b(t)}, found ${N(e)}.`
+    );
+  }
+  /**
+   * 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".
+   *
+   * @internal
+   */
+  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.
+   *
+   * @internal
+   */
+  expectKeyword(t) {
+    const e = this._lexer.token;
+    if (e.kind === r.NAME && e.value === t)
+      this.advanceLexer();
+    else
+      throw u(
+        this._lexer.source,
+        e.start,
+        `Expected "${t}", found ${N(e)}.`
+      );
+  }
+  /**
+   * If the next token is a given keyword, return "true" after advancing the lexer.
+   * Otherwise, do not change the parser state and return "false".
+   *
+   * @internal
+   */
+  expectOptionalKeyword(t) {
+    const e = this._lexer.token;
+    return e.kind === r.NAME && e.value === t ? (this.advanceLexer(), !0) : !1;
+  }
+  /**
+   * Helper function for creating an error when an unexpected lexed token is encountered.
+   *
+   * @internal
+   */
+  unexpected(t) {
+    const e = t ?? this._lexer.token;
+    return u(
+      this._lexer.source,
+      e.start,
+      `Unexpected ${N(e)}.`
+    );
+  }
+  /**
+   * 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.
+   *
+   * @internal
+   */
+  any(t, e, i) {
+    this.expectToken(t);
+    const s = [];
+    for (; !this.expectOptionalToken(i); )
+      s.push(e.call(this));
+    return s;
+  }
+  /**
+   * 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.
+   *
+   * @internal
+   */
+  optionalMany(t, e, i) {
+    if (this.expectOptionalToken(t)) {
+      const s = [];
+      do
+        s.push(e.call(this));
+      while (!this.expectOptionalToken(i));
+      return s;
+    }
+    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.
+   *
+   * @internal
+   */
+  many(t, e, i) {
+    this.expectToken(t);
+    const s = [];
+    do
+      s.push(e.call(this));
+    while (!this.expectOptionalToken(i));
+    return s;
+  }
+  /**
+   * 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.
+   *
+   * @internal
+   */
+  delimitedMany(t, e) {
+    this.expectOptionalToken(t);
+    const i = [];
+    do
+      i.push(e.call(this));
+    while (this.expectOptionalToken(t));
+    return i;
+  }
+  advanceLexer() {
+    const { maxTokens: t } = this._options, e = this._lexer.advance();
+    if (e.kind !== r.EOF && (++this._tokenCounter, t !== void 0 && this._tokenCounter > t))
+      throw u(
+        this._lexer.source,
+        e.start,
+        `Document contains more that ${t} tokens. Parsing aborted.`
+      );
+  }
+}
+function N(n) {
+  const t = n.value;
+  return b(n.kind) + (t != null ? ` "${t}"` : "");
+}
+function b(n) {
+  return Q(n) ? `"${n}"` : n;
+}
+function oe(n, t) {
+  const e = {};
+  for (const i of Object.keys(n)) {
+    const s = n[i];
+    if (!s)
+      continue;
+    const o = typeof s == "function" ? s : s.enter, c = typeof s == "function" ? void 0 : s.leave;
+    e[i] = {
+      ...o ? { enter: I(o, t) } : {},
+      ...c ? { leave: I(c, t) } : {}
+    };
+  }
+  return e;
+}
+function I(n, t) {
+  return (e, i, s, o, c) => {
+    n(e, ae(e, t, c));
+  };
+}
+function ae(n, t, e = []) {
+  const { ruleId: i, severity: s, message: o, source: c, config: p, problems: d } = t, f = e.filter((l) => !Array.isArray(l));
+  return {
+    source: c,
+    config: p,
+    ancestors: f,
+    report(l) {
+      const P = l.node ?? n, O = l.loc ?? ce(P), F = {
+        source: c,
+        pointer: void 0,
+        start: O?.start ?? { line: 1, col: 1 },
+        end: O?.end
+      };
+      d.push({
+        ruleId: l.ruleId ?? i,
+        severity: l.severity ?? s,
+        message: o ? o.replace("{{message}}", l.message) : l.message,
+        suggest: l.suggest ?? [],
+        location: [F]
+      });
+    }
+  };
+}
+function ce(n) {
+  if (!n?.loc)
+    return;
+  const t = v(n.loc.source, n.loc.start), e = v(n.loc.source, n.loc.end);
+  return {
+    start: { line: t.line, col: t.column },
+    end: { line: e.line, col: e.column }
+  };
+}
+function de(n) {
+  const { document: t, config: e } = n, i = t.source;
+  if (i.body.trim() === "")
+    return [
+      {
+        ruleId: "struct",
+        severity: "error",
+        message: "The GraphQL document is empty. Expected at least one type definition.",
+        suggest: [],
+        location: [{ source: i, pointer: void 0, start: { line: 1, col: 1 } }]
+      }
+    ];
+  let s;
+  try {
+    s = ie(new y(i.body, i.absoluteRef));
+  } catch (d) {
+    if (d instanceof R)
+      return [he(d, i)];
+    throw d;
+  }
+  const o = e.getRulesForSpecVersion("graphql") ?? [], c = $(o, e, "rules", "graphql");
+  return pe({ ast: s, source: i, config: e, rules: c }).map((d) => e.addProblemToIgnore(d));
+}
+function he(n, t) {
+  const e = n.locations?.[0];
+  return {
+    ruleId: "struct",
+    severity: "error",
+    message: n.message,
+    suggest: [],
+    location: [
+      {
+        source: t,
+        pointer: void 0,
+        start: e ? { line: e.line, col: e.column } : { line: 1, col: 1 }
+      }
+    ]
+  };
+}
+function pe(n) {
+  const { ast: t, source: e, config: i, rules: s } = n, o = [], c = s.map(({ ruleId: p, severity: d, message: f, visitor: l }) => oe(l, { ruleId: p, severity: d, message: f, source: e, config: i, problems: o }));
+  return c.length > 0 && Y(t, j(c)), o;
+}
+export {
+  de as lintGraphqlDocument
+};