{"version":3,"file":"js/npm.parser.mjs-3cb7574e0c6741a33540.js","mappings":"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","sources":["webpack://app/./node_modules/graphql/language/parser.mjs"],"sourcesContent":["import { syntaxError } from '../error/syntaxError.mjs';\nimport { Location, OperationTypeNode } from './ast.mjs';\nimport { DirectiveLocation } from './directiveLocation.mjs';\nimport { Kind } from './kinds.mjs';\nimport { isPunctuatorTokenKind, Lexer } from './lexer.mjs';\nimport { isSource, Source } from './source.mjs';\nimport { TokenKind } from './tokenKind.mjs';\n/**\n * Configuration options to control parser behavior\n */\n\n/**\n * Given a GraphQL source, parses it into a Document.\n * Throws GraphQLError if a syntax error is encountered.\n */\nexport function parse(source, options) {\n  const parser = new Parser(source, options);\n  return parser.parseDocument();\n}\n/**\n * Given a string containing a GraphQL value (ex. `[42]`), parse the AST for\n * that value.\n * Throws GraphQLError if a syntax error is encountered.\n *\n * This is useful within tools that operate upon GraphQL Values directly and\n * in isolation of complete GraphQL documents.\n *\n * Consider providing the results to the utility function: valueFromAST().\n */\n\nexport function parseValue(source, options) {\n  const parser = new Parser(source, options);\n  parser.expectToken(TokenKind.SOF);\n  const value = parser.parseValueLiteral(false);\n  parser.expectToken(TokenKind.EOF);\n  return value;\n}\n/**\n * Similar to parseValue(), but raises a parse error if it encounters a\n * variable. The return type will be a constant value.\n */\n\nexport function parseConstValue(source, options) {\n  const parser = new Parser(source, options);\n  parser.expectToken(TokenKind.SOF);\n  const value = parser.parseConstValueLiteral();\n  parser.expectToken(TokenKind.EOF);\n  return value;\n}\n/**\n * Given a string containing a GraphQL Type (ex. `[Int!]`), parse the AST for\n * that type.\n * Throws GraphQLError if a syntax error is encountered.\n *\n * This is useful within tools that operate upon GraphQL Types directly and\n * in isolation of complete GraphQL documents.\n *\n * Consider providing the results to the utility function: typeFromAST().\n */\n\nexport function parseType(source, options) {\n  const parser = new Parser(source, options);\n  parser.expectToken(TokenKind.SOF);\n  const type = parser.parseTypeReference();\n  parser.expectToken(TokenKind.EOF);\n  return type;\n}\n/**\n * This class is exported only to assist people in implementing their own parsers\n * without duplicating too much code and should be used only as last resort for cases\n * such as experimental syntax or if certain features could not be contributed upstream.\n *\n * It is still part of the internal API and is versioned, so any changes to it are never\n * considered breaking changes. If you still need to support multiple versions of the\n * library, please use the `versionInfo` variable for version detection.\n *\n * @internal\n */\n\nexport class Parser {\n  constructor(source, options = {}) {\n    const sourceObj = isSource(source) ? source : new Source(source);\n    this._lexer = new Lexer(sourceObj);\n    this._options = options;\n    this._tokenCounter = 0;\n  }\n  /**\n   * Converts a name lex token into a name parse node.\n   */\n\n  parseName() {\n    const token = this.expectToken(TokenKind.NAME);\n    return this.node(token, {\n      kind: Kind.NAME,\n      value: token.value,\n    });\n  } // Implements the parsing rules in the Document section.\n\n  /**\n   * Document : Definition+\n   */\n\n  parseDocument() {\n    return this.node(this._lexer.token, {\n      kind: Kind.DOCUMENT,\n      definitions: this.many(\n        TokenKind.SOF,\n        this.parseDefinition,\n        TokenKind.EOF,\n      ),\n    });\n  }\n  /**\n   * Definition :\n   *   - ExecutableDefinition\n   *   - TypeSystemDefinition\n   *   - TypeSystemExtension\n   *\n   * ExecutableDefinition :\n   *   - OperationDefinition\n   *   - FragmentDefinition\n   *\n   * TypeSystemDefinition :\n   *   - SchemaDefinition\n   *   - TypeDefinition\n   *   - DirectiveDefinition\n   *\n   * TypeDefinition :\n   *   - ScalarTypeDefinition\n   *   - ObjectTypeDefinition\n   *   - InterfaceTypeDefinition\n   *   - UnionTypeDefinition\n   *   - EnumTypeDefinition\n   *   - InputObjectTypeDefinition\n   */\n\n  parseDefinition() {\n    if (this.peek(TokenKind.BRACE_L)) {\n      return this.parseOperationDefinition();\n    } // Many definitions begin with a description and require a lookahead.\n\n    const hasDescription = this.peekDescription();\n    const keywordToken = hasDescription\n      ? this._lexer.lookahead()\n      : this._lexer.token;\n\n    if (keywordToken.kind === TokenKind.NAME) {\n      switch (keywordToken.value) {\n        case 'schema':\n          return this.parseSchemaDefinition();\n\n        case 'scalar':\n          return this.parseScalarTypeDefinition();\n\n        case 'type':\n          return this.parseObjectTypeDefinition();\n\n        case 'interface':\n          return this.parseInterfaceTypeDefinition();\n\n        case 'union':\n          return this.parseUnionTypeDefinition();\n\n        case 'enum':\n          return this.parseEnumTypeDefinition();\n\n        case 'input':\n          return this.parseInputObjectTypeDefinition();\n\n        case 'directive':\n          return this.parseDirectiveDefinition();\n      }\n\n      if (hasDescription) {\n        throw syntaxError(\n          this._lexer.source,\n          this._lexer.token.start,\n          'Unexpected description, descriptions are supported only on type definitions.',\n        );\n      }\n\n      switch (keywordToken.value) {\n        case 'query':\n        case 'mutation':\n        case 'subscription':\n          return this.parseOperationDefinition();\n\n        case 'fragment':\n          return this.parseFragmentDefinition();\n\n        case 'extend':\n          return this.parseTypeSystemExtension();\n      }\n    }\n\n    throw this.unexpected(keywordToken);\n  } // Implements the parsing rules in the Operations section.\n\n  /**\n   * OperationDefinition :\n   *  - SelectionSet\n   *  - OperationType Name? VariableDefinitions? Directives? SelectionSet\n   */\n\n  parseOperationDefinition() {\n    const start = this._lexer.token;\n\n    if (this.peek(TokenKind.BRACE_L)) {\n      return this.node(start, {\n        kind: Kind.OPERATION_DEFINITION,\n        operation: OperationTypeNode.QUERY,\n        name: undefined,\n        variableDefinitions: [],\n        directives: [],\n        selectionSet: this.parseSelectionSet(),\n      });\n    }\n\n    const operation = this.parseOperationType();\n    let name;\n\n    if (this.peek(TokenKind.NAME)) {\n      name = this.parseName();\n    }\n\n    return this.node(start, {\n      kind: Kind.OPERATION_DEFINITION,\n      operation,\n      name,\n      variableDefinitions: this.parseVariableDefinitions(),\n      directives: this.parseDirectives(false),\n      selectionSet: this.parseSelectionSet(),\n    });\n  }\n  /**\n   * OperationType : one of query mutation subscription\n   */\n\n  parseOperationType() {\n    const operationToken = this.expectToken(TokenKind.NAME);\n\n    switch (operationToken.value) {\n      case 'query':\n        return OperationTypeNode.QUERY;\n\n      case 'mutation':\n        return OperationTypeNode.MUTATION;\n\n      case 'subscription':\n        return OperationTypeNode.SUBSCRIPTION;\n    }\n\n    throw this.unexpected(operationToken);\n  }\n  /**\n   * VariableDefinitions : ( VariableDefinition+ )\n   */\n\n  parseVariableDefinitions() {\n    return this.optionalMany(\n      TokenKind.PAREN_L,\n      this.parseVariableDefinition,\n      TokenKind.PAREN_R,\n    );\n  }\n  /**\n   * VariableDefinition : Variable : Type DefaultValue? Directives[Const]?\n   */\n\n  parseVariableDefinition() {\n    return this.node(this._lexer.token, {\n      kind: Kind.VARIABLE_DEFINITION,\n      variable: this.parseVariable(),\n      type: (this.expectToken(TokenKind.COLON), this.parseTypeReference()),\n      defaultValue: this.expectOptionalToken(TokenKind.EQUALS)\n        ? this.parseConstValueLiteral()\n        : undefined,\n      directives: this.parseConstDirectives(),\n    });\n  }\n  /**\n   * Variable : $ Name\n   */\n\n  parseVariable() {\n    const start = this._lexer.token;\n    this.expectToken(TokenKind.DOLLAR);\n    return this.node(start, {\n      kind: Kind.VARIABLE,\n      name: this.parseName(),\n    });\n  }\n  /**\n   * ```\n   * SelectionSet : { Selection+ }\n   * ```\n   */\n\n  parseSelectionSet() {\n    return this.node(this._lexer.token, {\n      kind: Kind.SELECTION_SET,\n      selections: this.many(\n        TokenKind.BRACE_L,\n        this.parseSelection,\n        TokenKind.BRACE_R,\n      ),\n    });\n  }\n  /**\n   * Selection :\n   *   - Field\n   *   - FragmentSpread\n   *   - InlineFragment\n   */\n\n  parseSelection() {\n    return this.peek(TokenKind.SPREAD)\n      ? this.parseFragment()\n      : this.parseField();\n  }\n  /**\n   * Field : Alias? Name Arguments? Directives? SelectionSet?\n   *\n   * Alias : Name :\n   */\n\n  parseField() {\n    const start = this._lexer.token;\n    const nameOrAlias = this.parseName();\n    let alias;\n    let name;\n\n    if (this.expectOptionalToken(TokenKind.COLON)) {\n      alias = nameOrAlias;\n      name = this.parseName();\n    } else {\n      name = nameOrAlias;\n    }\n\n    return this.node(start, {\n      kind: Kind.FIELD,\n      alias,\n      name,\n      arguments: this.parseArguments(false),\n      directives: this.parseDirectives(false),\n      selectionSet: this.peek(TokenKind.BRACE_L)\n        ? this.parseSelectionSet()\n        : undefined,\n    });\n  }\n  /**\n   * Arguments[Const] : ( Argument[?Const]+ )\n   */\n\n  parseArguments(isConst) {\n    const item = isConst ? this.parseConstArgument : this.parseArgument;\n    return this.optionalMany(TokenKind.PAREN_L, item, TokenKind.PAREN_R);\n  }\n  /**\n   * Argument[Const] : Name : Value[?Const]\n   */\n\n  parseArgument(isConst = false) {\n    const start = this._lexer.token;\n    const name = this.parseName();\n    this.expectToken(TokenKind.COLON);\n    return this.node(start, {\n      kind: Kind.ARGUMENT,\n      name,\n      value: this.parseValueLiteral(isConst),\n    });\n  }\n\n  parseConstArgument() {\n    return this.parseArgument(true);\n  } // Implements the parsing rules in the Fragments section.\n\n  /**\n   * Corresponds to both FragmentSpread and InlineFragment in the spec.\n   *\n   * FragmentSpread : ... FragmentName Directives?\n   *\n   * InlineFragment : ... TypeCondition? Directives? SelectionSet\n   */\n\n  parseFragment() {\n    const start = this._lexer.token;\n    this.expectToken(TokenKind.SPREAD);\n    const hasTypeCondition = this.expectOptionalKeyword('on');\n\n    if (!hasTypeCondition && this.peek(TokenKind.NAME)) {\n      return this.node(start, {\n        kind: Kind.FRAGMENT_SPREAD,\n        name: this.parseFragmentName(),\n        directives: this.parseDirectives(false),\n      });\n    }\n\n    return this.node(start, {\n      kind: Kind.INLINE_FRAGMENT,\n      typeCondition: hasTypeCondition ? this.parseNamedType() : undefined,\n      directives: this.parseDirectives(false),\n      selectionSet: this.parseSelectionSet(),\n    });\n  }\n  /**\n   * FragmentDefinition :\n   *   - fragment FragmentName on TypeCondition Directives? SelectionSet\n   *\n   * TypeCondition : NamedType\n   */\n\n  parseFragmentDefinition() {\n    const start = this._lexer.token;\n    this.expectKeyword('fragment'); // Legacy support for defining variables within fragments changes\n    // the grammar of FragmentDefinition:\n    //   - fragment FragmentName VariableDefinitions? on TypeCondition Directives? SelectionSet\n\n    if (this._options.allowLegacyFragmentVariables === true) {\n      return this.node(start, {\n        kind: Kind.FRAGMENT_DEFINITION,\n        name: this.parseFragmentName(),\n        variableDefinitions: this.parseVariableDefinitions(),\n        typeCondition: (this.expectKeyword('on'), this.parseNamedType()),\n        directives: this.parseDirectives(false),\n        selectionSet: this.parseSelectionSet(),\n      });\n    }\n\n    return this.node(start, {\n      kind: Kind.FRAGMENT_DEFINITION,\n      name: this.parseFragmentName(),\n      typeCondition: (this.expectKeyword('on'), this.parseNamedType()),\n      directives: this.parseDirectives(false),\n      selectionSet: this.parseSelectionSet(),\n    });\n  }\n  /**\n   * FragmentName : Name but not `on`\n   */\n\n  parseFragmentName() {\n    if (this._lexer.token.value === 'on') {\n      throw this.unexpected();\n    }\n\n    return this.parseName();\n  } // Implements the parsing rules in the Values section.\n\n  /**\n   * Value[Const] :\n   *   - [~Const] Variable\n   *   - IntValue\n   *   - FloatValue\n   *   - StringValue\n   *   - BooleanValue\n   *   - NullValue\n   *   - EnumValue\n   *   - ListValue[?Const]\n   *   - ObjectValue[?Const]\n   *\n   * BooleanValue : one of `true` `false`\n   *\n   * NullValue : `null`\n   *\n   * EnumValue : Name but not `true`, `false` or `null`\n   */\n\n  parseValueLiteral(isConst) {\n    const token = this._lexer.token;\n\n    switch (token.kind) {\n      case TokenKind.BRACKET_L:\n        return this.parseList(isConst);\n\n      case TokenKind.BRACE_L:\n        return this.parseObject(isConst);\n\n      case TokenKind.INT:\n        this.advanceLexer();\n        return this.node(token, {\n          kind: Kind.INT,\n          value: token.value,\n        });\n\n      case TokenKind.FLOAT:\n        this.advanceLexer();\n        return this.node(token, {\n          kind: Kind.FLOAT,\n          value: token.value,\n        });\n\n      case TokenKind.STRING:\n      case TokenKind.BLOCK_STRING:\n        return this.parseStringLiteral();\n\n      case TokenKind.NAME:\n        this.advanceLexer();\n\n        switch (token.value) {\n          case 'true':\n            return this.node(token, {\n              kind: Kind.BOOLEAN,\n              value: true,\n            });\n\n          case 'false':\n            return this.node(token, {\n              kind: Kind.BOOLEAN,\n              value: false,\n            });\n\n          case 'null':\n            return this.node(token, {\n              kind: Kind.NULL,\n            });\n\n          default:\n            return this.node(token, {\n              kind: Kind.ENUM,\n              value: token.value,\n            });\n        }\n\n      case TokenKind.DOLLAR:\n        if (isConst) {\n          this.expectToken(TokenKind.DOLLAR);\n\n          if (this._lexer.token.kind === TokenKind.NAME) {\n            const varName = this._lexer.token.value;\n            throw syntaxError(\n              this._lexer.source,\n              token.start,\n              `Unexpected variable \"$${varName}\" in constant value.`,\n            );\n          } else {\n            throw this.unexpected(token);\n          }\n        }\n\n        return this.parseVariable();\n\n      default:\n        throw this.unexpected();\n    }\n  }\n\n  parseConstValueLiteral() {\n    return this.parseValueLiteral(true);\n  }\n\n  parseStringLiteral() {\n    const token = this._lexer.token;\n    this.advanceLexer();\n    return this.node(token, {\n      kind: Kind.STRING,\n      value: token.value,\n      block: token.kind === TokenKind.BLOCK_STRING,\n    });\n  }\n  /**\n   * ListValue[Const] :\n   *   - [ ]\n   *   - [ Value[?Const]+ ]\n   */\n\n  parseList(isConst) {\n    const item = () => this.parseValueLiteral(isConst);\n\n    return this.node(this._lexer.token, {\n      kind: Kind.LIST,\n      values: this.any(TokenKind.BRACKET_L, item, TokenKind.BRACKET_R),\n    });\n  }\n  /**\n   * ```\n   * ObjectValue[Const] :\n   *   - { }\n   *   - { ObjectField[?Const]+ }\n   * ```\n   */\n\n  parseObject(isConst) {\n    const item = () => this.parseObjectField(isConst);\n\n    return this.node(this._lexer.token, {\n      kind: Kind.OBJECT,\n      fields: this.any(TokenKind.BRACE_L, item, TokenKind.BRACE_R),\n    });\n  }\n  /**\n   * ObjectField[Const] : Name : Value[?Const]\n   */\n\n  parseObjectField(isConst) {\n    const start = this._lexer.token;\n    const name = this.parseName();\n    this.expectToken(TokenKind.COLON);\n    return this.node(start, {\n      kind: Kind.OBJECT_FIELD,\n      name,\n      value: this.parseValueLiteral(isConst),\n    });\n  } // Implements the parsing rules in the Directives section.\n\n  /**\n   * Directives[Const] : Directive[?Const]+\n   */\n\n  parseDirectives(isConst) {\n    const directives = [];\n\n    while (this.peek(TokenKind.AT)) {\n      directives.push(this.parseDirective(isConst));\n    }\n\n    return directives;\n  }\n\n  parseConstDirectives() {\n    return this.parseDirectives(true);\n  }\n  /**\n   * ```\n   * Directive[Const] : @ Name Arguments[?Const]?\n   * ```\n   */\n\n  parseDirective(isConst) {\n    const start = this._lexer.token;\n    this.expectToken(TokenKind.AT);\n    return this.node(start, {\n      kind: Kind.DIRECTIVE,\n      name: this.parseName(),\n      arguments: this.parseArguments(isConst),\n    });\n  } // Implements the parsing rules in the Types section.\n\n  /**\n   * Type :\n   *   - NamedType\n   *   - ListType\n   *   - NonNullType\n   */\n\n  parseTypeReference() {\n    const start = this._lexer.token;\n    let type;\n\n    if (this.expectOptionalToken(TokenKind.BRACKET_L)) {\n      const innerType = this.parseTypeReference();\n      this.expectToken(TokenKind.BRACKET_R);\n      type = this.node(start, {\n        kind: Kind.LIST_TYPE,\n        type: innerType,\n      });\n    } else {\n      type = this.parseNamedType();\n    }\n\n    if (this.expectOptionalToken(TokenKind.BANG)) {\n      return this.node(start, {\n        kind: Kind.NON_NULL_TYPE,\n        type,\n      });\n    }\n\n    return type;\n  }\n  /**\n   * NamedType : Name\n   */\n\n  parseNamedType() {\n    return this.node(this._lexer.token, {\n      kind: Kind.NAMED_TYPE,\n      name: this.parseName(),\n    });\n  } // Implements the parsing rules in the Type Definition section.\n\n  peekDescription() {\n    return this.peek(TokenKind.STRING) || this.peek(TokenKind.BLOCK_STRING);\n  }\n  /**\n   * Description : StringValue\n   */\n\n  parseDescription() {\n    if (this.peekDescription()) {\n      return this.parseStringLiteral();\n    }\n  }\n  /**\n   * ```\n   * SchemaDefinition : Description? schema Directives[Const]? { OperationTypeDefinition+ }\n   * ```\n   */\n\n  parseSchemaDefinition() {\n    const start = this._lexer.token;\n    const description = this.parseDescription();\n    this.expectKeyword('schema');\n    const directives = this.parseConstDirectives();\n    const operationTypes = this.many(\n      TokenKind.BRACE_L,\n      this.parseOperationTypeDefinition,\n      TokenKind.BRACE_R,\n    );\n    return this.node(start, {\n      kind: Kind.SCHEMA_DEFINITION,\n      description,\n      directives,\n      operationTypes,\n    });\n  }\n  /**\n   * OperationTypeDefinition : OperationType : NamedType\n   */\n\n  parseOperationTypeDefinition() {\n    const start = this._lexer.token;\n    const operation = this.parseOperationType();\n    this.expectToken(TokenKind.COLON);\n    const type = this.parseNamedType();\n    return this.node(start, {\n      kind: Kind.OPERATION_TYPE_DEFINITION,\n      operation,\n      type,\n    });\n  }\n  /**\n   * ScalarTypeDefinition : Description? scalar Name Directives[Const]?\n   */\n\n  parseScalarTypeDefinition() {\n    const start = this._lexer.token;\n    const description = this.parseDescription();\n    this.expectKeyword('scalar');\n    const name = this.parseName();\n    const directives = this.parseConstDirectives();\n    return this.node(start, {\n      kind: Kind.SCALAR_TYPE_DEFINITION,\n      description,\n      name,\n      directives,\n    });\n  }\n  /**\n   * ObjectTypeDefinition :\n   *   Description?\n   *   type Name ImplementsInterfaces? Directives[Const]? FieldsDefinition?\n   */\n\n  parseObjectTypeDefinition() {\n    const start = this._lexer.token;\n    const description = this.parseDescription();\n    this.expectKeyword('type');\n    const name = this.parseName();\n    const interfaces = this.parseImplementsInterfaces();\n    const directives = this.parseConstDirectives();\n    const fields = this.parseFieldsDefinition();\n    return this.node(start, {\n      kind: Kind.OBJECT_TYPE_DEFINITION,\n      description,\n      name,\n      interfaces,\n      directives,\n      fields,\n    });\n  }\n  /**\n   * ImplementsInterfaces :\n   *   - implements `&`? NamedType\n   *   - ImplementsInterfaces & NamedType\n   */\n\n  parseImplementsInterfaces() {\n    return this.expectOptionalKeyword('implements')\n      ? this.delimitedMany(TokenKind.AMP, this.parseNamedType)\n      : [];\n  }\n  /**\n   * ```\n   * FieldsDefinition : { FieldDefinition+ }\n   * ```\n   */\n\n  parseFieldsDefinition() {\n    return this.optionalMany(\n      TokenKind.BRACE_L,\n      this.parseFieldDefinition,\n      TokenKind.BRACE_R,\n    );\n  }\n  /**\n   * FieldDefinition :\n   *   - Description? Name ArgumentsDefinition? : Type Directives[Const]?\n   */\n\n  parseFieldDefinition() {\n    const start = this._lexer.token;\n    const description = this.parseDescription();\n    const name = this.parseName();\n    const args = this.parseArgumentDefs();\n    this.expectToken(TokenKind.COLON);\n    const type = this.parseTypeReference();\n    const directives = this.parseConstDirectives();\n    return this.node(start, {\n      kind: Kind.FIELD_DEFINITION,\n      description,\n      name,\n      arguments: args,\n      type,\n      directives,\n    });\n  }\n  /**\n   * ArgumentsDefinition : ( InputValueDefinition+ )\n   */\n\n  parseArgumentDefs() {\n    return this.optionalMany(\n      TokenKind.PAREN_L,\n      this.parseInputValueDef,\n      TokenKind.PAREN_R,\n    );\n  }\n  /**\n   * InputValueDefinition :\n   *   - Description? Name : Type DefaultValue? Directives[Const]?\n   */\n\n  parseInputValueDef() {\n    const start = this._lexer.token;\n    const description = this.parseDescription();\n    const name = this.parseName();\n    this.expectToken(TokenKind.COLON);\n    const type = this.parseTypeReference();\n    let defaultValue;\n\n    if (this.expectOptionalToken(TokenKind.EQUALS)) {\n      defaultValue = this.parseConstValueLiteral();\n    }\n\n    const directives = this.parseConstDirectives();\n    return this.node(start, {\n      kind: Kind.INPUT_VALUE_DEFINITION,\n      description,\n      name,\n      type,\n      defaultValue,\n      directives,\n    });\n  }\n  /**\n   * InterfaceTypeDefinition :\n   *   - Description? interface Name Directives[Const]? FieldsDefinition?\n   */\n\n  parseInterfaceTypeDefinition() {\n    const start = this._lexer.token;\n    const description = this.parseDescription();\n    this.expectKeyword('interface');\n    const name = this.parseName();\n    const interfaces = this.parseImplementsInterfaces();\n    const directives = this.parseConstDirectives();\n    const fields = this.parseFieldsDefinition();\n    return this.node(start, {\n      kind: Kind.INTERFACE_TYPE_DEFINITION,\n      description,\n      name,\n      interfaces,\n      directives,\n      fields,\n    });\n  }\n  /**\n   * UnionTypeDefinition :\n   *   - Description? union Name Directives[Const]? UnionMemberTypes?\n   */\n\n  parseUnionTypeDefinition() {\n    const start = this._lexer.token;\n    const description = this.parseDescription();\n    this.expectKeyword('union');\n    const name = this.parseName();\n    const directives = this.parseConstDirectives();\n    const types = this.parseUnionMemberTypes();\n    return this.node(start, {\n      kind: Kind.UNION_TYPE_DEFINITION,\n      description,\n      name,\n      directives,\n      types,\n    });\n  }\n  /**\n   * UnionMemberTypes :\n   *   - = `|`? NamedType\n   *   - UnionMemberTypes | NamedType\n   */\n\n  parseUnionMemberTypes() {\n    return this.expectOptionalToken(TokenKind.EQUALS)\n      ? this.delimitedMany(TokenKind.PIPE, this.parseNamedType)\n      : [];\n  }\n  /**\n   * EnumTypeDefinition :\n   *   - Description? enum Name Directives[Const]? EnumValuesDefinition?\n   */\n\n  parseEnumTypeDefinition() {\n    const start = this._lexer.token;\n    const description = this.parseDescription();\n    this.expectKeyword('enum');\n    const name = this.parseName();\n    const directives = this.parseConstDirectives();\n    const values = this.parseEnumValuesDefinition();\n    return this.node(start, {\n      kind: Kind.ENUM_TYPE_DEFINITION,\n      description,\n      name,\n      directives,\n      values,\n    });\n  }\n  /**\n   * ```\n   * EnumValuesDefinition : { EnumValueDefinition+ }\n   * ```\n   */\n\n  parseEnumValuesDefinition() {\n    return this.optionalMany(\n      TokenKind.BRACE_L,\n      this.parseEnumValueDefinition,\n      TokenKind.BRACE_R,\n    );\n  }\n  /**\n   * EnumValueDefinition : Description? EnumValue Directives[Const]?\n   */\n\n  parseEnumValueDefinition() {\n    const start = this._lexer.token;\n    const description = this.parseDescription();\n    const name = this.parseEnumValueName();\n    const directives = this.parseConstDirectives();\n    return this.node(start, {\n      kind: Kind.ENUM_VALUE_DEFINITION,\n      description,\n      name,\n      directives,\n    });\n  }\n  /**\n   * EnumValue : Name but not `true`, `false` or `null`\n   */\n\n  parseEnumValueName() {\n    if (\n      this._lexer.token.value === 'true' ||\n      this._lexer.token.value === 'false' ||\n      this._lexer.token.value === 'null'\n    ) {\n      throw syntaxError(\n        this._lexer.source,\n        this._lexer.token.start,\n        `${getTokenDesc(\n          this._lexer.token,\n        )} is reserved and cannot be used for an enum value.`,\n      );\n    }\n\n    return this.parseName();\n  }\n  /**\n   * InputObjectTypeDefinition :\n   *   - Description? input Name Directives[Const]? InputFieldsDefinition?\n   */\n\n  parseInputObjectTypeDefinition() {\n    const start = this._lexer.token;\n    const description = this.parseDescription();\n    this.expectKeyword('input');\n    const name = this.parseName();\n    const directives = this.parseConstDirectives();\n    const fields = this.parseInputFieldsDefinition();\n    return this.node(start, {\n      kind: Kind.INPUT_OBJECT_TYPE_DEFINITION,\n      description,\n      name,\n      directives,\n      fields,\n    });\n  }\n  /**\n   * ```\n   * InputFieldsDefinition : { InputValueDefinition+ }\n   * ```\n   */\n\n  parseInputFieldsDefinition() {\n    return this.optionalMany(\n      TokenKind.BRACE_L,\n      this.parseInputValueDef,\n      TokenKind.BRACE_R,\n    );\n  }\n  /**\n   * TypeSystemExtension :\n   *   - SchemaExtension\n   *   - TypeExtension\n   *\n   * TypeExtension :\n   *   - ScalarTypeExtension\n   *   - ObjectTypeExtension\n   *   - InterfaceTypeExtension\n   *   - UnionTypeExtension\n   *   - EnumTypeExtension\n   *   - InputObjectTypeDefinition\n   */\n\n  parseTypeSystemExtension() {\n    const keywordToken = this._lexer.lookahead();\n\n    if (keywordToken.kind === TokenKind.NAME) {\n      switch (keywordToken.value) {\n        case 'schema':\n          return this.parseSchemaExtension();\n\n        case 'scalar':\n          return this.parseScalarTypeExtension();\n\n        case 'type':\n          return this.parseObjectTypeExtension();\n\n        case 'interface':\n          return this.parseInterfaceTypeExtension();\n\n        case 'union':\n          return this.parseUnionTypeExtension();\n\n        case 'enum':\n          return this.parseEnumTypeExtension();\n\n        case 'input':\n          return this.parseInputObjectTypeExtension();\n      }\n    }\n\n    throw this.unexpected(keywordToken);\n  }\n  /**\n   * ```\n   * SchemaExtension :\n   *  - extend schema Directives[Const]? { OperationTypeDefinition+ }\n   *  - extend schema Directives[Const]\n   * ```\n   */\n\n  parseSchemaExtension() {\n    const start = this._lexer.token;\n    this.expectKeyword('extend');\n    this.expectKeyword('schema');\n    const directives = this.parseConstDirectives();\n    const operationTypes = this.optionalMany(\n      TokenKind.BRACE_L,\n      this.parseOperationTypeDefinition,\n      TokenKind.BRACE_R,\n    );\n\n    if (directives.length === 0 && operationTypes.length === 0) {\n      throw this.unexpected();\n    }\n\n    return this.node(start, {\n      kind: Kind.SCHEMA_EXTENSION,\n      directives,\n      operationTypes,\n    });\n  }\n  /**\n   * ScalarTypeExtension :\n   *   - extend scalar Name Directives[Const]\n   */\n\n  parseScalarTypeExtension() {\n    const start = this._lexer.token;\n    this.expectKeyword('extend');\n    this.expectKeyword('scalar');\n    const name = this.parseName();\n    const directives = this.parseConstDirectives();\n\n    if (directives.length === 0) {\n      throw this.unexpected();\n    }\n\n    return this.node(start, {\n      kind: Kind.SCALAR_TYPE_EXTENSION,\n      name,\n      directives,\n    });\n  }\n  /**\n   * ObjectTypeExtension :\n   *  - extend type Name ImplementsInterfaces? Directives[Const]? FieldsDefinition\n   *  - extend type Name ImplementsInterfaces? Directives[Const]\n   *  - extend type Name ImplementsInterfaces\n   */\n\n  parseObjectTypeExtension() {\n    const start = this._lexer.token;\n    this.expectKeyword('extend');\n    this.expectKeyword('type');\n    const name = this.parseName();\n    const interfaces = this.parseImplementsInterfaces();\n    const directives = this.parseConstDirectives();\n    const fields = this.parseFieldsDefinition();\n\n    if (\n      interfaces.length === 0 &&\n      directives.length === 0 &&\n      fields.length === 0\n    ) {\n      throw this.unexpected();\n    }\n\n    return this.node(start, {\n      kind: Kind.OBJECT_TYPE_EXTENSION,\n      name,\n      interfaces,\n      directives,\n      fields,\n    });\n  }\n  /**\n   * InterfaceTypeExtension :\n   *  - extend interface Name ImplementsInterfaces? Directives[Const]? FieldsDefinition\n   *  - extend interface Name ImplementsInterfaces? Directives[Const]\n   *  - extend interface Name ImplementsInterfaces\n   */\n\n  parseInterfaceTypeExtension() {\n    const start = this._lexer.token;\n    this.expectKeyword('extend');\n    this.expectKeyword('interface');\n    const name = this.parseName();\n    const interfaces = this.parseImplementsInterfaces();\n    const directives = this.parseConstDirectives();\n    const fields = this.parseFieldsDefinition();\n\n    if (\n      interfaces.length === 0 &&\n      directives.length === 0 &&\n      fields.length === 0\n    ) {\n      throw this.unexpected();\n    }\n\n    return this.node(start, {\n      kind: Kind.INTERFACE_TYPE_EXTENSION,\n      name,\n      interfaces,\n      directives,\n      fields,\n    });\n  }\n  /**\n   * UnionTypeExtension :\n   *   - extend union Name Directives[Const]? UnionMemberTypes\n   *   - extend union Name Directives[Const]\n   */\n\n  parseUnionTypeExtension() {\n    const start = this._lexer.token;\n    this.expectKeyword('extend');\n    this.expectKeyword('union');\n    const name = this.parseName();\n    const directives = this.parseConstDirectives();\n    const types = this.parseUnionMemberTypes();\n\n    if (directives.length === 0 && types.length === 0) {\n      throw this.unexpected();\n    }\n\n    return this.node(start, {\n      kind: Kind.UNION_TYPE_EXTENSION,\n      name,\n      directives,\n      types,\n    });\n  }\n  /**\n   * EnumTypeExtension :\n   *   - extend enum Name Directives[Const]? EnumValuesDefinition\n   *   - extend enum Name Directives[Const]\n   */\n\n  parseEnumTypeExtension() {\n    const start = this._lexer.token;\n    this.expectKeyword('extend');\n    this.expectKeyword('enum');\n    const name = this.parseName();\n    const directives = this.parseConstDirectives();\n    const values = this.parseEnumValuesDefinition();\n\n    if (directives.length === 0 && values.length === 0) {\n      throw this.unexpected();\n    }\n\n    return this.node(start, {\n      kind: Kind.ENUM_TYPE_EXTENSION,\n      name,\n      directives,\n      values,\n    });\n  }\n  /**\n   * InputObjectTypeExtension :\n   *   - extend input Name Directives[Const]? InputFieldsDefinition\n   *   - extend input Name Directives[Const]\n   */\n\n  parseInputObjectTypeExtension() {\n    const start = this._lexer.token;\n    this.expectKeyword('extend');\n    this.expectKeyword('input');\n    const name = this.parseName();\n    const directives = this.parseConstDirectives();\n    const fields = this.parseInputFieldsDefinition();\n\n    if (directives.length === 0 && fields.length === 0) {\n      throw this.unexpected();\n    }\n\n    return this.node(start, {\n      kind: Kind.INPUT_OBJECT_TYPE_EXTENSION,\n      name,\n      directives,\n      fields,\n    });\n  }\n  /**\n   * ```\n   * DirectiveDefinition :\n   *   - Description? directive @ Name ArgumentsDefinition? `repeatable`? on DirectiveLocations\n   * ```\n   */\n\n  parseDirectiveDefinition() {\n    const start = this._lexer.token;\n    const description = this.parseDescription();\n    this.expectKeyword('directive');\n    this.expectToken(TokenKind.AT);\n    const name = this.parseName();\n    const args = this.parseArgumentDefs();\n    const repeatable = this.expectOptionalKeyword('repeatable');\n    this.expectKeyword('on');\n    const locations = this.parseDirectiveLocations();\n    return this.node(start, {\n      kind: Kind.DIRECTIVE_DEFINITION,\n      description,\n      name,\n      arguments: args,\n      repeatable,\n      locations,\n    });\n  }\n  /**\n   * DirectiveLocations :\n   *   - `|`? DirectiveLocation\n   *   - DirectiveLocations | DirectiveLocation\n   */\n\n  parseDirectiveLocations() {\n    return this.delimitedMany(TokenKind.PIPE, this.parseDirectiveLocation);\n  }\n  /*\n   * DirectiveLocation :\n   *   - ExecutableDirectiveLocation\n   *   - TypeSystemDirectiveLocation\n   *\n   * ExecutableDirectiveLocation : one of\n   *   `QUERY`\n   *   `MUTATION`\n   *   `SUBSCRIPTION`\n   *   `FIELD`\n   *   `FRAGMENT_DEFINITION`\n   *   `FRAGMENT_SPREAD`\n   *   `INLINE_FRAGMENT`\n   *\n   * TypeSystemDirectiveLocation : one of\n   *   `SCHEMA`\n   *   `SCALAR`\n   *   `OBJECT`\n   *   `FIELD_DEFINITION`\n   *   `ARGUMENT_DEFINITION`\n   *   `INTERFACE`\n   *   `UNION`\n   *   `ENUM`\n   *   `ENUM_VALUE`\n   *   `INPUT_OBJECT`\n   *   `INPUT_FIELD_DEFINITION`\n   */\n\n  parseDirectiveLocation() {\n    const start = this._lexer.token;\n    const name = this.parseName();\n\n    if (Object.prototype.hasOwnProperty.call(DirectiveLocation, name.value)) {\n      return name;\n    }\n\n    throw this.unexpected(start);\n  } // Core parsing utility functions\n\n  /**\n   * Returns a node that, if configured to do so, sets a \"loc\" field as a\n   * location object, used to identify the place in the source that created a\n   * given parsed object.\n   */\n\n  node(startToken, node) {\n    if (this._options.noLocation !== true) {\n      node.loc = new Location(\n        startToken,\n        this._lexer.lastToken,\n        this._lexer.source,\n      );\n    }\n\n    return node;\n  }\n  /**\n   * Determines if the next token is of a given kind\n   */\n\n  peek(kind) {\n    return this._lexer.token.kind === kind;\n  }\n  /**\n   * If the next token is of the given kind, return that token after advancing the lexer.\n   * Otherwise, do not change the parser state and throw an error.\n   */\n\n  expectToken(kind) {\n    const token = this._lexer.token;\n\n    if (token.kind === kind) {\n      this.advanceLexer();\n      return token;\n    }\n\n    throw syntaxError(\n      this._lexer.source,\n      token.start,\n      `Expected ${getTokenKindDesc(kind)}, found ${getTokenDesc(token)}.`,\n    );\n  }\n  /**\n   * If the next token is of the given kind, return \"true\" after advancing the lexer.\n   * Otherwise, do not change the parser state and return \"false\".\n   */\n\n  expectOptionalToken(kind) {\n    const token = this._lexer.token;\n\n    if (token.kind === kind) {\n      this.advanceLexer();\n      return true;\n    }\n\n    return false;\n  }\n  /**\n   * If the next token is a given keyword, advance the lexer.\n   * Otherwise, do not change the parser state and throw an error.\n   */\n\n  expectKeyword(value) {\n    const token = this._lexer.token;\n\n    if (token.kind === TokenKind.NAME && token.value === value) {\n      this.advanceLexer();\n    } else {\n      throw syntaxError(\n        this._lexer.source,\n        token.start,\n        `Expected \"${value}\", found ${getTokenDesc(token)}.`,\n      );\n    }\n  }\n  /**\n   * If the next token is a given keyword, return \"true\" after advancing the lexer.\n   * Otherwise, do not change the parser state and return \"false\".\n   */\n\n  expectOptionalKeyword(value) {\n    const token = this._lexer.token;\n\n    if (token.kind === TokenKind.NAME && token.value === value) {\n      this.advanceLexer();\n      return true;\n    }\n\n    return false;\n  }\n  /**\n   * Helper function for creating an error when an unexpected lexed token is encountered.\n   */\n\n  unexpected(atToken) {\n    const token =\n      atToken !== null && atToken !== void 0 ? atToken : this._lexer.token;\n    return syntaxError(\n      this._lexer.source,\n      token.start,\n      `Unexpected ${getTokenDesc(token)}.`,\n    );\n  }\n  /**\n   * Returns a possibly empty list of parse nodes, determined by the parseFn.\n   * This list begins with a lex token of openKind and ends with a lex token of closeKind.\n   * Advances the parser to the next lex token after the closing token.\n   */\n\n  any(openKind, parseFn, closeKind) {\n    this.expectToken(openKind);\n    const nodes = [];\n\n    while (!this.expectOptionalToken(closeKind)) {\n      nodes.push(parseFn.call(this));\n    }\n\n    return nodes;\n  }\n  /**\n   * Returns a list of parse nodes, determined by the parseFn.\n   * It can be empty only if open token is missing otherwise it will always return non-empty list\n   * that begins with a lex token of openKind and ends with a lex token of closeKind.\n   * Advances the parser to the next lex token after the closing token.\n   */\n\n  optionalMany(openKind, parseFn, closeKind) {\n    if (this.expectOptionalToken(openKind)) {\n      const nodes = [];\n\n      do {\n        nodes.push(parseFn.call(this));\n      } while (!this.expectOptionalToken(closeKind));\n\n      return nodes;\n    }\n\n    return [];\n  }\n  /**\n   * Returns a non-empty list of parse nodes, determined by the parseFn.\n   * This list begins with a lex token of openKind and ends with a lex token of closeKind.\n   * Advances the parser to the next lex token after the closing token.\n   */\n\n  many(openKind, parseFn, closeKind) {\n    this.expectToken(openKind);\n    const nodes = [];\n\n    do {\n      nodes.push(parseFn.call(this));\n    } while (!this.expectOptionalToken(closeKind));\n\n    return nodes;\n  }\n  /**\n   * Returns a non-empty list of parse nodes, determined by the parseFn.\n   * This list may begin with a lex token of delimiterKind followed by items separated by lex tokens of tokenKind.\n   * Advances the parser to the next lex token after last item in the list.\n   */\n\n  delimitedMany(delimiterKind, parseFn) {\n    this.expectOptionalToken(delimiterKind);\n    const nodes = [];\n\n    do {\n      nodes.push(parseFn.call(this));\n    } while (this.expectOptionalToken(delimiterKind));\n\n    return nodes;\n  }\n\n  advanceLexer() {\n    const { maxTokens } = this._options;\n\n    const token = this._lexer.advance();\n\n    if (maxTokens !== undefined && token.kind !== TokenKind.EOF) {\n      ++this._tokenCounter;\n\n      if (this._tokenCounter > maxTokens) {\n        throw syntaxError(\n          this._lexer.source,\n          token.start,\n          `Document contains more that ${maxTokens} tokens. Parsing aborted.`,\n        );\n      }\n    }\n  }\n}\n/**\n * A helper function to describe a token as a string for debugging.\n */\n\nfunction getTokenDesc(token) {\n  const value = token.value;\n  return getTokenKindDesc(token.kind) + (value != null ? ` \"${value}\"` : '');\n}\n/**\n * A helper function to describe a token kind as a string for debugging.\n */\n\nfunction getTokenKindDesc(kind) {\n  return isPunctuatorTokenKind(kind) ? `\"${kind}\"` : kind;\n}\n"],"names":["parse","source","options","Parser","parseDocument","constructor","sourceObj","this","_lexer","_options","_tokenCounter","parseName","token","expectToken","T","node","kind","value","definitions","many","parseDefinition","peek","parseOperationDefinition","hasDescription","peekDescription","keywordToken","lookahead","parseSchemaDefinition","parseScalarTypeDefinition","parseObjectTypeDefinition","parseInterfaceTypeDefinition","parseUnionTypeDefinition","parseEnumTypeDefinition","parseInputObjectTypeDefinition","parseDirectiveDefinition","start","parseFragmentDefinition","parseTypeSystemExtension","unexpected","operation","name","undefined","variableDefinitions","directives","selectionSet","parseSelectionSet","parseOperationType","parseVariableDefinitions","parseDirectives","operationToken","optionalMany","parseVariableDefinition","variable","parseVariable","type","parseTypeReference","defaultValue","expectOptionalToken","parseConstValueLiteral","parseConstDirectives","selections","parseSelection","parseFragment","parseField","nameOrAlias","alias","arguments","parseArguments","isConst","item","parseConstArgument","parseArgument","parseValueLiteral","hasTypeCondition","expectOptionalKeyword","parseFragmentName","typeCondition","parseNamedType","expectKeyword","allowLegacyFragmentVariables","parseList","parseObject","advanceLexer","parseStringLiteral","varName","block","values","any","fields","parseObjectField","push","parseDirective","innerType","parseDescription","description","operationTypes","parseOperationTypeDefinition","interfaces","parseImplementsInterfaces","parseFieldsDefinition","delimitedMany","parseFieldDefinition","args","parseArgumentDefs","parseInputValueDef","types","parseUnionMemberTypes","parseEnumValuesDefinition","parseEnumValueDefinition","parseEnumValueName","getTokenDesc","parseInputFieldsDefinition","parseSchemaExtension","parseScalarTypeExtension","parseObjectTypeExtension","parseInterfaceTypeExtension","parseUnionTypeExtension","parseEnumTypeExtension","parseInputObjectTypeExtension","length","repeatable","locations","parseDirectiveLocations","parseDirectiveLocation","Object","prototype","hasOwnProperty","call","startToken","noLocation","loc","lastToken","getTokenKindDesc","atToken","openKind","parseFn","closeKind","nodes","delimiterKind","maxTokens","advance"],"sourceRoot":""}