@ynput/ayon-frontend-shared 0.3.5 → 0.3.6

package/dist/node_modules/graphql/language/parser.es.js

@@ -0,0 +1,1184 @@
+import { syntaxError as c } from "../error/syntaxError.es.js";
+import { OperationTypeNode as h, Location as u } from "./ast.es.js";
+import { DirectiveLocation as x } from "./directiveLocation.es.js";
+import { Kind as r } from "./kinds.es.js";
+import { Lexer as T, isPunctuatorTokenKind as k } from "./lexer.es.js";
+import { isSource as E, Source as m } from "./source.es.js";
+import { TokenKind as i } from "./tokenKind.es.js";
+function A(a, e) {
+  const t = new N(a, e), s = t.parseDocument();
+  return Object.defineProperty(s, "tokenCount", {
+    enumerable: !1,
+    value: t.tokenCount
+  }), s;
+}
+class N {
+  constructor(e, t = {}) {
+    const { lexer: s, ...n } = t;
+    if (s)
+      this._lexer = s;
+    else {
+      const o = E(e) ? e : new m(e);
+      this._lexer = new T(o);
+    }
+    this._options = n, this._tokenCounter = 0;
+  }
+  get tokenCount() {
+    return this._tokenCounter;
+  }
+  /**
+   * Converts a name lex token into a name parse node.
+   */
+  parseName() {
+    const e = this.expectToken(i.NAME);
+    return this.node(e, {
+      kind: r.NAME,
+      value: e.value
+    });
+  }
+  // Implements the parsing rules in the Document section.
+  /**
+   * Document : Definition+
+   */
+  parseDocument() {
+    return this.node(this._lexer.token, {
+      kind: r.DOCUMENT,
+      definitions: this.many(
+        i.SOF,
+        this.parseDefinition,
+        i.EOF
+      )
+    });
+  }
+  /**
+   * Definition :
+   *   - ExecutableDefinition
+   *   - TypeSystemDefinition
+   *   - TypeSystemExtension
+   *
+   * ExecutableDefinition :
+   *   - OperationDefinition
+   *   - FragmentDefinition
+   *
+   * TypeSystemDefinition :
+   *   - SchemaDefinition
+   *   - TypeDefinition
+   *   - DirectiveDefinition
+   *
+   * TypeDefinition :
+   *   - ScalarTypeDefinition
+   *   - ObjectTypeDefinition
+   *   - InterfaceTypeDefinition
+   *   - UnionTypeDefinition
+   *   - EnumTypeDefinition
+   *   - InputObjectTypeDefinition
+   */
+  parseDefinition() {
+    if (this.peek(i.BRACE_L))
+      return this.parseOperationDefinition();
+    const e = this.peekDescription(), t = e ? this._lexer.lookahead() : this._lexer.token;
+    if (e && t.kind === i.BRACE_L)
+      throw c(
+        this._lexer.source,
+        this._lexer.token.start,
+        "Unexpected description, descriptions are not supported on shorthand queries."
+      );
+    if (t.kind === i.NAME) {
+      switch (t.value) {
+        case "schema":
+          return this.parseSchemaDefinition();
+        case "scalar":
+          return this.parseScalarTypeDefinition();
+        case "type":
+          return this.parseObjectTypeDefinition();
+        case "interface":
+          return this.parseInterfaceTypeDefinition();
+        case "union":
+          return this.parseUnionTypeDefinition();
+        case "enum":
+          return this.parseEnumTypeDefinition();
+        case "input":
+          return this.parseInputObjectTypeDefinition();
+        case "directive":
+          return this.parseDirectiveDefinition();
+      }
+      switch (t.value) {
+        case "query":
+        case "mutation":
+        case "subscription":
+          return this.parseOperationDefinition();
+        case "fragment":
+          return this.parseFragmentDefinition();
+      }
+      if (e)
+        throw c(
+          this._lexer.source,
+          this._lexer.token.start,
+          "Unexpected description, only GraphQL definitions support descriptions."
+        );
+      switch (t.value) {
+        case "extend":
+          return this.parseTypeSystemExtension();
+      }
+    }
+    throw this.unexpected(t);
+  }
+  // Implements the parsing rules in the Operations section.
+  /**
+   * OperationDefinition :
+   *  - SelectionSet
+   *  - OperationType Name? VariableDefinitions? Directives? SelectionSet
+   */
+  parseOperationDefinition() {
+    const e = this._lexer.token;
+    if (this.peek(i.BRACE_L))
+      return this.node(e, {
+        kind: r.OPERATION_DEFINITION,
+        operation: h.QUERY,
+        description: void 0,
+        name: void 0,
+        variableDefinitions: [],
+        directives: [],
+        selectionSet: this.parseSelectionSet()
+      });
+    const t = this.parseDescription(), s = this.parseOperationType();
+    let n;
+    return this.peek(i.NAME) && (n = this.parseName()), this.node(e, {
+      kind: r.OPERATION_DEFINITION,
+      operation: s,
+      description: t,
+      name: n,
+      variableDefinitions: this.parseVariableDefinitions(),
+      directives: this.parseDirectives(!1),
+      selectionSet: this.parseSelectionSet()
+    });
+  }
+  /**
+   * OperationType : one of query mutation subscription
+   */
+  parseOperationType() {
+    const e = this.expectToken(i.NAME);
+    switch (e.value) {
+      case "query":
+        return h.QUERY;
+      case "mutation":
+        return h.MUTATION;
+      case "subscription":
+        return h.SUBSCRIPTION;
+    }
+    throw this.unexpected(e);
+  }
+  /**
+   * VariableDefinitions : ( VariableDefinition+ )
+   */
+  parseVariableDefinitions() {
+    return this.optionalMany(
+      i.PAREN_L,
+      this.parseVariableDefinition,
+      i.PAREN_R
+    );
+  }
+  /**
+   * VariableDefinition : Variable : Type DefaultValue? Directives[Const]?
+   */
+  parseVariableDefinition() {
+    return this.node(this._lexer.token, {
+      kind: r.VARIABLE_DEFINITION,
+      description: this.parseDescription(),
+      variable: this.parseVariable(),
+      type: (this.expectToken(i.COLON), this.parseTypeReference()),
+      defaultValue: this.expectOptionalToken(i.EQUALS) ? this.parseConstValueLiteral() : void 0,
+      directives: this.parseConstDirectives()
+    });
+  }
+  /**
+   * Variable : $ Name
+   */
+  parseVariable() {
+    const e = this._lexer.token;
+    return this.expectToken(i.DOLLAR), this.node(e, {
+      kind: r.VARIABLE,
+      name: this.parseName()
+    });
+  }
+  /**
+   * ```
+   * SelectionSet : { Selection+ }
+   * ```
+   */
+  parseSelectionSet() {
+    return this.node(this._lexer.token, {
+      kind: r.SELECTION_SET,
+      selections: this.many(
+        i.BRACE_L,
+        this.parseSelection,
+        i.BRACE_R
+      )
+    });
+  }
+  /**
+   * Selection :
+   *   - Field
+   *   - FragmentSpread
+   *   - InlineFragment
+   */
+  parseSelection() {
+    return this.peek(i.SPREAD) ? this.parseFragment() : this.parseField();
+  }
+  /**
+   * Field : Alias? Name Arguments? Directives? SelectionSet?
+   *
+   * Alias : Name :
+   */
+  parseField() {
+    const e = this._lexer.token, t = this.parseName();
+    let s, n;
+    return this.expectOptionalToken(i.COLON) ? (s = t, n = this.parseName()) : n = t, this.node(e, {
+      kind: r.FIELD,
+      alias: s,
+      name: n,
+      arguments: this.parseArguments(!1),
+      directives: this.parseDirectives(!1),
+      selectionSet: this.peek(i.BRACE_L) ? this.parseSelectionSet() : void 0
+    });
+  }
+  /**
+   * Arguments[Const] : ( Argument[?Const]+ )
+   */
+  parseArguments(e) {
+    const t = e ? this.parseConstArgument : this.parseArgument;
+    return this.optionalMany(i.PAREN_L, t, i.PAREN_R);
+  }
+  /**
+   * Argument[Const] : Name : Value[?Const]
+   */
+  parseArgument(e = !1) {
+    const t = this._lexer.token, s = this.parseName();
+    return this.expectToken(i.COLON), this.node(t, {
+      kind: r.ARGUMENT,
+      name: s,
+      value: this.parseValueLiteral(e)
+    });
+  }
+  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 e = this._lexer.token;
+    this.expectToken(i.SPREAD);
+    const t = this.expectOptionalKeyword("on");
+    return !t && this.peek(i.NAME) ? this.node(e, {
+      kind: r.FRAGMENT_SPREAD,
+      name: this.parseFragmentName(),
+      directives: this.parseDirectives(!1)
+    }) : this.node(e, {
+      kind: r.INLINE_FRAGMENT,
+      typeCondition: t ? this.parseNamedType() : void 0,
+      directives: this.parseDirectives(!1),
+      selectionSet: this.parseSelectionSet()
+    });
+  }
+  /**
+   * FragmentDefinition :
+   *   - fragment FragmentName on TypeCondition Directives? SelectionSet
+   *
+   * TypeCondition : NamedType
+   */
+  parseFragmentDefinition() {
+    const e = this._lexer.token, t = this.parseDescription();
+    return this.expectKeyword("fragment"), this._options.allowLegacyFragmentVariables === !0 ? this.node(e, {
+      kind: r.FRAGMENT_DEFINITION,
+      description: t,
+      name: this.parseFragmentName(),
+      variableDefinitions: this.parseVariableDefinitions(),
+      typeCondition: (this.expectKeyword("on"), this.parseNamedType()),
+      directives: this.parseDirectives(!1),
+      selectionSet: this.parseSelectionSet()
+    }) : this.node(e, {
+      kind: r.FRAGMENT_DEFINITION,
+      description: t,
+      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(e) {
+    const t = this._lexer.token;
+    switch (t.kind) {
+      case i.BRACKET_L:
+        return this.parseList(e);
+      case i.BRACE_L:
+        return this.parseObject(e);
+      case i.INT:
+        return this.advanceLexer(), this.node(t, {
+          kind: r.INT,
+          value: t.value
+        });
+      case i.FLOAT:
+        return this.advanceLexer(), this.node(t, {
+          kind: r.FLOAT,
+          value: t.value
+        });
+      case i.STRING:
+      case i.BLOCK_STRING:
+        return this.parseStringLiteral();
+      case i.NAME:
+        switch (this.advanceLexer(), t.value) {
+          case "true":
+            return this.node(t, {
+              kind: r.BOOLEAN,
+              value: !0
+            });
+          case "false":
+            return this.node(t, {
+              kind: r.BOOLEAN,
+              value: !1
+            });
+          case "null":
+            return this.node(t, {
+              kind: r.NULL
+            });
+          default:
+            return this.node(t, {
+              kind: r.ENUM,
+              value: t.value
+            });
+        }
+      case i.DOLLAR:
+        if (e)
+          if (this.expectToken(i.DOLLAR), this._lexer.token.kind === i.NAME) {
+            const s = this._lexer.token.value;
+            throw c(
+              this._lexer.source,
+              t.start,
+              `Unexpected variable "$${s}" in constant value.`
+            );
+          } else
+            throw this.unexpected(t);
+        return this.parseVariable();
+      default:
+        throw this.unexpected();
+    }
+  }
+  parseConstValueLiteral() {
+    return this.parseValueLiteral(!0);
+  }
+  parseStringLiteral() {
+    const e = this._lexer.token;
+    return this.advanceLexer(), this.node(e, {
+      kind: r.STRING,
+      value: e.value,
+      block: e.kind === i.BLOCK_STRING
+    });
+  }
+  /**
+   * ListValue[Const] :
+   *   - [ ]
+   *   - [ Value[?Const]+ ]
+   */
+  parseList(e) {
+    const t = () => this.parseValueLiteral(e);
+    return this.node(this._lexer.token, {
+      kind: r.LIST,
+      values: this.any(i.BRACKET_L, t, i.BRACKET_R)
+    });
+  }
+  /**
+   * ```
+   * ObjectValue[Const] :
+   *   - { }
+   *   - { ObjectField[?Const]+ }
+   * ```
+   */
+  parseObject(e) {
+    const t = () => this.parseObjectField(e);
+    return this.node(this._lexer.token, {
+      kind: r.OBJECT,
+      fields: this.any(i.BRACE_L, t, i.BRACE_R)
+    });
+  }
+  /**
+   * ObjectField[Const] : Name : Value[?Const]
+   */
+  parseObjectField(e) {
+    const t = this._lexer.token, s = this.parseName();
+    return this.expectToken(i.COLON), this.node(t, {
+      kind: r.OBJECT_FIELD,
+      name: s,
+      value: this.parseValueLiteral(e)
+    });
+  }
+  // Implements the parsing rules in the Directives section.
+  /**
+   * Directives[Const] : Directive[?Const]+
+   */
+  parseDirectives(e) {
+    const t = [];
+    for (; this.peek(i.AT); )
+      t.push(this.parseDirective(e));
+    return t;
+  }
+  parseConstDirectives() {
+    return this.parseDirectives(!0);
+  }
+  /**
+   * ```
+   * Directive[Const] : @ Name Arguments[?Const]?
+   * ```
+   */
+  parseDirective(e) {
+    const t = this._lexer.token;
+    return this.expectToken(i.AT), this.node(t, {
+      kind: r.DIRECTIVE,
+      name: this.parseName(),
+      arguments: this.parseArguments(e)
+    });
+  }
+  // Implements the parsing rules in the Types section.
+  /**
+   * Type :
+   *   - NamedType
+   *   - ListType
+   *   - NonNullType
+   */
+  parseTypeReference() {
+    const e = this._lexer.token;
+    let t;
+    if (this.expectOptionalToken(i.BRACKET_L)) {
+      const s = this.parseTypeReference();
+      this.expectToken(i.BRACKET_R), t = this.node(e, {
+        kind: r.LIST_TYPE,
+        type: s
+      });
+    } else
+      t = this.parseNamedType();
+    return this.expectOptionalToken(i.BANG) ? this.node(e, {
+      kind: r.NON_NULL_TYPE,
+      type: t
+    }) : t;
+  }
+  /**
+   * NamedType : Name
+   */
+  parseNamedType() {
+    return this.node(this._lexer.token, {
+      kind: r.NAMED_TYPE,
+      name: this.parseName()
+    });
+  }
+  // Implements the parsing rules in the Type Definition section.
+  peekDescription() {
+    return this.peek(i.STRING) || this.peek(i.BLOCK_STRING);
+  }
+  /**
+   * Description : StringValue
+   */
+  parseDescription() {
+    if (this.peekDescription())
+      return this.parseStringLiteral();
+  }
+  /**
+   * ```
+   * SchemaDefinition : Description? schema Directives[Const]? { OperationTypeDefinition+ }
+   * ```
+   */
+  parseSchemaDefinition() {
+    const e = this._lexer.token, t = this.parseDescription();
+    this.expectKeyword("schema");
+    const s = this.parseConstDirectives(), n = this.many(
+      i.BRACE_L,
+      this.parseOperationTypeDefinition,
+      i.BRACE_R
+    );
+    return this.node(e, {
+      kind: r.SCHEMA_DEFINITION,
+      description: t,
+      directives: s,
+      operationTypes: n
+    });
+  }
+  /**
+   * OperationTypeDefinition : OperationType : NamedType
+   */
+  parseOperationTypeDefinition() {
+    const e = this._lexer.token, t = this.parseOperationType();
+    this.expectToken(i.COLON);
+    const s = this.parseNamedType();
+    return this.node(e, {
+      kind: r.OPERATION_TYPE_DEFINITION,
+      operation: t,
+      type: s
+    });
+  }
+  /**
+   * ScalarTypeDefinition : Description? scalar Name Directives[Const]?
+   */
+  parseScalarTypeDefinition() {
+    const e = this._lexer.token, t = this.parseDescription();
+    this.expectKeyword("scalar");
+    const s = this.parseName(), n = this.parseConstDirectives();
+    return this.node(e, {
+      kind: r.SCALAR_TYPE_DEFINITION,
+      description: t,
+      name: s,
+      directives: n
+    });
+  }
+  /**
+   * ObjectTypeDefinition :
+   *   Description?
+   *   type Name ImplementsInterfaces? Directives[Const]? FieldsDefinition?
+   */
+  parseObjectTypeDefinition() {
+    const e = this._lexer.token, t = this.parseDescription();
+    this.expectKeyword("type");
+    const s = this.parseName(), n = this.parseImplementsInterfaces(), o = this.parseConstDirectives(), p = this.parseFieldsDefinition();
+    return this.node(e, {
+      kind: r.OBJECT_TYPE_DEFINITION,
+      description: t,
+      name: s,
+      interfaces: n,
+      directives: o,
+      fields: p
+    });
+  }
+  /**
+   * ImplementsInterfaces :
+   *   - implements `&`? NamedType
+   *   - ImplementsInterfaces & NamedType
+   */
+  parseImplementsInterfaces() {
+    return this.expectOptionalKeyword("implements") ? this.delimitedMany(i.AMP, this.parseNamedType) : [];
+  }
+  /**
+   * ```
+   * FieldsDefinition : { FieldDefinition+ }
+   * ```
+   */
+  parseFieldsDefinition() {
+    return this.optionalMany(
+      i.BRACE_L,
+      this.parseFieldDefinition,
+      i.BRACE_R
+    );
+  }
+  /**
+   * FieldDefinition :
+   *   - Description? Name ArgumentsDefinition? : Type Directives[Const]?
+   */
+  parseFieldDefinition() {
+    const e = this._lexer.token, t = this.parseDescription(), s = this.parseName(), n = this.parseArgumentDefs();
+    this.expectToken(i.COLON);
+    const o = this.parseTypeReference(), p = this.parseConstDirectives();
+    return this.node(e, {
+      kind: r.FIELD_DEFINITION,
+      description: t,
+      name: s,
+      arguments: n,
+      type: o,
+      directives: p
+    });
+  }
+  /**
+   * ArgumentsDefinition : ( InputValueDefinition+ )
+   */
+  parseArgumentDefs() {
+    return this.optionalMany(
+      i.PAREN_L,
+      this.parseInputValueDef,
+      i.PAREN_R
+    );
+  }
+  /**
+   * InputValueDefinition :
+   *   - Description? Name : Type DefaultValue? Directives[Const]?
+   */
+  parseInputValueDef() {
+    const e = this._lexer.token, t = this.parseDescription(), s = this.parseName();
+    this.expectToken(i.COLON);
+    const n = this.parseTypeReference();
+    let o;
+    this.expectOptionalToken(i.EQUALS) && (o = this.parseConstValueLiteral());
+    const p = this.parseConstDirectives();
+    return this.node(e, {
+      kind: r.INPUT_VALUE_DEFINITION,
+      description: t,
+      name: s,
+      type: n,
+      defaultValue: o,
+      directives: p
+    });
+  }
+  /**
+   * InterfaceTypeDefinition :
+   *   - Description? interface Name Directives[Const]? FieldsDefinition?
+   */
+  parseInterfaceTypeDefinition() {
+    const e = this._lexer.token, t = this.parseDescription();
+    this.expectKeyword("interface");
+    const s = this.parseName(), n = this.parseImplementsInterfaces(), o = this.parseConstDirectives(), p = this.parseFieldsDefinition();
+    return this.node(e, {
+      kind: r.INTERFACE_TYPE_DEFINITION,
+      description: t,
+      name: s,
+      interfaces: n,
+      directives: o,
+      fields: p
+    });
+  }
+  /**
+   * UnionTypeDefinition :
+   *   - Description? union Name Directives[Const]? UnionMemberTypes?
+   */
+  parseUnionTypeDefinition() {
+    const e = this._lexer.token, t = this.parseDescription();
+    this.expectKeyword("union");
+    const s = this.parseName(), n = this.parseConstDirectives(), o = this.parseUnionMemberTypes();
+    return this.node(e, {
+      kind: r.UNION_TYPE_DEFINITION,
+      description: t,
+      name: s,
+      directives: n,
+      types: o
+    });
+  }
+  /**
+   * UnionMemberTypes :
+   *   - = `|`? NamedType
+   *   - UnionMemberTypes | NamedType
+   */
+  parseUnionMemberTypes() {
+    return this.expectOptionalToken(i.EQUALS) ? this.delimitedMany(i.PIPE, this.parseNamedType) : [];
+  }
+  /**
+   * EnumTypeDefinition :
+   *   - Description? enum Name Directives[Const]? EnumValuesDefinition?
+   */
+  parseEnumTypeDefinition() {
+    const e = this._lexer.token, t = this.parseDescription();
+    this.expectKeyword("enum");
+    const s = this.parseName(), n = this.parseConstDirectives(), o = this.parseEnumValuesDefinition();
+    return this.node(e, {
+      kind: r.ENUM_TYPE_DEFINITION,
+      description: t,
+      name: s,
+      directives: n,
+      values: o
+    });
+  }
+  /**
+   * ```
+   * EnumValuesDefinition : { EnumValueDefinition+ }
+   * ```
+   */
+  parseEnumValuesDefinition() {
+    return this.optionalMany(
+      i.BRACE_L,
+      this.parseEnumValueDefinition,
+      i.BRACE_R
+    );
+  }
+  /**
+   * EnumValueDefinition : Description? EnumValue Directives[Const]?
+   */
+  parseEnumValueDefinition() {
+    const e = this._lexer.token, t = this.parseDescription(), s = this.parseEnumValueName(), n = this.parseConstDirectives();
+    return this.node(e, {
+      kind: r.ENUM_VALUE_DEFINITION,
+      description: t,
+      name: s,
+      directives: n
+    });
+  }
+  /**
+   * 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 c(
+        this._lexer.source,
+        this._lexer.token.start,
+        `${l(
+          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 e = this._lexer.token, t = this.parseDescription();
+    this.expectKeyword("input");
+    const s = this.parseName(), n = this.parseConstDirectives(), o = this.parseInputFieldsDefinition();
+    return this.node(e, {
+      kind: r.INPUT_OBJECT_TYPE_DEFINITION,
+      description: t,
+      name: s,
+      directives: n,
+      fields: o
+    });
+  }
+  /**
+   * ```
+   * InputFieldsDefinition : { InputValueDefinition+ }
+   * ```
+   */
+  parseInputFieldsDefinition() {
+    return this.optionalMany(
+      i.BRACE_L,
+      this.parseInputValueDef,
+      i.BRACE_R
+    );
+  }
+  /**
+   * TypeSystemExtension :
+   *   - SchemaExtension
+   *   - TypeExtension
+   *
+   * TypeExtension :
+   *   - ScalarTypeExtension
+   *   - ObjectTypeExtension
+   *   - InterfaceTypeExtension
+   *   - UnionTypeExtension
+   *   - EnumTypeExtension
+   *   - InputObjectTypeDefinition
+   */
+  parseTypeSystemExtension() {
+    const e = this._lexer.lookahead();
+    if (e.kind === i.NAME)
+      switch (e.value) {
+        case "schema":
+          return this.parseSchemaExtension();
+        case "scalar":
+          return this.parseScalarTypeExtension();
+        case "type":
+          return this.parseObjectTypeExtension();
+        case "interface":
+          return this.parseInterfaceTypeExtension();
+        case "union":
+          return this.parseUnionTypeExtension();
+        case "enum":
+          return this.parseEnumTypeExtension();
+        case "input":
+          return this.parseInputObjectTypeExtension();
+      }
+    throw this.unexpected(e);
+  }
+  /**
+   * ```
+   * SchemaExtension :
+   *  - extend schema Directives[Const]? { OperationTypeDefinition+ }
+   *  - extend schema Directives[Const]
+   * ```
+   */
+  parseSchemaExtension() {
+    const e = this._lexer.token;
+    this.expectKeyword("extend"), this.expectKeyword("schema");
+    const t = this.parseConstDirectives(), s = this.optionalMany(
+      i.BRACE_L,
+      this.parseOperationTypeDefinition,
+      i.BRACE_R
+    );
+    if (t.length === 0 && s.length === 0)
+      throw this.unexpected();
+    return this.node(e, {
+      kind: r.SCHEMA_EXTENSION,
+      directives: t,
+      operationTypes: s
+    });
+  }
+  /**
+   * ScalarTypeExtension :
+   *   - extend scalar Name Directives[Const]
+   */
+  parseScalarTypeExtension() {
+    const e = this._lexer.token;
+    this.expectKeyword("extend"), this.expectKeyword("scalar");
+    const t = this.parseName(), s = this.parseConstDirectives();
+    if (s.length === 0)
+      throw this.unexpected();
+    return this.node(e, {
+      kind: r.SCALAR_TYPE_EXTENSION,
+      name: t,
+      directives: s
+    });
+  }
+  /**
+   * ObjectTypeExtension :
+   *  - extend type Name ImplementsInterfaces? Directives[Const]? FieldsDefinition
+   *  - extend type Name ImplementsInterfaces? Directives[Const]
+   *  - extend type Name ImplementsInterfaces
+   */
+  parseObjectTypeExtension() {
+    const e = this._lexer.token;
+    this.expectKeyword("extend"), this.expectKeyword("type");
+    const t = this.parseName(), s = this.parseImplementsInterfaces(), n = this.parseConstDirectives(), o = this.parseFieldsDefinition();
+    if (s.length === 0 && n.length === 0 && o.length === 0)
+      throw this.unexpected();
+    return this.node(e, {
+      kind: r.OBJECT_TYPE_EXTENSION,
+      name: t,
+      interfaces: s,
+      directives: n,
+      fields: o
+    });
+  }
+  /**
+   * InterfaceTypeExtension :
+   *  - extend interface Name ImplementsInterfaces? Directives[Const]? FieldsDefinition
+   *  - extend interface Name ImplementsInterfaces? Directives[Const]
+   *  - extend interface Name ImplementsInterfaces
+   */
+  parseInterfaceTypeExtension() {
+    const e = this._lexer.token;
+    this.expectKeyword("extend"), this.expectKeyword("interface");
+    const t = this.parseName(), s = this.parseImplementsInterfaces(), n = this.parseConstDirectives(), o = this.parseFieldsDefinition();
+    if (s.length === 0 && n.length === 0 && o.length === 0)
+      throw this.unexpected();
+    return this.node(e, {
+      kind: r.INTERFACE_TYPE_EXTENSION,
+      name: t,
+      interfaces: s,
+      directives: n,
+      fields: o
+    });
+  }
+  /**
+   * UnionTypeExtension :
+   *   - extend union Name Directives[Const]? UnionMemberTypes
+   *   - extend union Name Directives[Const]
+   */
+  parseUnionTypeExtension() {
+    const e = this._lexer.token;
+    this.expectKeyword("extend"), this.expectKeyword("union");
+    const t = this.parseName(), s = this.parseConstDirectives(), n = this.parseUnionMemberTypes();
+    if (s.length === 0 && n.length === 0)
+      throw this.unexpected();
+    return this.node(e, {
+      kind: r.UNION_TYPE_EXTENSION,
+      name: t,
+      directives: s,
+      types: n
+    });
+  }
+  /**
+   * EnumTypeExtension :
+   *   - extend enum Name Directives[Const]? EnumValuesDefinition
+   *   - extend enum Name Directives[Const]
+   */
+  parseEnumTypeExtension() {
+    const e = this._lexer.token;
+    this.expectKeyword("extend"), this.expectKeyword("enum");
+    const t = this.parseName(), s = this.parseConstDirectives(), n = this.parseEnumValuesDefinition();
+    if (s.length === 0 && n.length === 0)
+      throw this.unexpected();
+    return this.node(e, {
+      kind: r.ENUM_TYPE_EXTENSION,
+      name: t,
+      directives: s,
+      values: n
+    });
+  }
+  /**
+   * InputObjectTypeExtension :
+   *   - extend input Name Directives[Const]? InputFieldsDefinition
+   *   - extend input Name Directives[Const]
+   */
+  parseInputObjectTypeExtension() {
+    const e = this._lexer.token;
+    this.expectKeyword("extend"), this.expectKeyword("input");
+    const t = this.parseName(), s = this.parseConstDirectives(), n = this.parseInputFieldsDefinition();
+    if (s.length === 0 && n.length === 0)
+      throw this.unexpected();
+    return this.node(e, {
+      kind: r.INPUT_OBJECT_TYPE_EXTENSION,
+      name: t,
+      directives: s,
+      fields: n
+    });
+  }
+  /**
+   * ```
+   * DirectiveDefinition :
+   *   - Description? directive @ Name ArgumentsDefinition? `repeatable`? on DirectiveLocations
+   * ```
+   */
+  parseDirectiveDefinition() {
+    const e = this._lexer.token, t = this.parseDescription();
+    this.expectKeyword("directive"), this.expectToken(i.AT);
+    const s = this.parseName(), n = this.parseArgumentDefs(), o = this.expectOptionalKeyword("repeatable");
+    this.expectKeyword("on");
+    const p = this.parseDirectiveLocations();
+    return this.node(e, {
+      kind: r.DIRECTIVE_DEFINITION,
+      description: t,
+      name: s,
+      arguments: n,
+      repeatable: o,
+      locations: p
+    });
+  }
+  /**
+   * DirectiveLocations :
+   *   - `|`? DirectiveLocation
+   *   - DirectiveLocations | DirectiveLocation
+   */
+  parseDirectiveLocations() {
+    return this.delimitedMany(i.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 e = this._lexer.token, t = this.parseName();
+    if (Object.prototype.hasOwnProperty.call(x, t.value))
+      return t;
+    throw this.unexpected(e);
+  }
+  // Schema Coordinates
+  /**
+   * SchemaCoordinate :
+   *   - Name
+   *   - Name . Name
+   *   - Name . Name ( Name : )
+   *   - \@ Name
+   *   - \@ Name ( Name : )
+   */
+  parseSchemaCoordinate() {
+    const e = this._lexer.token, t = this.expectOptionalToken(i.AT), s = this.parseName();
+    let n;
+    !t && this.expectOptionalToken(i.DOT) && (n = this.parseName());
+    let o;
+    return (t || n) && this.expectOptionalToken(i.PAREN_L) && (o = this.parseName(), this.expectToken(i.COLON), this.expectToken(i.PAREN_R)), t ? o ? this.node(e, {
+      kind: r.DIRECTIVE_ARGUMENT_COORDINATE,
+      name: s,
+      argumentName: o
+    }) : this.node(e, {
+      kind: r.DIRECTIVE_COORDINATE,
+      name: s
+    }) : n ? o ? this.node(e, {
+      kind: r.ARGUMENT_COORDINATE,
+      name: s,
+      fieldName: n,
+      argumentName: o
+    }) : this.node(e, {
+      kind: r.MEMBER_COORDINATE,
+      name: s,
+      memberName: n
+    }) : this.node(e, {
+      kind: r.TYPE_COORDINATE,
+      name: s
+    });
+  }
+  // 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(e, t) {
+    return this._options.noLocation !== !0 && (t.loc = new u(
+      e,
+      this._lexer.lastToken,
+      this._lexer.source
+    )), t;
+  }
+  /**
+   * Determines if the next token is of a given kind
+   */
+  peek(e) {
+    return this._lexer.token.kind === e;
+  }
+  /**
+   * 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(e) {
+    const t = this._lexer.token;
+    if (t.kind === e)
+      return this.advanceLexer(), t;
+    throw c(
+      this._lexer.source,
+      t.start,
+      `Expected ${d(e)}, found ${l(t)}.`
+    );
+  }
+  /**
+   * 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(e) {
+    return this._lexer.token.kind === e ? (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(e) {
+    const t = this._lexer.token;
+    if (t.kind === i.NAME && t.value === e)
+      this.advanceLexer();
+    else
+      throw c(
+        this._lexer.source,
+        t.start,
+        `Expected "${e}", found ${l(t)}.`
+      );
+  }
+  /**
+   * 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(e) {
+    const t = this._lexer.token;
+    return t.kind === i.NAME && t.value === e ? (this.advanceLexer(), !0) : !1;
+  }
+  /**
+   * Helper function for creating an error when an unexpected lexed token is encountered.
+   */
+  unexpected(e) {
+    const t = e ?? this._lexer.token;
+    return c(
+      this._lexer.source,
+      t.start,
+      `Unexpected ${l(t)}.`
+    );
+  }
+  /**
+   * 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(e, t, s) {
+    this.expectToken(e);
+    const n = [];
+    for (; !this.expectOptionalToken(s); )
+      n.push(t.call(this));
+    return n;
+  }
+  /**
+   * 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(e, t, s) {
+    if (this.expectOptionalToken(e)) {
+      const n = [];
+      do
+        n.push(t.call(this));
+      while (!this.expectOptionalToken(s));
+      return n;
+    }
+    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(e, t, s) {
+    this.expectToken(e);
+    const n = [];
+    do
+      n.push(t.call(this));
+    while (!this.expectOptionalToken(s));
+    return n;
+  }
+  /**
+   * 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(e, t) {
+    this.expectOptionalToken(e);
+    const s = [];
+    do
+      s.push(t.call(this));
+    while (this.expectOptionalToken(e));
+    return s;
+  }
+  advanceLexer() {
+    const { maxTokens: e } = this._options, t = this._lexer.advance();
+    if (t.kind !== i.EOF && (++this._tokenCounter, e !== void 0 && this._tokenCounter > e))
+      throw c(
+        this._lexer.source,
+        t.start,
+        `Document contains more that ${e} tokens. Parsing aborted.`
+      );
+  }
+}
+function l(a) {
+  const e = a.value;
+  return d(a.kind) + (e != null ? ` "${e}"` : "");
+}
+function d(a) {
+  return k(a) ? `"${a}"` : a;
+}
+export {
+  N as Parser,
+  A as parse
+};
+//# sourceMappingURL=parser.es.js.map