{"version":3,"sources":["webpack:///./node_modules/graphql/language/blockString.mjs","webpack:///./node_modules/graphql/jsutils/devAssert.mjs","webpack:///./node_modules/graphql/jsutils/defineToJSON.mjs","webpack:///./node_modules/graphql/jsutils/isObjectLike.mjs","webpack:///./node_modules/graphql/language/location.mjs","webpack:///./node_modules/graphql/language/printLocation.mjs","webpack:///./node_modules/graphql/error/GraphQLError.mjs","webpack:///./node_modules/graphql/error/syntaxError.mjs","webpack:///./node_modules/graphql/language/kinds.mjs","webpack:///./node_modules/graphql/jsutils/defineToStringTag.mjs","webpack:///./node_modules/graphql/language/source.mjs","webpack:///./node_modules/graphql/language/tokenKind.mjs","webpack:///./node_modules/graphql/language/lexer.mjs","webpack:///./node_modules/graphql/language/directiveLocation.mjs","webpack:///./node_modules/graphql/language/parser.mjs","webpack:///./node_modules/graphql/jsutils/nodejsCustomInspectSymbol.mjs","webpack:///./node_modules/graphql/language/visitor.mjs","webpack:///./node_modules/graphql/language/printer.mjs","webpack:///./node_modules/graphql/jsutils/inspect.mjs"],"names":["dedentBlockStringValue","rawString","lines","split","commonIndent","getBlockStringIndentation","i","length","slice","isBlank","shift","pop","join","line","indent","leadingWhitespace","str","printBlockString","value","indentation","arguments","undefined","preferMultipleLines","isSingleLine","indexOf","hasLeadingSpace","hasTrailingQuote","printAsMultipleLines","result","replace","devAssert","condition","message","booleanCondition","Boolean","Error","defineToJSON","classObject","fn","prototype","toString","toJSON","inspect","nodejsCustomInspectSymbol","_typeof","obj","Symbol","iterator","constructor","isObjectLike","getLocation","source","position","match","lineRegexp","column","exec","body","index","printLocation","location","printSourceLocation","start","sourceLocation","firstLineColumnOffset","locationOffset","whitespace","lineIndex","lineOffset","lineNum","columnOffset","columnNum","locationStr","concat","name","locationLine","sublineIndex","Math","floor","sublineColumnNum","sublines","push","printPrefixedLines","map","subline","existingLines","filter","_ref","padLen","max","apply","_ref2","prefix","_ref3","lpad","len","Array","GraphQLError","nodes","positions","path","originalError","extensions","_nodes","isArray","_source","node","loc","_locations","_positions","reduce","list","pos","_extensions","originalExtensions","Object","defineProperties","this","enumerable","writable","locations","stack","defineProperty","configurable","captureStackTrace","printError","error","output","_i2","_error$nodes2","_i4","_error$locations2","syntaxError","description","create","Kind","freeze","NAME","DOCUMENT","OPERATION_DEFINITION","VARIABLE_DEFINITION","SELECTION_SET","FIELD","ARGUMENT","FRAGMENT_SPREAD","INLINE_FRAGMENT","FRAGMENT_DEFINITION","VARIABLE","INT","FLOAT","STRING","BOOLEAN","NULL","ENUM","LIST","OBJECT","OBJECT_FIELD","DIRECTIVE","NAMED_TYPE","LIST_TYPE","NON_NULL_TYPE","SCHEMA_DEFINITION","OPERATION_TYPE_DEFINITION","SCALAR_TYPE_DEFINITION","OBJECT_TYPE_DEFINITION","FIELD_DEFINITION","INPUT_VALUE_DEFINITION","INTERFACE_TYPE_DEFINITION","UNION_TYPE_DEFINITION","ENUM_TYPE_DEFINITION","ENUM_VALUE_DEFINITION","INPUT_OBJECT_TYPE_DEFINITION","DIRECTIVE_DEFINITION","SCHEMA_EXTENSION","SCALAR_TYPE_EXTENSION","OBJECT_TYPE_EXTENSION","INTERFACE_TYPE_EXTENSION","UNION_TYPE_EXTENSION","ENUM_TYPE_EXTENSION","INPUT_OBJECT_TYPE_EXTENSION","defineToStringTag","toStringTag","get","TokenKind","SOF","EOF","BANG","DOLLAR","AMP","PAREN_L","PAREN_R","SPREAD","COLON","EQUALS","AT","BRACKET_L","BRACKET_R","BRACE_L","PIPE","BRACE_R","BLOCK_STRING","COMMENT","createLexer","options","startOfFileToken","Tok","lexer","lastToken","token","lineStart","advance","advanceLexer","lookahead","kind","next","readToken","end","prev","printCharCode","code","isNaN","JSON","stringify","String","fromCharCode","toUpperCase","bodyLength","positionAfterWhitespace","col","charCodeAt","readComment","readName","readNumber","readBlockString","readString","unexpectedCharacterMessage","startPosition","firstCode","isFloat","readDigits","chunkStart","charCode","uniCharCode","invalidSequence","rawValue","a","b","c","d","char2hex","DirectiveLocation","QUERY","MUTATION","SUBSCRIPTION","SCHEMA","SCALAR","ARGUMENT_DEFINITION","INTERFACE","UNION","ENUM_VALUE","INPUT_OBJECT","INPUT_FIELD_DEFINITION","parse","parser","parseDocument","parseValue","expectToken","parseValueLiteral","parseType","type","parseTypeReference","Parser","sourceObj","_lexer","_options","_proto","parseName","definitions","many","parseDefinition","peek","parseOperationDefinition","parseFragmentDefinition","parseTypeSystemDefinition","parseTypeSystemExtension","peekDescription","unexpected","operation","variableDefinitions","directives","selectionSet","parseSelectionSet","parseOperationType","parseVariableDefinitions","parseDirectives","operationToken","optionalMany","parseVariableDefinition","variable","parseVariable","defaultValue","expectOptionalToken","selections","parseSelection","parseFragment","parseField","alias","nameOrAlias","parseArguments","isConst","item","parseConstArgument","parseArgument","hasTypeCondition","expectOptionalKeyword","parseFragmentName","typeCondition","parseNamedType","expectKeyword","experimentalFragmentVariables","parseList","parseObject","parseStringLiteral","block","_this","values","any","_this2","parseObjectField","fields","parseDirective","keywordToken","parseSchemaDefinition","parseScalarTypeDefinition","parseObjectTypeDefinition","parseInterfaceTypeDefinition","parseUnionTypeDefinition","parseEnumTypeDefinition","parseInputObjectTypeDefinition","parseDirectiveDefinition","parseDescription","operationTypes","parseOperationTypeDefinition","interfaces","parseImplementsInterfaces","parseFieldsDefinition","types","allowLegacySDLImplementsInterfaces","allowLegacySDLEmptyFields","parseFieldDefinition","args","parseArgumentDefs","parseInputValueDef","parseUnionMemberTypes","parseEnumValuesDefinition","parseEnumValueDefinition","parseInputFieldsDefinition","parseSchemaExtension","parseScalarTypeExtension","parseObjectTypeExtension","parseInterfaceTypeExtension","parseUnionTypeExtension","parseEnumTypeExtension","parseInputObjectTypeExtension","repeatable","parseDirectiveLocations","parseDirectiveLocation","startToken","noLocation","Loc","getTokenDesc","atToken","openKind","parseFn","closeKind","call","endToken","for","QueryDocumentKeys","Name","Document","OperationDefinition","VariableDefinition","Variable","SelectionSet","Field","Argument","FragmentSpread","InlineFragment","FragmentDefinition","IntValue","FloatValue","StringValue","BooleanValue","NullValue","EnumValue","ListValue","ObjectValue","ObjectField","Directive","NamedType","ListType","NonNullType","SchemaDefinition","OperationTypeDefinition","ScalarTypeDefinition","ObjectTypeDefinition","FieldDefinition","InputValueDefinition","InterfaceTypeDefinition","UnionTypeDefinition","EnumTypeDefinition","EnumValueDefinition","InputObjectTypeDefinition","DirectiveDefinition","SchemaExtension","ScalarTypeExtension","ObjectTypeExtension","InterfaceTypeExtension","UnionTypeExtension","EnumTypeExtension","InputObjectTypeExtension","BREAK","visit","root","visitor","visitorKeys","inArray","keys","edits","key","parent","ancestors","newRoot","isLeaving","isEdited","clone","_Object$keys2","k","editOffset","ii","editKey","editValue","splice","isNode","visitFn","getVisitFn","maybeNode","kindVisitor","kindSpecificVisitor","leave","enter","specificVisitor","specificKindVisitor","print","ast","printDocASTReducer","op","varDefs","wrap","_ref4","_ref5","_ref6","_ref7","_ref8","_ref9","_ref10","isBlockString","_ref11","_ref12","_ref13","_ref14","_ref15","_ref16","_ref17","_ref18","_ref19","_ref20","_ref21","addDescription","_ref22","_ref23","_ref24","hasMultilineItems","_ref25","_ref26","_ref27","_ref28","_ref29","_ref30","_ref31","_ref32","_ref33","_ref34","_ref35","_ref36","_ref37","_ref38","cb","maybeArray","separator","x","array","maybeString","isMultiline","string","some","MAX_ARRAY_LENGTH","MAX_RECURSIVE_DEPTH","formatValue","seenValues","formatObjectValue","previouslySeenValues","customInspectFn","getCustomFn","customValue","formatArray","formatObject","object","getObjectTag","properties","min","remaining","items","tag"],"mappings":"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","file":"js/npm.graphql.215784f1.js","sourcesContent":["/**\n * Produces the value of a block string from its parsed raw value, similar to\n * CoffeeScript's block string, Python's docstring trim or Ruby's strip_heredoc.\n *\n * This implements the GraphQL spec's BlockStringValue() static algorithm.\n */\nexport function dedentBlockStringValue(rawString) {\n  // Expand a block string's raw value into independent lines.\n  var lines = rawString.split(/\\r\\n|[\\n\\r]/g); // Remove common indentation from all lines but first.\n\n  var commonIndent = getBlockStringIndentation(lines);\n\n  if (commonIndent !== 0) {\n    for (var i = 1; i < lines.length; i++) {\n      lines[i] = lines[i].slice(commonIndent);\n    }\n  } // Remove leading and trailing blank lines.\n\n\n  while (lines.length > 0 && isBlank(lines[0])) {\n    lines.shift();\n  }\n\n  while (lines.length > 0 && isBlank(lines[lines.length - 1])) {\n    lines.pop();\n  } // Return a string of the lines joined with U+000A.\n\n\n  return lines.join('\\n');\n} // @internal\n\nexport function getBlockStringIndentation(lines) {\n  var commonIndent = null;\n\n  for (var i = 1; i < lines.length; i++) {\n    var line = lines[i];\n    var indent = leadingWhitespace(line);\n\n    if (indent === line.length) {\n      continue; // skip empty lines\n    }\n\n    if (commonIndent === null || indent < commonIndent) {\n      commonIndent = indent;\n\n      if (commonIndent === 0) {\n        break;\n      }\n    }\n  }\n\n  return commonIndent === null ? 0 : commonIndent;\n}\n\nfunction leadingWhitespace(str) {\n  var i = 0;\n\n  while (i < str.length && (str[i] === ' ' || str[i] === '\\t')) {\n    i++;\n  }\n\n  return i;\n}\n\nfunction isBlank(str) {\n  return leadingWhitespace(str) === str.length;\n}\n/**\n * Print a block string in the indented block form by adding a leading and\n * trailing blank line. However, if a block string starts with whitespace and is\n * a single-line, adding a leading blank line would strip that whitespace.\n */\n\n\nexport function printBlockString(value) {\n  var indentation = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';\n  var preferMultipleLines = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;\n  var isSingleLine = value.indexOf('\\n') === -1;\n  var hasLeadingSpace = value[0] === ' ' || value[0] === '\\t';\n  var hasTrailingQuote = value[value.length - 1] === '\"';\n  var printAsMultipleLines = !isSingleLine || hasTrailingQuote || preferMultipleLines;\n  var result = ''; // Format a multi-line block quote to account for leading space.\n\n  if (printAsMultipleLines && !(isSingleLine && hasLeadingSpace)) {\n    result += '\\n' + indentation;\n  }\n\n  result += indentation ? value.replace(/\\n/g, '\\n' + indentation) : value;\n\n  if (printAsMultipleLines) {\n    result += '\\n';\n  }\n\n  return '\"\"\"' + result.replace(/\"\"\"/g, '\\\\\"\"\"') + '\"\"\"';\n}\n","export default function devAssert(condition, message) {\n  var booleanCondition = Boolean(condition);\n\n  if (!booleanCondition) {\n    throw new Error(message);\n  }\n}\n","import nodejsCustomInspectSymbol from './nodejsCustomInspectSymbol';\n/**\n * The `defineToJSON()` function defines toJSON() and inspect() prototype\n * methods, if no function provided they become aliases for toString().\n */\n\nexport default function defineToJSON(classObject) {\n  var fn = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : classObject.prototype.toString;\n  classObject.prototype.toJSON = fn;\n  classObject.prototype.inspect = fn;\n\n  if (nodejsCustomInspectSymbol) {\n    classObject.prototype[nodejsCustomInspectSymbol] = fn;\n  }\n}\n","function _typeof(obj) { if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }; } return _typeof(obj); }\n\n/**\n * Return true if `value` is object-like. A value is object-like if it's not\n * `null` and has a `typeof` result of \"object\".\n */\nexport default function isObjectLike(value) {\n  return _typeof(value) == 'object' && value !== null;\n}\n","/**\n * Represents a location in a Source.\n */\n\n/**\n * Takes a Source and a UTF-8 character offset, and returns the corresponding\n * line and column as a SourceLocation.\n */\nexport function getLocation(source, position) {\n  var lineRegexp = /\\r\\n|[\\n\\r]/g;\n  var line = 1;\n  var column = position + 1;\n  var match;\n\n  while ((match = lineRegexp.exec(source.body)) && match.index < position) {\n    line += 1;\n    column = position + 1 - (match.index + match[0].length);\n  }\n\n  return {\n    line: line,\n    column: column\n  };\n}\n","import { getLocation } from '../language/location';\n/**\n * Render a helpful description of the location in the GraphQL Source document.\n */\n\nexport function printLocation(location) {\n  return printSourceLocation(location.source, getLocation(location.source, location.start));\n}\n/**\n * Render a helpful description of the location in the GraphQL Source document.\n */\n\nexport function printSourceLocation(source, sourceLocation) {\n  var firstLineColumnOffset = source.locationOffset.column - 1;\n  var body = whitespace(firstLineColumnOffset) + source.body;\n  var lineIndex = sourceLocation.line - 1;\n  var lineOffset = source.locationOffset.line - 1;\n  var lineNum = sourceLocation.line + lineOffset;\n  var columnOffset = sourceLocation.line === 1 ? firstLineColumnOffset : 0;\n  var columnNum = sourceLocation.column + columnOffset;\n  var locationStr = \"\".concat(source.name, \":\").concat(lineNum, \":\").concat(columnNum, \"\\n\");\n  var lines = body.split(/\\r\\n|[\\n\\r]/g);\n  var locationLine = lines[lineIndex]; // Special case for minified documents\n\n  if (locationLine.length > 120) {\n    var sublineIndex = Math.floor(columnNum / 80);\n    var sublineColumnNum = columnNum % 80;\n    var sublines = [];\n\n    for (var i = 0; i < locationLine.length; i += 80) {\n      sublines.push(locationLine.slice(i, i + 80));\n    }\n\n    return locationStr + printPrefixedLines([[\"\".concat(lineNum), sublines[0]]].concat(sublines.slice(1, sublineIndex + 1).map(function (subline) {\n      return ['', subline];\n    }), [[' ', whitespace(sublineColumnNum - 1) + '^'], ['', sublines[sublineIndex + 1]]]));\n  }\n\n  return locationStr + printPrefixedLines([// Lines specified like this: [\"prefix\", \"string\"],\n  [\"\".concat(lineNum - 1), lines[lineIndex - 1]], [\"\".concat(lineNum), locationLine], ['', whitespace(columnNum - 1) + '^'], [\"\".concat(lineNum + 1), lines[lineIndex + 1]]]);\n}\n\nfunction printPrefixedLines(lines) {\n  var existingLines = lines.filter(function (_ref) {\n    var _ = _ref[0],\n        line = _ref[1];\n    return line !== undefined;\n  });\n  var padLen = Math.max.apply(Math, existingLines.map(function (_ref2) {\n    var prefix = _ref2[0];\n    return prefix.length;\n  }));\n  return existingLines.map(function (_ref3) {\n    var prefix = _ref3[0],\n        line = _ref3[1];\n    return lpad(padLen, prefix) + (line ? ' | ' + line : ' |');\n  }).join('\\n');\n}\n\nfunction whitespace(len) {\n  return Array(len + 1).join(' ');\n}\n\nfunction lpad(len, str) {\n  return whitespace(len - str.length) + str;\n}\n","import isObjectLike from '../jsutils/isObjectLike';\nimport { getLocation } from '../language/location';\nimport { printLocation, printSourceLocation } from '../language/printLocation';\n/**\n * A GraphQLError describes an Error found during the parse, validate, or\n * execute phases of performing a GraphQL operation. In addition to a message\n * and stack trace, it also includes information about the locations in a\n * GraphQL document and/or execution result that correspond to the Error.\n */\n\nexport function GraphQLError( // eslint-disable-line no-redeclare\nmessage, nodes, source, positions, path, originalError, extensions) {\n  // Compute list of blame nodes.\n  var _nodes = Array.isArray(nodes) ? nodes.length !== 0 ? nodes : undefined : nodes ? [nodes] : undefined; // Compute locations in the source for the given nodes/positions.\n\n\n  var _source = source;\n\n  if (!_source && _nodes) {\n    var node = _nodes[0];\n    _source = node && node.loc && node.loc.source;\n  }\n\n  var _positions = positions;\n\n  if (!_positions && _nodes) {\n    _positions = _nodes.reduce(function (list, node) {\n      if (node.loc) {\n        list.push(node.loc.start);\n      }\n\n      return list;\n    }, []);\n  }\n\n  if (_positions && _positions.length === 0) {\n    _positions = undefined;\n  }\n\n  var _locations;\n\n  if (positions && source) {\n    _locations = positions.map(function (pos) {\n      return getLocation(source, pos);\n    });\n  } else if (_nodes) {\n    _locations = _nodes.reduce(function (list, node) {\n      if (node.loc) {\n        list.push(getLocation(node.loc.source, node.loc.start));\n      }\n\n      return list;\n    }, []);\n  }\n\n  var _extensions = extensions;\n\n  if (_extensions == null && originalError != null) {\n    var originalExtensions = originalError.extensions;\n\n    if (isObjectLike(originalExtensions)) {\n      _extensions = originalExtensions;\n    }\n  }\n\n  Object.defineProperties(this, {\n    message: {\n      value: message,\n      // By being enumerable, JSON.stringify will include `message` in the\n      // resulting output. This ensures that the simplest possible GraphQL\n      // service adheres to the spec.\n      enumerable: true,\n      writable: true\n    },\n    locations: {\n      // Coercing falsey values to undefined ensures they will not be included\n      // in JSON.stringify() when not provided.\n      value: _locations || undefined,\n      // By being enumerable, JSON.stringify will include `locations` in the\n      // resulting output. This ensures that the simplest possible GraphQL\n      // service adheres to the spec.\n      enumerable: Boolean(_locations)\n    },\n    path: {\n      // Coercing falsey values to undefined ensures they will not be included\n      // in JSON.stringify() when not provided.\n      value: path || undefined,\n      // By being enumerable, JSON.stringify will include `path` in the\n      // resulting output. This ensures that the simplest possible GraphQL\n      // service adheres to the spec.\n      enumerable: Boolean(path)\n    },\n    nodes: {\n      value: _nodes || undefined\n    },\n    source: {\n      value: _source || undefined\n    },\n    positions: {\n      value: _positions || undefined\n    },\n    originalError: {\n      value: originalError\n    },\n    extensions: {\n      // Coercing falsey values to undefined ensures they will not be included\n      // in JSON.stringify() when not provided.\n      value: _extensions || undefined,\n      // By being enumerable, JSON.stringify will include `path` in the\n      // resulting output. This ensures that the simplest possible GraphQL\n      // service adheres to the spec.\n      enumerable: Boolean(_extensions)\n    }\n  }); // Include (non-enumerable) stack trace.\n\n  if (originalError && originalError.stack) {\n    Object.defineProperty(this, 'stack', {\n      value: originalError.stack,\n      writable: true,\n      configurable: true\n    });\n  } else if (Error.captureStackTrace) {\n    Error.captureStackTrace(this, GraphQLError);\n  } else {\n    Object.defineProperty(this, 'stack', {\n      value: Error().stack,\n      writable: true,\n      configurable: true\n    });\n  }\n}\nGraphQLError.prototype = Object.create(Error.prototype, {\n  constructor: {\n    value: GraphQLError\n  },\n  name: {\n    value: 'GraphQLError'\n  },\n  toString: {\n    value: function toString() {\n      return printError(this);\n    }\n  }\n});\n/**\n * Prints a GraphQLError to a string, representing useful location information\n * about the error's position in the source.\n */\n\nexport function printError(error) {\n  var output = error.message;\n\n  if (error.nodes) {\n    for (var _i2 = 0, _error$nodes2 = error.nodes; _i2 < _error$nodes2.length; _i2++) {\n      var node = _error$nodes2[_i2];\n\n      if (node.loc) {\n        output += '\\n\\n' + printLocation(node.loc);\n      }\n    }\n  } else if (error.source && error.locations) {\n    for (var _i4 = 0, _error$locations2 = error.locations; _i4 < _error$locations2.length; _i4++) {\n      var location = _error$locations2[_i4];\n      output += '\\n\\n' + printSourceLocation(error.source, location);\n    }\n  }\n\n  return output;\n}\n","import { GraphQLError } from './GraphQLError';\n/**\n * Produces a GraphQLError representing a syntax error, containing useful\n * descriptive information about the syntax error's position in the source.\n */\n\nexport function syntaxError(source, position, description) {\n  return new GraphQLError(\"Syntax Error: \".concat(description), undefined, source, [position]);\n}\n","/**\n * The set of allowed kind values for AST nodes.\n */\nexport var Kind = Object.freeze({\n  // Name\n  NAME: 'Name',\n  // Document\n  DOCUMENT: 'Document',\n  OPERATION_DEFINITION: 'OperationDefinition',\n  VARIABLE_DEFINITION: 'VariableDefinition',\n  SELECTION_SET: 'SelectionSet',\n  FIELD: 'Field',\n  ARGUMENT: 'Argument',\n  // Fragments\n  FRAGMENT_SPREAD: 'FragmentSpread',\n  INLINE_FRAGMENT: 'InlineFragment',\n  FRAGMENT_DEFINITION: 'FragmentDefinition',\n  // Values\n  VARIABLE: 'Variable',\n  INT: 'IntValue',\n  FLOAT: 'FloatValue',\n  STRING: 'StringValue',\n  BOOLEAN: 'BooleanValue',\n  NULL: 'NullValue',\n  ENUM: 'EnumValue',\n  LIST: 'ListValue',\n  OBJECT: 'ObjectValue',\n  OBJECT_FIELD: 'ObjectField',\n  // Directives\n  DIRECTIVE: 'Directive',\n  // Types\n  NAMED_TYPE: 'NamedType',\n  LIST_TYPE: 'ListType',\n  NON_NULL_TYPE: 'NonNullType',\n  // Type System Definitions\n  SCHEMA_DEFINITION: 'SchemaDefinition',\n  OPERATION_TYPE_DEFINITION: 'OperationTypeDefinition',\n  // Type Definitions\n  SCALAR_TYPE_DEFINITION: 'ScalarTypeDefinition',\n  OBJECT_TYPE_DEFINITION: 'ObjectTypeDefinition',\n  FIELD_DEFINITION: 'FieldDefinition',\n  INPUT_VALUE_DEFINITION: 'InputValueDefinition',\n  INTERFACE_TYPE_DEFINITION: 'InterfaceTypeDefinition',\n  UNION_TYPE_DEFINITION: 'UnionTypeDefinition',\n  ENUM_TYPE_DEFINITION: 'EnumTypeDefinition',\n  ENUM_VALUE_DEFINITION: 'EnumValueDefinition',\n  INPUT_OBJECT_TYPE_DEFINITION: 'InputObjectTypeDefinition',\n  // Directive Definitions\n  DIRECTIVE_DEFINITION: 'DirectiveDefinition',\n  // Type System Extensions\n  SCHEMA_EXTENSION: 'SchemaExtension',\n  // Type Extensions\n  SCALAR_TYPE_EXTENSION: 'ScalarTypeExtension',\n  OBJECT_TYPE_EXTENSION: 'ObjectTypeExtension',\n  INTERFACE_TYPE_EXTENSION: 'InterfaceTypeExtension',\n  UNION_TYPE_EXTENSION: 'UnionTypeExtension',\n  ENUM_TYPE_EXTENSION: 'EnumTypeExtension',\n  INPUT_OBJECT_TYPE_EXTENSION: 'InputObjectTypeExtension'\n});\n/**\n * The enum type representing the possible kind values of AST nodes.\n */\n","/**\n * The `defineToStringTag()` function checks first to see if the runtime\n * supports the `Symbol` class and then if the `Symbol.toStringTag` constant\n * is defined as a `Symbol` instance. If both conditions are met, the\n * Symbol.toStringTag property is defined as a getter that returns the\n * supplied class constructor's name.\n *\n * @method defineToStringTag\n *\n * @param {Class<any>} classObject a class such as Object, String, Number but\n * typically one of your own creation through the class keyword; `class A {}`,\n * for example.\n */\nexport default function defineToStringTag(classObject) {\n  if (typeof Symbol === 'function' && Symbol.toStringTag) {\n    Object.defineProperty(classObject.prototype, Symbol.toStringTag, {\n      get: function get() {\n        return this.constructor.name;\n      }\n    });\n  }\n}\n","import devAssert from '../jsutils/devAssert';\nimport defineToStringTag from '../jsutils/defineToStringTag';\n\n/**\n * A representation of source input to GraphQL.\n * `name` and `locationOffset` are optional. They are useful for clients who\n * store GraphQL documents in source files; for example, if the GraphQL input\n * starts at line 40 in a file named Foo.graphql, it might be useful for name to\n * be \"Foo.graphql\" and location to be `{ line: 40, column: 0 }`.\n * line and column in locationOffset are 1-indexed\n */\nexport var Source = function Source(body, name, locationOffset) {\n  this.body = body;\n  this.name = name || 'GraphQL request';\n  this.locationOffset = locationOffset || {\n    line: 1,\n    column: 1\n  };\n  this.locationOffset.line > 0 || devAssert(0, 'line in locationOffset is 1-indexed and must be positive');\n  this.locationOffset.column > 0 || devAssert(0, 'column in locationOffset is 1-indexed and must be positive');\n}; // Conditionally apply `[Symbol.toStringTag]` if `Symbol`s are supported\n\ndefineToStringTag(Source);\n","/**\n * An exported enum describing the different kinds of tokens that the\n * lexer emits.\n */\nexport var TokenKind = Object.freeze({\n  SOF: '<SOF>',\n  EOF: '<EOF>',\n  BANG: '!',\n  DOLLAR: '$',\n  AMP: '&',\n  PAREN_L: '(',\n  PAREN_R: ')',\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'\n});\n/**\n * The enum type representing the token kinds values.\n */\n","import defineToJSON from '../jsutils/defineToJSON';\nimport { syntaxError } from '../error/syntaxError';\nimport { dedentBlockStringValue } from './blockString';\nimport { TokenKind } from './tokenKind';\n/**\n * Given a Source object, this returns a Lexer for that source.\n * A Lexer is a stateful stream generator in that every time\n * it is advanced, it returns the next token in the Source. Assuming the\n * source lexes, the final Token emitted by the lexer will be of kind\n * EOF, after which the lexer will repeatedly return the same EOF token\n * whenever called.\n */\n\nexport function createLexer(source, options) {\n  var startOfFileToken = new Tok(TokenKind.SOF, 0, 0, 0, 0, null);\n  var lexer = {\n    source: source,\n    options: options,\n    lastToken: startOfFileToken,\n    token: startOfFileToken,\n    line: 1,\n    lineStart: 0,\n    advance: advanceLexer,\n    lookahead: lookahead\n  };\n  return lexer;\n}\n\nfunction advanceLexer() {\n  this.lastToken = this.token;\n  var token = this.token = this.lookahead();\n  return token;\n}\n\nfunction lookahead() {\n  var token = this.token;\n\n  if (token.kind !== TokenKind.EOF) {\n    do {\n      // Note: next is only mutable during parsing, so we cast to allow this.\n      token = token.next || (token.next = readToken(this, token));\n    } while (token.kind === TokenKind.COMMENT);\n  }\n\n  return token;\n}\n/**\n * The return type of createLexer.\n */\n\n\n// @internal\nexport function isPunctuatorToken(token) {\n  var kind = token.kind;\n  return kind === TokenKind.BANG || kind === TokenKind.DOLLAR || kind === TokenKind.AMP || kind === TokenKind.PAREN_L || kind === TokenKind.PAREN_R || kind === TokenKind.SPREAD || kind === TokenKind.COLON || kind === TokenKind.EQUALS || kind === TokenKind.AT || kind === TokenKind.BRACKET_L || kind === TokenKind.BRACKET_R || kind === TokenKind.BRACE_L || kind === TokenKind.PIPE || kind === TokenKind.BRACE_R;\n}\n/**\n * Helper function for constructing the Token object.\n */\n\nfunction Tok(kind, start, end, line, column, prev, value) {\n  this.kind = kind;\n  this.start = start;\n  this.end = end;\n  this.line = line;\n  this.column = column;\n  this.value = value;\n  this.prev = prev;\n  this.next = null;\n} // Print a simplified form when appearing in JSON/util.inspect.\n\n\ndefineToJSON(Tok, function () {\n  return {\n    kind: this.kind,\n    value: this.value,\n    line: this.line,\n    column: this.column\n  };\n});\n\nfunction printCharCode(code) {\n  return (// NaN/undefined represents access beyond the end of the file.\n    isNaN(code) ? TokenKind.EOF : // Trust JSON for ASCII.\n    code < 0x007f ? JSON.stringify(String.fromCharCode(code)) : // Otherwise print the escaped form.\n    \"\\\"\\\\u\".concat(('00' + code.toString(16).toUpperCase()).slice(-4), \"\\\"\")\n  );\n}\n/**\n * Gets the next token from the source starting at the given position.\n *\n * This skips over whitespace until it finds the next lexable token, then lexes\n * punctuators immediately or calls the appropriate helper function for more\n * complicated tokens.\n */\n\n\nfunction readToken(lexer, prev) {\n  var source = lexer.source;\n  var body = source.body;\n  var bodyLength = body.length;\n  var pos = positionAfterWhitespace(body, prev.end, lexer);\n  var line = lexer.line;\n  var col = 1 + pos - lexer.lineStart;\n\n  if (pos >= bodyLength) {\n    return new Tok(TokenKind.EOF, bodyLength, bodyLength, line, col, prev);\n  }\n\n  var code = body.charCodeAt(pos); // SourceCharacter\n\n  switch (code) {\n    // !\n    case 33:\n      return new Tok(TokenKind.BANG, pos, pos + 1, line, col, prev);\n    // #\n\n    case 35:\n      return readComment(source, pos, line, col, prev);\n    // $\n\n    case 36:\n      return new Tok(TokenKind.DOLLAR, pos, pos + 1, line, col, prev);\n    // &\n\n    case 38:\n      return new Tok(TokenKind.AMP, pos, pos + 1, line, col, prev);\n    // (\n\n    case 40:\n      return new Tok(TokenKind.PAREN_L, pos, pos + 1, line, col, prev);\n    // )\n\n    case 41:\n      return new Tok(TokenKind.PAREN_R, pos, pos + 1, line, col, prev);\n    // .\n\n    case 46:\n      if (body.charCodeAt(pos + 1) === 46 && body.charCodeAt(pos + 2) === 46) {\n        return new Tok(TokenKind.SPREAD, pos, pos + 3, line, col, prev);\n      }\n\n      break;\n    // :\n\n    case 58:\n      return new Tok(TokenKind.COLON, pos, pos + 1, line, col, prev);\n    // =\n\n    case 61:\n      return new Tok(TokenKind.EQUALS, pos, pos + 1, line, col, prev);\n    // @\n\n    case 64:\n      return new Tok(TokenKind.AT, pos, pos + 1, line, col, prev);\n    // [\n\n    case 91:\n      return new Tok(TokenKind.BRACKET_L, pos, pos + 1, line, col, prev);\n    // ]\n\n    case 93:\n      return new Tok(TokenKind.BRACKET_R, pos, pos + 1, line, col, prev);\n    // {\n\n    case 123:\n      return new Tok(TokenKind.BRACE_L, pos, pos + 1, line, col, prev);\n    // |\n\n    case 124:\n      return new Tok(TokenKind.PIPE, pos, pos + 1, line, col, prev);\n    // }\n\n    case 125:\n      return new Tok(TokenKind.BRACE_R, pos, pos + 1, line, col, prev);\n    // A-Z _ a-z\n\n    case 65:\n    case 66:\n    case 67:\n    case 68:\n    case 69:\n    case 70:\n    case 71:\n    case 72:\n    case 73:\n    case 74:\n    case 75:\n    case 76:\n    case 77:\n    case 78:\n    case 79:\n    case 80:\n    case 81:\n    case 82:\n    case 83:\n    case 84:\n    case 85:\n    case 86:\n    case 87:\n    case 88:\n    case 89:\n    case 90:\n    case 95:\n    case 97:\n    case 98:\n    case 99:\n    case 100:\n    case 101:\n    case 102:\n    case 103:\n    case 104:\n    case 105:\n    case 106:\n    case 107:\n    case 108:\n    case 109:\n    case 110:\n    case 111:\n    case 112:\n    case 113:\n    case 114:\n    case 115:\n    case 116:\n    case 117:\n    case 118:\n    case 119:\n    case 120:\n    case 121:\n    case 122:\n      return readName(source, pos, line, col, prev);\n    // - 0-9\n\n    case 45:\n    case 48:\n    case 49:\n    case 50:\n    case 51:\n    case 52:\n    case 53:\n    case 54:\n    case 55:\n    case 56:\n    case 57:\n      return readNumber(source, pos, code, line, col, prev);\n    // \"\n\n    case 34:\n      if (body.charCodeAt(pos + 1) === 34 && body.charCodeAt(pos + 2) === 34) {\n        return readBlockString(source, pos, line, col, prev, lexer);\n      }\n\n      return readString(source, pos, line, col, prev);\n  }\n\n  throw syntaxError(source, pos, unexpectedCharacterMessage(code));\n}\n/**\n * Report a message that an unexpected character was encountered.\n */\n\n\nfunction unexpectedCharacterMessage(code) {\n  if (code < 0x0020 && code !== 0x0009 && code !== 0x000a && code !== 0x000d) {\n    return \"Cannot contain the invalid character \".concat(printCharCode(code), \".\");\n  }\n\n  if (code === 39) {\n    // '\n    return 'Unexpected single quote character (\\'), did you mean to use a double quote (\")?';\n  }\n\n  return \"Cannot parse the unexpected character \".concat(printCharCode(code), \".\");\n}\n/**\n * Reads from body starting at startPosition until it finds a non-whitespace\n * character, then returns the position of that character for lexing.\n */\n\n\nfunction positionAfterWhitespace(body, startPosition, lexer) {\n  var bodyLength = body.length;\n  var position = startPosition;\n\n  while (position < bodyLength) {\n    var code = body.charCodeAt(position); // tab | space | comma | BOM\n\n    if (code === 9 || code === 32 || code === 44 || code === 0xfeff) {\n      ++position;\n    } else if (code === 10) {\n      // new line\n      ++position;\n      ++lexer.line;\n      lexer.lineStart = position;\n    } else if (code === 13) {\n      // carriage return\n      if (body.charCodeAt(position + 1) === 10) {\n        position += 2;\n      } else {\n        ++position;\n      }\n\n      ++lexer.line;\n      lexer.lineStart = position;\n    } else {\n      break;\n    }\n  }\n\n  return position;\n}\n/**\n * Reads a comment token from the source file.\n *\n * #[\\u0009\\u0020-\\uFFFF]*\n */\n\n\nfunction readComment(source, start, line, col, prev) {\n  var body = source.body;\n  var code;\n  var position = start;\n\n  do {\n    code = body.charCodeAt(++position);\n  } while (!isNaN(code) && ( // SourceCharacter but not LineTerminator\n  code > 0x001f || code === 0x0009));\n\n  return new Tok(TokenKind.COMMENT, start, position, line, col, prev, body.slice(start + 1, position));\n}\n/**\n * Reads a number token from the source file, either a float\n * or an int depending on whether a decimal point appears.\n *\n * Int:   -?(0|[1-9][0-9]*)\n * Float: -?(0|[1-9][0-9]*)(\\.[0-9]+)?((E|e)(+|-)?[0-9]+)?\n */\n\n\nfunction readNumber(source, start, firstCode, line, col, prev) {\n  var body = source.body;\n  var code = firstCode;\n  var position = start;\n  var isFloat = false;\n\n  if (code === 45) {\n    // -\n    code = body.charCodeAt(++position);\n  }\n\n  if (code === 48) {\n    // 0\n    code = body.charCodeAt(++position);\n\n    if (code >= 48 && code <= 57) {\n      throw syntaxError(source, position, \"Invalid number, unexpected digit after 0: \".concat(printCharCode(code), \".\"));\n    }\n  } else {\n    position = readDigits(source, position, code);\n    code = body.charCodeAt(position);\n  }\n\n  if (code === 46) {\n    // .\n    isFloat = true;\n    code = body.charCodeAt(++position);\n    position = readDigits(source, position, code);\n    code = body.charCodeAt(position);\n  }\n\n  if (code === 69 || code === 101) {\n    // E e\n    isFloat = true;\n    code = body.charCodeAt(++position);\n\n    if (code === 43 || code === 45) {\n      // + -\n      code = body.charCodeAt(++position);\n    }\n\n    position = readDigits(source, position, code);\n    code = body.charCodeAt(position);\n  } // Numbers cannot be followed by . or e\n\n\n  if (code === 46 || code === 69 || code === 101) {\n    throw syntaxError(source, position, \"Invalid number, expected digit but got: \".concat(printCharCode(code), \".\"));\n  }\n\n  return new Tok(isFloat ? TokenKind.FLOAT : TokenKind.INT, start, position, line, col, prev, body.slice(start, position));\n}\n/**\n * Returns the new position in the source after reading digits.\n */\n\n\nfunction readDigits(source, start, firstCode) {\n  var body = source.body;\n  var position = start;\n  var code = firstCode;\n\n  if (code >= 48 && code <= 57) {\n    // 0 - 9\n    do {\n      code = body.charCodeAt(++position);\n    } while (code >= 48 && code <= 57); // 0 - 9\n\n\n    return position;\n  }\n\n  throw syntaxError(source, position, \"Invalid number, expected digit but got: \".concat(printCharCode(code), \".\"));\n}\n/**\n * Reads a string token from the source file.\n *\n * \"([^\"\\\\\\u000A\\u000D]|(\\\\(u[0-9a-fA-F]{4}|[\"\\\\/bfnrt])))*\"\n */\n\n\nfunction readString(source, start, line, col, prev) {\n  var body = source.body;\n  var position = start + 1;\n  var chunkStart = position;\n  var code = 0;\n  var value = '';\n\n  while (position < body.length && !isNaN(code = body.charCodeAt(position)) && // not LineTerminator\n  code !== 0x000a && code !== 0x000d) {\n    // Closing Quote (\")\n    if (code === 34) {\n      value += body.slice(chunkStart, position);\n      return new Tok(TokenKind.STRING, start, position + 1, line, col, prev, value);\n    } // SourceCharacter\n\n\n    if (code < 0x0020 && code !== 0x0009) {\n      throw syntaxError(source, position, \"Invalid character within String: \".concat(printCharCode(code), \".\"));\n    }\n\n    ++position;\n\n    if (code === 92) {\n      // \\\n      value += body.slice(chunkStart, position - 1);\n      code = body.charCodeAt(position);\n\n      switch (code) {\n        case 34:\n          value += '\"';\n          break;\n\n        case 47:\n          value += '/';\n          break;\n\n        case 92:\n          value += '\\\\';\n          break;\n\n        case 98:\n          value += '\\b';\n          break;\n\n        case 102:\n          value += '\\f';\n          break;\n\n        case 110:\n          value += '\\n';\n          break;\n\n        case 114:\n          value += '\\r';\n          break;\n\n        case 116:\n          value += '\\t';\n          break;\n\n        case 117:\n          {\n            // uXXXX\n            var charCode = uniCharCode(body.charCodeAt(position + 1), body.charCodeAt(position + 2), body.charCodeAt(position + 3), body.charCodeAt(position + 4));\n\n            if (charCode < 0) {\n              var invalidSequence = body.slice(position + 1, position + 5);\n              throw syntaxError(source, position, \"Invalid character escape sequence: \\\\u\".concat(invalidSequence, \".\"));\n            }\n\n            value += String.fromCharCode(charCode);\n            position += 4;\n            break;\n          }\n\n        default:\n          throw syntaxError(source, position, \"Invalid character escape sequence: \\\\\".concat(String.fromCharCode(code), \".\"));\n      }\n\n      ++position;\n      chunkStart = position;\n    }\n  }\n\n  throw syntaxError(source, position, 'Unterminated string.');\n}\n/**\n * Reads a block string token from the source file.\n *\n * \"\"\"(\"?\"?(\\\\\"\"\"|\\\\(?!=\"\"\")|[^\"\\\\]))*\"\"\"\n */\n\n\nfunction readBlockString(source, start, line, col, prev, lexer) {\n  var body = source.body;\n  var position = start + 3;\n  var chunkStart = position;\n  var code = 0;\n  var rawValue = '';\n\n  while (position < body.length && !isNaN(code = body.charCodeAt(position))) {\n    // Closing Triple-Quote (\"\"\")\n    if (code === 34 && body.charCodeAt(position + 1) === 34 && body.charCodeAt(position + 2) === 34) {\n      rawValue += body.slice(chunkStart, position);\n      return new Tok(TokenKind.BLOCK_STRING, start, position + 3, line, col, prev, dedentBlockStringValue(rawValue));\n    } // SourceCharacter\n\n\n    if (code < 0x0020 && code !== 0x0009 && code !== 0x000a && code !== 0x000d) {\n      throw syntaxError(source, position, \"Invalid character within String: \".concat(printCharCode(code), \".\"));\n    }\n\n    if (code === 10) {\n      // new line\n      ++position;\n      ++lexer.line;\n      lexer.lineStart = position;\n    } else if (code === 13) {\n      // carriage return\n      if (body.charCodeAt(position + 1) === 10) {\n        position += 2;\n      } else {\n        ++position;\n      }\n\n      ++lexer.line;\n      lexer.lineStart = position;\n    } else if ( // Escape Triple-Quote (\\\"\"\")\n    code === 92 && body.charCodeAt(position + 1) === 34 && body.charCodeAt(position + 2) === 34 && body.charCodeAt(position + 3) === 34) {\n      rawValue += body.slice(chunkStart, position) + '\"\"\"';\n      position += 4;\n      chunkStart = position;\n    } else {\n      ++position;\n    }\n  }\n\n  throw syntaxError(source, position, 'Unterminated string.');\n}\n/**\n * Converts four hexadecimal chars to the integer that the\n * string represents. For example, uniCharCode('0','0','0','f')\n * will return 15, and uniCharCode('0','0','f','f') returns 255.\n *\n * Returns a negative number on error, if a char was invalid.\n *\n * This is implemented by noting that char2hex() returns -1 on error,\n * which means the result of ORing the char2hex() will also be negative.\n */\n\n\nfunction uniCharCode(a, b, c, d) {\n  return char2hex(a) << 12 | char2hex(b) << 8 | char2hex(c) << 4 | char2hex(d);\n}\n/**\n * Converts a hex character to its integer value.\n * '0' becomes 0, '9' becomes 9\n * 'A' becomes 10, 'F' becomes 15\n * 'a' becomes 10, 'f' becomes 15\n *\n * Returns -1 on error.\n */\n\n\nfunction char2hex(a) {\n  return a >= 48 && a <= 57 ? a - 48 // 0-9\n  : a >= 65 && a <= 70 ? a - 55 // A-F\n  : a >= 97 && a <= 102 ? a - 87 // a-f\n  : -1;\n}\n/**\n * Reads an alphanumeric + underscore name from the source.\n *\n * [_A-Za-z][_0-9A-Za-z]*\n */\n\n\nfunction readName(source, start, line, col, prev) {\n  var body = source.body;\n  var bodyLength = body.length;\n  var position = start + 1;\n  var code = 0;\n\n  while (position !== bodyLength && !isNaN(code = body.charCodeAt(position)) && (code === 95 || // _\n  code >= 48 && code <= 57 || // 0-9\n  code >= 65 && code <= 90 || // A-Z\n  code >= 97 && code <= 122) // a-z\n  ) {\n    ++position;\n  }\n\n  return new Tok(TokenKind.NAME, start, position, line, col, prev, body.slice(start, position));\n}\n","/**\n * The set of allowed directive location values.\n */\nexport var DirectiveLocation = Object.freeze({\n  // Request Definitions\n  QUERY: 'QUERY',\n  MUTATION: 'MUTATION',\n  SUBSCRIPTION: 'SUBSCRIPTION',\n  FIELD: 'FIELD',\n  FRAGMENT_DEFINITION: 'FRAGMENT_DEFINITION',\n  FRAGMENT_SPREAD: 'FRAGMENT_SPREAD',\n  INLINE_FRAGMENT: 'INLINE_FRAGMENT',\n  VARIABLE_DEFINITION: 'VARIABLE_DEFINITION',\n  // Type System Definitions\n  SCHEMA: 'SCHEMA',\n  SCALAR: 'SCALAR',\n  OBJECT: 'OBJECT',\n  FIELD_DEFINITION: 'FIELD_DEFINITION',\n  ARGUMENT_DEFINITION: 'ARGUMENT_DEFINITION',\n  INTERFACE: 'INTERFACE',\n  UNION: 'UNION',\n  ENUM: 'ENUM',\n  ENUM_VALUE: 'ENUM_VALUE',\n  INPUT_OBJECT: 'INPUT_OBJECT',\n  INPUT_FIELD_DEFINITION: 'INPUT_FIELD_DEFINITION'\n});\n/**\n * The enum type representing the directive location values.\n */\n","import inspect from '../jsutils/inspect';\nimport devAssert from '../jsutils/devAssert';\nimport defineToJSON from '../jsutils/defineToJSON';\nimport { syntaxError } from '../error/syntaxError';\nimport { Kind } from './kinds';\nimport { Source } from './source';\nimport { createLexer } from './lexer';\nimport { DirectiveLocation } from './directiveLocation';\nimport { TokenKind } from './tokenKind';\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  var 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  var parser = new Parser(source, options);\n  parser.expectToken(TokenKind.SOF);\n  var value = parser.parseValueLiteral(false);\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  var parser = new Parser(source, options);\n  parser.expectToken(TokenKind.SOF);\n  var type = parser.parseTypeReference();\n  parser.expectToken(TokenKind.EOF);\n  return type;\n}\n\nvar Parser =\n/*#__PURE__*/\nfunction () {\n  function Parser(source, options) {\n    var sourceObj = typeof source === 'string' ? new Source(source) : source;\n    sourceObj instanceof Source || devAssert(0, \"Must provide Source. Received: \".concat(inspect(sourceObj)));\n    this._lexer = createLexer(sourceObj);\n    this._options = options || {};\n  }\n  /**\n   * Converts a name lex token into a name parse node.\n   */\n\n\n  var _proto = Parser.prototype;\n\n  _proto.parseName = function parseName() {\n    var token = this.expectToken(TokenKind.NAME);\n    return {\n      kind: Kind.NAME,\n      value: token.value,\n      loc: this.loc(token)\n    };\n  } // Implements the parsing rules in the Document section.\n\n  /**\n   * Document : Definition+\n   */\n  ;\n\n  _proto.parseDocument = function parseDocument() {\n    var start = this._lexer.token;\n    return {\n      kind: Kind.DOCUMENT,\n      definitions: this.many(TokenKind.SOF, this.parseDefinition, TokenKind.EOF),\n      loc: this.loc(start)\n    };\n  }\n  /**\n   * Definition :\n   *   - ExecutableDefinition\n   *   - TypeSystemDefinition\n   *   - TypeSystemExtension\n   *\n   * ExecutableDefinition :\n   *   - OperationDefinition\n   *   - FragmentDefinition\n   */\n  ;\n\n  _proto.parseDefinition = function parseDefinition() {\n    if (this.peek(TokenKind.NAME)) {\n      switch (this._lexer.token.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 'schema':\n        case 'scalar':\n        case 'type':\n        case 'interface':\n        case 'union':\n        case 'enum':\n        case 'input':\n        case 'directive':\n          return this.parseTypeSystemDefinition();\n\n        case 'extend':\n          return this.parseTypeSystemExtension();\n      }\n    } else if (this.peek(TokenKind.BRACE_L)) {\n      return this.parseOperationDefinition();\n    } else if (this.peekDescription()) {\n      return this.parseTypeSystemDefinition();\n    }\n\n    throw this.unexpected();\n  } // Implements the parsing rules in the Operations section.\n\n  /**\n   * OperationDefinition :\n   *  - SelectionSet\n   *  - OperationType Name? VariableDefinitions? Directives? SelectionSet\n   */\n  ;\n\n  _proto.parseOperationDefinition = function parseOperationDefinition() {\n    var start = this._lexer.token;\n\n    if (this.peek(TokenKind.BRACE_L)) {\n      return {\n        kind: Kind.OPERATION_DEFINITION,\n        operation: 'query',\n        name: undefined,\n        variableDefinitions: [],\n        directives: [],\n        selectionSet: this.parseSelectionSet(),\n        loc: this.loc(start)\n      };\n    }\n\n    var operation = this.parseOperationType();\n    var name;\n\n    if (this.peek(TokenKind.NAME)) {\n      name = this.parseName();\n    }\n\n    return {\n      kind: Kind.OPERATION_DEFINITION,\n      operation: operation,\n      name: name,\n      variableDefinitions: this.parseVariableDefinitions(),\n      directives: this.parseDirectives(false),\n      selectionSet: this.parseSelectionSet(),\n      loc: this.loc(start)\n    };\n  }\n  /**\n   * OperationType : one of query mutation subscription\n   */\n  ;\n\n  _proto.parseOperationType = function parseOperationType() {\n    var operationToken = this.expectToken(TokenKind.NAME);\n\n    switch (operationToken.value) {\n      case 'query':\n        return 'query';\n\n      case 'mutation':\n        return 'mutation';\n\n      case 'subscription':\n        return 'subscription';\n    }\n\n    throw this.unexpected(operationToken);\n  }\n  /**\n   * VariableDefinitions : ( VariableDefinition+ )\n   */\n  ;\n\n  _proto.parseVariableDefinitions = function parseVariableDefinitions() {\n    return this.optionalMany(TokenKind.PAREN_L, this.parseVariableDefinition, TokenKind.PAREN_R);\n  }\n  /**\n   * VariableDefinition : Variable : Type DefaultValue? Directives[Const]?\n   */\n  ;\n\n  _proto.parseVariableDefinition = function parseVariableDefinition() {\n    var start = this._lexer.token;\n    return {\n      kind: Kind.VARIABLE_DEFINITION,\n      variable: this.parseVariable(),\n      type: (this.expectToken(TokenKind.COLON), this.parseTypeReference()),\n      defaultValue: this.expectOptionalToken(TokenKind.EQUALS) ? this.parseValueLiteral(true) : undefined,\n      directives: this.parseDirectives(true),\n      loc: this.loc(start)\n    };\n  }\n  /**\n   * Variable : $ Name\n   */\n  ;\n\n  _proto.parseVariable = function parseVariable() {\n    var start = this._lexer.token;\n    this.expectToken(TokenKind.DOLLAR);\n    return {\n      kind: Kind.VARIABLE,\n      name: this.parseName(),\n      loc: this.loc(start)\n    };\n  }\n  /**\n   * SelectionSet : { Selection+ }\n   */\n  ;\n\n  _proto.parseSelectionSet = function parseSelectionSet() {\n    var start = this._lexer.token;\n    return {\n      kind: Kind.SELECTION_SET,\n      selections: this.many(TokenKind.BRACE_L, this.parseSelection, TokenKind.BRACE_R),\n      loc: this.loc(start)\n    };\n  }\n  /**\n   * Selection :\n   *   - Field\n   *   - FragmentSpread\n   *   - InlineFragment\n   */\n  ;\n\n  _proto.parseSelection = function parseSelection() {\n    return this.peek(TokenKind.SPREAD) ? this.parseFragment() : this.parseField();\n  }\n  /**\n   * Field : Alias? Name Arguments? Directives? SelectionSet?\n   *\n   * Alias : Name :\n   */\n  ;\n\n  _proto.parseField = function parseField() {\n    var start = this._lexer.token;\n    var nameOrAlias = this.parseName();\n    var alias;\n    var name;\n\n    if (this.expectOptionalToken(TokenKind.COLON)) {\n      alias = nameOrAlias;\n      name = this.parseName();\n    } else {\n      name = nameOrAlias;\n    }\n\n    return {\n      kind: Kind.FIELD,\n      alias: alias,\n      name: name,\n      arguments: this.parseArguments(false),\n      directives: this.parseDirectives(false),\n      selectionSet: this.peek(TokenKind.BRACE_L) ? this.parseSelectionSet() : undefined,\n      loc: this.loc(start)\n    };\n  }\n  /**\n   * Arguments[Const] : ( Argument[?Const]+ )\n   */\n  ;\n\n  _proto.parseArguments = function parseArguments(isConst) {\n    var 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\n  _proto.parseArgument = function parseArgument() {\n    var start = this._lexer.token;\n    var name = this.parseName();\n    this.expectToken(TokenKind.COLON);\n    return {\n      kind: Kind.ARGUMENT,\n      name: name,\n      value: this.parseValueLiteral(false),\n      loc: this.loc(start)\n    };\n  };\n\n  _proto.parseConstArgument = function parseConstArgument() {\n    var start = this._lexer.token;\n    return {\n      kind: Kind.ARGUMENT,\n      name: this.parseName(),\n      value: (this.expectToken(TokenKind.COLON), this.parseValueLiteral(true)),\n      loc: this.loc(start)\n    };\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\n  _proto.parseFragment = function parseFragment() {\n    var start = this._lexer.token;\n    this.expectToken(TokenKind.SPREAD);\n    var hasTypeCondition = this.expectOptionalKeyword('on');\n\n    if (!hasTypeCondition && this.peek(TokenKind.NAME)) {\n      return {\n        kind: Kind.FRAGMENT_SPREAD,\n        name: this.parseFragmentName(),\n        directives: this.parseDirectives(false),\n        loc: this.loc(start)\n      };\n    }\n\n    return {\n      kind: Kind.INLINE_FRAGMENT,\n      typeCondition: hasTypeCondition ? this.parseNamedType() : undefined,\n      directives: this.parseDirectives(false),\n      selectionSet: this.parseSelectionSet(),\n      loc: this.loc(start)\n    };\n  }\n  /**\n   * FragmentDefinition :\n   *   - fragment FragmentName on TypeCondition Directives? SelectionSet\n   *\n   * TypeCondition : NamedType\n   */\n  ;\n\n  _proto.parseFragmentDefinition = function parseFragmentDefinition() {\n    var start = this._lexer.token;\n    this.expectKeyword('fragment'); // Experimental 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.experimentalFragmentVariables) {\n      return {\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        loc: this.loc(start)\n      };\n    }\n\n    return {\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      loc: this.loc(start)\n    };\n  }\n  /**\n   * FragmentName : Name but not `on`\n   */\n  ;\n\n  _proto.parseFragmentName = function 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\n  _proto.parseValueLiteral = function parseValueLiteral(isConst) {\n    var 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._lexer.advance();\n\n        return {\n          kind: Kind.INT,\n          value: token.value,\n          loc: this.loc(token)\n        };\n\n      case TokenKind.FLOAT:\n        this._lexer.advance();\n\n        return {\n          kind: Kind.FLOAT,\n          value: token.value,\n          loc: this.loc(token)\n        };\n\n      case TokenKind.STRING:\n      case TokenKind.BLOCK_STRING:\n        return this.parseStringLiteral();\n\n      case TokenKind.NAME:\n        if (token.value === 'true' || token.value === 'false') {\n          this._lexer.advance();\n\n          return {\n            kind: Kind.BOOLEAN,\n            value: token.value === 'true',\n            loc: this.loc(token)\n          };\n        } else if (token.value === 'null') {\n          this._lexer.advance();\n\n          return {\n            kind: Kind.NULL,\n            loc: this.loc(token)\n          };\n        }\n\n        this._lexer.advance();\n\n        return {\n          kind: Kind.ENUM,\n          value: token.value,\n          loc: this.loc(token)\n        };\n\n      case TokenKind.DOLLAR:\n        if (!isConst) {\n          return this.parseVariable();\n        }\n\n        break;\n    }\n\n    throw this.unexpected();\n  };\n\n  _proto.parseStringLiteral = function parseStringLiteral() {\n    var token = this._lexer.token;\n\n    this._lexer.advance();\n\n    return {\n      kind: Kind.STRING,\n      value: token.value,\n      block: token.kind === TokenKind.BLOCK_STRING,\n      loc: this.loc(token)\n    };\n  }\n  /**\n   * ListValue[Const] :\n   *   - [ ]\n   *   - [ Value[?Const]+ ]\n   */\n  ;\n\n  _proto.parseList = function parseList(isConst) {\n    var _this = this;\n\n    var start = this._lexer.token;\n\n    var item = function item() {\n      return _this.parseValueLiteral(isConst);\n    };\n\n    return {\n      kind: Kind.LIST,\n      values: this.any(TokenKind.BRACKET_L, item, TokenKind.BRACKET_R),\n      loc: this.loc(start)\n    };\n  }\n  /**\n   * ObjectValue[Const] :\n   *   - { }\n   *   - { ObjectField[?Const]+ }\n   */\n  ;\n\n  _proto.parseObject = function parseObject(isConst) {\n    var _this2 = this;\n\n    var start = this._lexer.token;\n\n    var item = function item() {\n      return _this2.parseObjectField(isConst);\n    };\n\n    return {\n      kind: Kind.OBJECT,\n      fields: this.any(TokenKind.BRACE_L, item, TokenKind.BRACE_R),\n      loc: this.loc(start)\n    };\n  }\n  /**\n   * ObjectField[Const] : Name : Value[?Const]\n   */\n  ;\n\n  _proto.parseObjectField = function parseObjectField(isConst) {\n    var start = this._lexer.token;\n    var name = this.parseName();\n    this.expectToken(TokenKind.COLON);\n    return {\n      kind: Kind.OBJECT_FIELD,\n      name: name,\n      value: this.parseValueLiteral(isConst),\n      loc: this.loc(start)\n    };\n  } // Implements the parsing rules in the Directives section.\n\n  /**\n   * Directives[Const] : Directive[?Const]+\n   */\n  ;\n\n  _proto.parseDirectives = function parseDirectives(isConst) {\n    var directives = [];\n\n    while (this.peek(TokenKind.AT)) {\n      directives.push(this.parseDirective(isConst));\n    }\n\n    return directives;\n  }\n  /**\n   * Directive[Const] : @ Name Arguments[?Const]?\n   */\n  ;\n\n  _proto.parseDirective = function parseDirective(isConst) {\n    var start = this._lexer.token;\n    this.expectToken(TokenKind.AT);\n    return {\n      kind: Kind.DIRECTIVE,\n      name: this.parseName(),\n      arguments: this.parseArguments(isConst),\n      loc: this.loc(start)\n    };\n  } // Implements the parsing rules in the Types section.\n\n  /**\n   * Type :\n   *   - NamedType\n   *   - ListType\n   *   - NonNullType\n   */\n  ;\n\n  _proto.parseTypeReference = function parseTypeReference() {\n    var start = this._lexer.token;\n    var type;\n\n    if (this.expectOptionalToken(TokenKind.BRACKET_L)) {\n      type = this.parseTypeReference();\n      this.expectToken(TokenKind.BRACKET_R);\n      type = {\n        kind: Kind.LIST_TYPE,\n        type: type,\n        loc: this.loc(start)\n      };\n    } else {\n      type = this.parseNamedType();\n    }\n\n    if (this.expectOptionalToken(TokenKind.BANG)) {\n      return {\n        kind: Kind.NON_NULL_TYPE,\n        type: type,\n        loc: this.loc(start)\n      };\n    }\n\n    return type;\n  }\n  /**\n   * NamedType : Name\n   */\n  ;\n\n  _proto.parseNamedType = function parseNamedType() {\n    var start = this._lexer.token;\n    return {\n      kind: Kind.NAMED_TYPE,\n      name: this.parseName(),\n      loc: this.loc(start)\n    };\n  } // Implements the parsing rules in the Type Definition section.\n\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\n  _proto.parseTypeSystemDefinition = function parseTypeSystemDefinition() {\n    // Many definitions begin with a description and require a lookahead.\n    var keywordToken = this.peekDescription() ? this._lexer.lookahead() : 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\n    throw this.unexpected(keywordToken);\n  };\n\n  _proto.peekDescription = function peekDescription() {\n    return this.peek(TokenKind.STRING) || this.peek(TokenKind.BLOCK_STRING);\n  }\n  /**\n   * Description : StringValue\n   */\n  ;\n\n  _proto.parseDescription = function parseDescription() {\n    if (this.peekDescription()) {\n      return this.parseStringLiteral();\n    }\n  }\n  /**\n   * SchemaDefinition : schema Directives[Const]? { OperationTypeDefinition+ }\n   */\n  ;\n\n  _proto.parseSchemaDefinition = function parseSchemaDefinition() {\n    var start = this._lexer.token;\n    this.expectKeyword('schema');\n    var directives = this.parseDirectives(true);\n    var operationTypes = this.many(TokenKind.BRACE_L, this.parseOperationTypeDefinition, TokenKind.BRACE_R);\n    return {\n      kind: Kind.SCHEMA_DEFINITION,\n      directives: directives,\n      operationTypes: operationTypes,\n      loc: this.loc(start)\n    };\n  }\n  /**\n   * OperationTypeDefinition : OperationType : NamedType\n   */\n  ;\n\n  _proto.parseOperationTypeDefinition = function parseOperationTypeDefinition() {\n    var start = this._lexer.token;\n    var operation = this.parseOperationType();\n    this.expectToken(TokenKind.COLON);\n    var type = this.parseNamedType();\n    return {\n      kind: Kind.OPERATION_TYPE_DEFINITION,\n      operation: operation,\n      type: type,\n      loc: this.loc(start)\n    };\n  }\n  /**\n   * ScalarTypeDefinition : Description? scalar Name Directives[Const]?\n   */\n  ;\n\n  _proto.parseScalarTypeDefinition = function parseScalarTypeDefinition() {\n    var start = this._lexer.token;\n    var description = this.parseDescription();\n    this.expectKeyword('scalar');\n    var name = this.parseName();\n    var directives = this.parseDirectives(true);\n    return {\n      kind: Kind.SCALAR_TYPE_DEFINITION,\n      description: description,\n      name: name,\n      directives: directives,\n      loc: this.loc(start)\n    };\n  }\n  /**\n   * ObjectTypeDefinition :\n   *   Description?\n   *   type Name ImplementsInterfaces? Directives[Const]? FieldsDefinition?\n   */\n  ;\n\n  _proto.parseObjectTypeDefinition = function parseObjectTypeDefinition() {\n    var start = this._lexer.token;\n    var description = this.parseDescription();\n    this.expectKeyword('type');\n    var name = this.parseName();\n    var interfaces = this.parseImplementsInterfaces();\n    var directives = this.parseDirectives(true);\n    var fields = this.parseFieldsDefinition();\n    return {\n      kind: Kind.OBJECT_TYPE_DEFINITION,\n      description: description,\n      name: name,\n      interfaces: interfaces,\n      directives: directives,\n      fields: fields,\n      loc: this.loc(start)\n    };\n  }\n  /**\n   * ImplementsInterfaces :\n   *   - implements `&`? NamedType\n   *   - ImplementsInterfaces & NamedType\n   */\n  ;\n\n  _proto.parseImplementsInterfaces = function parseImplementsInterfaces() {\n    var types = [];\n\n    if (this.expectOptionalKeyword('implements')) {\n      // Optional leading ampersand\n      this.expectOptionalToken(TokenKind.AMP);\n\n      do {\n        types.push(this.parseNamedType());\n      } while (this.expectOptionalToken(TokenKind.AMP) || // Legacy support for the SDL?\n      this._options.allowLegacySDLImplementsInterfaces && this.peek(TokenKind.NAME));\n    }\n\n    return types;\n  }\n  /**\n   * FieldsDefinition : { FieldDefinition+ }\n   */\n  ;\n\n  _proto.parseFieldsDefinition = function parseFieldsDefinition() {\n    // Legacy support for the SDL?\n    if (this._options.allowLegacySDLEmptyFields && this.peek(TokenKind.BRACE_L) && this._lexer.lookahead().kind === TokenKind.BRACE_R) {\n      this._lexer.advance();\n\n      this._lexer.advance();\n\n      return [];\n    }\n\n    return this.optionalMany(TokenKind.BRACE_L, this.parseFieldDefinition, TokenKind.BRACE_R);\n  }\n  /**\n   * FieldDefinition :\n   *   - Description? Name ArgumentsDefinition? : Type Directives[Const]?\n   */\n  ;\n\n  _proto.parseFieldDefinition = function parseFieldDefinition() {\n    var start = this._lexer.token;\n    var description = this.parseDescription();\n    var name = this.parseName();\n    var args = this.parseArgumentDefs();\n    this.expectToken(TokenKind.COLON);\n    var type = this.parseTypeReference();\n    var directives = this.parseDirectives(true);\n    return {\n      kind: Kind.FIELD_DEFINITION,\n      description: description,\n      name: name,\n      arguments: args,\n      type: type,\n      directives: directives,\n      loc: this.loc(start)\n    };\n  }\n  /**\n   * ArgumentsDefinition : ( InputValueDefinition+ )\n   */\n  ;\n\n  _proto.parseArgumentDefs = function parseArgumentDefs() {\n    return this.optionalMany(TokenKind.PAREN_L, this.parseInputValueDef, TokenKind.PAREN_R);\n  }\n  /**\n   * InputValueDefinition :\n   *   - Description? Name : Type DefaultValue? Directives[Const]?\n   */\n  ;\n\n  _proto.parseInputValueDef = function parseInputValueDef() {\n    var start = this._lexer.token;\n    var description = this.parseDescription();\n    var name = this.parseName();\n    this.expectToken(TokenKind.COLON);\n    var type = this.parseTypeReference();\n    var defaultValue;\n\n    if (this.expectOptionalToken(TokenKind.EQUALS)) {\n      defaultValue = this.parseValueLiteral(true);\n    }\n\n    var directives = this.parseDirectives(true);\n    return {\n      kind: Kind.INPUT_VALUE_DEFINITION,\n      description: description,\n      name: name,\n      type: type,\n      defaultValue: defaultValue,\n      directives: directives,\n      loc: this.loc(start)\n    };\n  }\n  /**\n   * InterfaceTypeDefinition :\n   *   - Description? interface Name Directives[Const]? FieldsDefinition?\n   */\n  ;\n\n  _proto.parseInterfaceTypeDefinition = function parseInterfaceTypeDefinition() {\n    var start = this._lexer.token;\n    var description = this.parseDescription();\n    this.expectKeyword('interface');\n    var name = this.parseName();\n    var directives = this.parseDirectives(true);\n    var fields = this.parseFieldsDefinition();\n    return {\n      kind: Kind.INTERFACE_TYPE_DEFINITION,\n      description: description,\n      name: name,\n      directives: directives,\n      fields: fields,\n      loc: this.loc(start)\n    };\n  }\n  /**\n   * UnionTypeDefinition :\n   *   - Description? union Name Directives[Const]? UnionMemberTypes?\n   */\n  ;\n\n  _proto.parseUnionTypeDefinition = function parseUnionTypeDefinition() {\n    var start = this._lexer.token;\n    var description = this.parseDescription();\n    this.expectKeyword('union');\n    var name = this.parseName();\n    var directives = this.parseDirectives(true);\n    var types = this.parseUnionMemberTypes();\n    return {\n      kind: Kind.UNION_TYPE_DEFINITION,\n      description: description,\n      name: name,\n      directives: directives,\n      types: types,\n      loc: this.loc(start)\n    };\n  }\n  /**\n   * UnionMemberTypes :\n   *   - = `|`? NamedType\n   *   - UnionMemberTypes | NamedType\n   */\n  ;\n\n  _proto.parseUnionMemberTypes = function parseUnionMemberTypes() {\n    var types = [];\n\n    if (this.expectOptionalToken(TokenKind.EQUALS)) {\n      // Optional leading pipe\n      this.expectOptionalToken(TokenKind.PIPE);\n\n      do {\n        types.push(this.parseNamedType());\n      } while (this.expectOptionalToken(TokenKind.PIPE));\n    }\n\n    return types;\n  }\n  /**\n   * EnumTypeDefinition :\n   *   - Description? enum Name Directives[Const]? EnumValuesDefinition?\n   */\n  ;\n\n  _proto.parseEnumTypeDefinition = function parseEnumTypeDefinition() {\n    var start = this._lexer.token;\n    var description = this.parseDescription();\n    this.expectKeyword('enum');\n    var name = this.parseName();\n    var directives = this.parseDirectives(true);\n    var values = this.parseEnumValuesDefinition();\n    return {\n      kind: Kind.ENUM_TYPE_DEFINITION,\n      description: description,\n      name: name,\n      directives: directives,\n      values: values,\n      loc: this.loc(start)\n    };\n  }\n  /**\n   * EnumValuesDefinition : { EnumValueDefinition+ }\n   */\n  ;\n\n  _proto.parseEnumValuesDefinition = function parseEnumValuesDefinition() {\n    return this.optionalMany(TokenKind.BRACE_L, this.parseEnumValueDefinition, TokenKind.BRACE_R);\n  }\n  /**\n   * EnumValueDefinition : Description? EnumValue Directives[Const]?\n   *\n   * EnumValue : Name\n   */\n  ;\n\n  _proto.parseEnumValueDefinition = function parseEnumValueDefinition() {\n    var start = this._lexer.token;\n    var description = this.parseDescription();\n    var name = this.parseName();\n    var directives = this.parseDirectives(true);\n    return {\n      kind: Kind.ENUM_VALUE_DEFINITION,\n      description: description,\n      name: name,\n      directives: directives,\n      loc: this.loc(start)\n    };\n  }\n  /**\n   * InputObjectTypeDefinition :\n   *   - Description? input Name Directives[Const]? InputFieldsDefinition?\n   */\n  ;\n\n  _proto.parseInputObjectTypeDefinition = function parseInputObjectTypeDefinition() {\n    var start = this._lexer.token;\n    var description = this.parseDescription();\n    this.expectKeyword('input');\n    var name = this.parseName();\n    var directives = this.parseDirectives(true);\n    var fields = this.parseInputFieldsDefinition();\n    return {\n      kind: Kind.INPUT_OBJECT_TYPE_DEFINITION,\n      description: description,\n      name: name,\n      directives: directives,\n      fields: fields,\n      loc: this.loc(start)\n    };\n  }\n  /**\n   * InputFieldsDefinition : { InputValueDefinition+ }\n   */\n  ;\n\n  _proto.parseInputFieldsDefinition = function parseInputFieldsDefinition() {\n    return this.optionalMany(TokenKind.BRACE_L, this.parseInputValueDef, TokenKind.BRACE_R);\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\n  _proto.parseTypeSystemExtension = function parseTypeSystemExtension() {\n    var 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   * SchemaExtension :\n   *  - extend schema Directives[Const]? { OperationTypeDefinition+ }\n   *  - extend schema Directives[Const]\n   */\n  ;\n\n  _proto.parseSchemaExtension = function parseSchemaExtension() {\n    var start = this._lexer.token;\n    this.expectKeyword('extend');\n    this.expectKeyword('schema');\n    var directives = this.parseDirectives(true);\n    var operationTypes = this.optionalMany(TokenKind.BRACE_L, this.parseOperationTypeDefinition, TokenKind.BRACE_R);\n\n    if (directives.length === 0 && operationTypes.length === 0) {\n      throw this.unexpected();\n    }\n\n    return {\n      kind: Kind.SCHEMA_EXTENSION,\n      directives: directives,\n      operationTypes: operationTypes,\n      loc: this.loc(start)\n    };\n  }\n  /**\n   * ScalarTypeExtension :\n   *   - extend scalar Name Directives[Const]\n   */\n  ;\n\n  _proto.parseScalarTypeExtension = function parseScalarTypeExtension() {\n    var start = this._lexer.token;\n    this.expectKeyword('extend');\n    this.expectKeyword('scalar');\n    var name = this.parseName();\n    var directives = this.parseDirectives(true);\n\n    if (directives.length === 0) {\n      throw this.unexpected();\n    }\n\n    return {\n      kind: Kind.SCALAR_TYPE_EXTENSION,\n      name: name,\n      directives: directives,\n      loc: this.loc(start)\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\n  _proto.parseObjectTypeExtension = function parseObjectTypeExtension() {\n    var start = this._lexer.token;\n    this.expectKeyword('extend');\n    this.expectKeyword('type');\n    var name = this.parseName();\n    var interfaces = this.parseImplementsInterfaces();\n    var directives = this.parseDirectives(true);\n    var fields = this.parseFieldsDefinition();\n\n    if (interfaces.length === 0 && directives.length === 0 && fields.length === 0) {\n      throw this.unexpected();\n    }\n\n    return {\n      kind: Kind.OBJECT_TYPE_EXTENSION,\n      name: name,\n      interfaces: interfaces,\n      directives: directives,\n      fields: fields,\n      loc: this.loc(start)\n    };\n  }\n  /**\n   * InterfaceTypeExtension :\n   *   - extend interface Name Directives[Const]? FieldsDefinition\n   *   - extend interface Name Directives[Const]\n   */\n  ;\n\n  _proto.parseInterfaceTypeExtension = function parseInterfaceTypeExtension() {\n    var start = this._lexer.token;\n    this.expectKeyword('extend');\n    this.expectKeyword('interface');\n    var name = this.parseName();\n    var directives = this.parseDirectives(true);\n    var fields = this.parseFieldsDefinition();\n\n    if (directives.length === 0 && fields.length === 0) {\n      throw this.unexpected();\n    }\n\n    return {\n      kind: Kind.INTERFACE_TYPE_EXTENSION,\n      name: name,\n      directives: directives,\n      fields: fields,\n      loc: this.loc(start)\n    };\n  }\n  /**\n   * UnionTypeExtension :\n   *   - extend union Name Directives[Const]? UnionMemberTypes\n   *   - extend union Name Directives[Const]\n   */\n  ;\n\n  _proto.parseUnionTypeExtension = function parseUnionTypeExtension() {\n    var start = this._lexer.token;\n    this.expectKeyword('extend');\n    this.expectKeyword('union');\n    var name = this.parseName();\n    var directives = this.parseDirectives(true);\n    var types = this.parseUnionMemberTypes();\n\n    if (directives.length === 0 && types.length === 0) {\n      throw this.unexpected();\n    }\n\n    return {\n      kind: Kind.UNION_TYPE_EXTENSION,\n      name: name,\n      directives: directives,\n      types: types,\n      loc: this.loc(start)\n    };\n  }\n  /**\n   * EnumTypeExtension :\n   *   - extend enum Name Directives[Const]? EnumValuesDefinition\n   *   - extend enum Name Directives[Const]\n   */\n  ;\n\n  _proto.parseEnumTypeExtension = function parseEnumTypeExtension() {\n    var start = this._lexer.token;\n    this.expectKeyword('extend');\n    this.expectKeyword('enum');\n    var name = this.parseName();\n    var directives = this.parseDirectives(true);\n    var values = this.parseEnumValuesDefinition();\n\n    if (directives.length === 0 && values.length === 0) {\n      throw this.unexpected();\n    }\n\n    return {\n      kind: Kind.ENUM_TYPE_EXTENSION,\n      name: name,\n      directives: directives,\n      values: values,\n      loc: this.loc(start)\n    };\n  }\n  /**\n   * InputObjectTypeExtension :\n   *   - extend input Name Directives[Const]? InputFieldsDefinition\n   *   - extend input Name Directives[Const]\n   */\n  ;\n\n  _proto.parseInputObjectTypeExtension = function parseInputObjectTypeExtension() {\n    var start = this._lexer.token;\n    this.expectKeyword('extend');\n    this.expectKeyword('input');\n    var name = this.parseName();\n    var directives = this.parseDirectives(true);\n    var fields = this.parseInputFieldsDefinition();\n\n    if (directives.length === 0 && fields.length === 0) {\n      throw this.unexpected();\n    }\n\n    return {\n      kind: Kind.INPUT_OBJECT_TYPE_EXTENSION,\n      name: name,\n      directives: directives,\n      fields: fields,\n      loc: this.loc(start)\n    };\n  }\n  /**\n   * DirectiveDefinition :\n   *   - Description? directive @ Name ArgumentsDefinition? `repeatable`? on DirectiveLocations\n   */\n  ;\n\n  _proto.parseDirectiveDefinition = function parseDirectiveDefinition() {\n    var start = this._lexer.token;\n    var description = this.parseDescription();\n    this.expectKeyword('directive');\n    this.expectToken(TokenKind.AT);\n    var name = this.parseName();\n    var args = this.parseArgumentDefs();\n    var repeatable = this.expectOptionalKeyword('repeatable');\n    this.expectKeyword('on');\n    var locations = this.parseDirectiveLocations();\n    return {\n      kind: Kind.DIRECTIVE_DEFINITION,\n      description: description,\n      name: name,\n      arguments: args,\n      repeatable: repeatable,\n      locations: locations,\n      loc: this.loc(start)\n    };\n  }\n  /**\n   * DirectiveLocations :\n   *   - `|`? DirectiveLocation\n   *   - DirectiveLocations | DirectiveLocation\n   */\n  ;\n\n  _proto.parseDirectiveLocations = function parseDirectiveLocations() {\n    // Optional leading pipe\n    this.expectOptionalToken(TokenKind.PIPE);\n    var locations = [];\n\n    do {\n      locations.push(this.parseDirectiveLocation());\n    } while (this.expectOptionalToken(TokenKind.PIPE));\n\n    return locations;\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\n  _proto.parseDirectiveLocation = function parseDirectiveLocation() {\n    var start = this._lexer.token;\n    var name = this.parseName();\n\n    if (DirectiveLocation[name.value] !== undefined) {\n      return name;\n    }\n\n    throw this.unexpected(start);\n  } // Core parsing utility functions\n\n  /**\n   * Returns a location object, used to identify the place in\n   * the source that created a given parsed object.\n   */\n  ;\n\n  _proto.loc = function loc(startToken) {\n    if (!this._options.noLocation) {\n      return new Loc(startToken, this._lexer.lastToken, this._lexer.source);\n    }\n  }\n  /**\n   * Determines if the next token is of a given kind\n   */\n  ;\n\n  _proto.peek = function 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\n   * the lexer. Otherwise, do not change the parser state and throw an error.\n   */\n  ;\n\n  _proto.expectToken = function expectToken(kind) {\n    var token = this._lexer.token;\n\n    if (token.kind === kind) {\n      this._lexer.advance();\n\n      return token;\n    }\n\n    throw syntaxError(this._lexer.source, token.start, \"Expected \".concat(kind, \", found \").concat(getTokenDesc(token)));\n  }\n  /**\n   * If the next token is of the given kind, return that token after advancing\n   * the lexer. Otherwise, do not change the parser state and return undefined.\n   */\n  ;\n\n  _proto.expectOptionalToken = function expectOptionalToken(kind) {\n    var token = this._lexer.token;\n\n    if (token.kind === kind) {\n      this._lexer.advance();\n\n      return token;\n    }\n\n    return undefined;\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\n  _proto.expectKeyword = function expectKeyword(value) {\n    var token = this._lexer.token;\n\n    if (token.kind === TokenKind.NAME && token.value === value) {\n      this._lexer.advance();\n    } else {\n      throw syntaxError(this._lexer.source, token.start, \"Expected \\\"\".concat(value, \"\\\", found \").concat(getTokenDesc(token)));\n    }\n  }\n  /**\n   * If the next token is a given keyword, return \"true\" after advancing\n   * the lexer. Otherwise, do not change the parser state and return \"false\".\n   */\n  ;\n\n  _proto.expectOptionalKeyword = function expectOptionalKeyword(value) {\n    var token = this._lexer.token;\n\n    if (token.kind === TokenKind.NAME && token.value === value) {\n      this._lexer.advance();\n\n      return true;\n    }\n\n    return false;\n  }\n  /**\n   * Helper function for creating an error when an unexpected lexed token\n   * is encountered.\n   */\n  ;\n\n  _proto.unexpected = function unexpected(atToken) {\n    var token = atToken || this._lexer.token;\n    return syntaxError(this._lexer.source, token.start, \"Unexpected \".concat(getTokenDesc(token)));\n  }\n  /**\n   * Returns a possibly empty list of parse nodes, determined by\n   * the parseFn. This list begins with a lex token of openKind\n   * and ends with a lex token of closeKind. Advances the parser\n   * to the next lex token after the closing token.\n   */\n  ;\n\n  _proto.any = function any(openKind, parseFn, closeKind) {\n    this.expectToken(openKind);\n    var 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\n   * return non-empty list that begins with a lex token of openKind and ends\n   * with a lex token of closeKind. Advances the parser to the next lex token\n   * after the closing token.\n   */\n  ;\n\n  _proto.optionalMany = function optionalMany(openKind, parseFn, closeKind) {\n    if (this.expectOptionalToken(openKind)) {\n      var 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\n   * the parseFn. This list begins with a lex token of openKind\n   * and ends with a lex token of closeKind. Advances the parser\n   * to the next lex token after the closing token.\n   */\n  ;\n\n  _proto.many = function many(openKind, parseFn, closeKind) {\n    this.expectToken(openKind);\n    var nodes = [];\n\n    do {\n      nodes.push(parseFn.call(this));\n    } while (!this.expectOptionalToken(closeKind));\n\n    return nodes;\n  };\n\n  return Parser;\n}();\n\nfunction Loc(startToken, endToken, source) {\n  this.start = startToken.start;\n  this.end = endToken.end;\n  this.startToken = startToken;\n  this.endToken = endToken;\n  this.source = source;\n} // Print a simplified form when appearing in JSON/util.inspect.\n\n\ndefineToJSON(Loc, function () {\n  return {\n    start: this.start,\n    end: this.end\n  };\n});\n/**\n * A helper function to describe a token as a string for debugging\n */\n\nfunction getTokenDesc(token) {\n  var value = token.value;\n  return value ? \"\".concat(token.kind, \" \\\"\").concat(value, \"\\\"\") : token.kind;\n}\n","var nodejsCustomInspectSymbol = typeof Symbol === 'function' && typeof Symbol.for === 'function' ? Symbol.for('nodejs.util.inspect.custom') : undefined;\nexport default nodejsCustomInspectSymbol;\n","import inspect from '../jsutils/inspect';\nexport var QueryDocumentKeys = {\n  Name: [],\n  Document: ['definitions'],\n  OperationDefinition: ['name', 'variableDefinitions', 'directives', 'selectionSet'],\n  VariableDefinition: ['variable', 'type', 'defaultValue', 'directives'],\n  Variable: ['name'],\n  SelectionSet: ['selections'],\n  Field: ['alias', 'name', 'arguments', 'directives', 'selectionSet'],\n  Argument: ['name', 'value'],\n  FragmentSpread: ['name', 'directives'],\n  InlineFragment: ['typeCondition', 'directives', 'selectionSet'],\n  FragmentDefinition: ['name', // Note: fragment variable definitions are experimental and may be changed\n  // or removed in the future.\n  'variableDefinitions', 'typeCondition', 'directives', 'selectionSet'],\n  IntValue: [],\n  FloatValue: [],\n  StringValue: [],\n  BooleanValue: [],\n  NullValue: [],\n  EnumValue: [],\n  ListValue: ['values'],\n  ObjectValue: ['fields'],\n  ObjectField: ['name', 'value'],\n  Directive: ['name', 'arguments'],\n  NamedType: ['name'],\n  ListType: ['type'],\n  NonNullType: ['type'],\n  SchemaDefinition: ['directives', 'operationTypes'],\n  OperationTypeDefinition: ['type'],\n  ScalarTypeDefinition: ['description', 'name', 'directives'],\n  ObjectTypeDefinition: ['description', 'name', 'interfaces', 'directives', 'fields'],\n  FieldDefinition: ['description', 'name', 'arguments', 'type', 'directives'],\n  InputValueDefinition: ['description', 'name', 'type', 'defaultValue', 'directives'],\n  InterfaceTypeDefinition: ['description', 'name', 'directives', 'fields'],\n  UnionTypeDefinition: ['description', 'name', 'directives', 'types'],\n  EnumTypeDefinition: ['description', 'name', 'directives', 'values'],\n  EnumValueDefinition: ['description', 'name', 'directives'],\n  InputObjectTypeDefinition: ['description', 'name', 'directives', 'fields'],\n  DirectiveDefinition: ['description', 'name', 'arguments', 'locations'],\n  SchemaExtension: ['directives', 'operationTypes'],\n  ScalarTypeExtension: ['name', 'directives'],\n  ObjectTypeExtension: ['name', 'interfaces', 'directives', 'fields'],\n  InterfaceTypeExtension: ['name', 'directives', 'fields'],\n  UnionTypeExtension: ['name', 'directives', 'types'],\n  EnumTypeExtension: ['name', 'directives', 'values'],\n  InputObjectTypeExtension: ['name', 'directives', 'fields']\n};\nexport var BREAK = Object.freeze({});\n/**\n * visit() will walk through an AST using a depth first traversal, calling\n * the visitor's enter function at each node in the traversal, and calling the\n * leave function after visiting that node and all of its child nodes.\n *\n * By returning different values from the enter and leave functions, the\n * behavior of the visitor can be altered, including skipping over a sub-tree of\n * the AST (by returning false), editing the AST by returning a value or null\n * to remove the value, or to stop the whole traversal by returning BREAK.\n *\n * When using visit() to edit an AST, the original AST will not be modified, and\n * a new version of the AST with the changes applied will be returned from the\n * visit function.\n *\n *     const editedAST = visit(ast, {\n *       enter(node, key, parent, path, ancestors) {\n *         // @return\n *         //   undefined: no action\n *         //   false: skip visiting this node\n *         //   visitor.BREAK: stop visiting altogether\n *         //   null: delete this node\n *         //   any value: replace this node with the returned value\n *       },\n *       leave(node, key, parent, path, ancestors) {\n *         // @return\n *         //   undefined: no action\n *         //   false: no action\n *         //   visitor.BREAK: stop visiting altogether\n *         //   null: delete this node\n *         //   any value: replace this node with the returned value\n *       }\n *     });\n *\n * Alternatively to providing enter() and leave() functions, a visitor can\n * instead provide functions named the same as the kinds of AST nodes, or\n * enter/leave visitors at a named key, leading to four permutations of\n * visitor API:\n *\n * 1) Named visitors triggered when entering a node a specific kind.\n *\n *     visit(ast, {\n *       Kind(node) {\n *         // enter the \"Kind\" node\n *       }\n *     })\n *\n * 2) Named visitors that trigger upon entering and leaving a node of\n *    a specific kind.\n *\n *     visit(ast, {\n *       Kind: {\n *         enter(node) {\n *           // enter the \"Kind\" node\n *         }\n *         leave(node) {\n *           // leave the \"Kind\" node\n *         }\n *       }\n *     })\n *\n * 3) Generic visitors that trigger upon entering and leaving any node.\n *\n *     visit(ast, {\n *       enter(node) {\n *         // enter any node\n *       },\n *       leave(node) {\n *         // leave any node\n *       }\n *     })\n *\n * 4) Parallel visitors for entering and leaving nodes of a specific kind.\n *\n *     visit(ast, {\n *       enter: {\n *         Kind(node) {\n *           // enter the \"Kind\" node\n *         }\n *       },\n *       leave: {\n *         Kind(node) {\n *           // leave the \"Kind\" node\n *         }\n *       }\n *     })\n */\n\nexport function visit(root, visitor) {\n  var visitorKeys = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : QueryDocumentKeys;\n\n  /* eslint-disable no-undef-init */\n  var stack = undefined;\n  var inArray = Array.isArray(root);\n  var keys = [root];\n  var index = -1;\n  var edits = [];\n  var node = undefined;\n  var key = undefined;\n  var parent = undefined;\n  var path = [];\n  var ancestors = [];\n  var newRoot = root;\n  /* eslint-enable no-undef-init */\n\n  do {\n    index++;\n    var isLeaving = index === keys.length;\n    var isEdited = isLeaving && edits.length !== 0;\n\n    if (isLeaving) {\n      key = ancestors.length === 0 ? undefined : path[path.length - 1];\n      node = parent;\n      parent = ancestors.pop();\n\n      if (isEdited) {\n        if (inArray) {\n          node = node.slice();\n        } else {\n          var clone = {};\n\n          for (var _i2 = 0, _Object$keys2 = Object.keys(node); _i2 < _Object$keys2.length; _i2++) {\n            var k = _Object$keys2[_i2];\n            clone[k] = node[k];\n          }\n\n          node = clone;\n        }\n\n        var editOffset = 0;\n\n        for (var ii = 0; ii < edits.length; ii++) {\n          var editKey = edits[ii][0];\n          var editValue = edits[ii][1];\n\n          if (inArray) {\n            editKey -= editOffset;\n          }\n\n          if (inArray && editValue === null) {\n            node.splice(editKey, 1);\n            editOffset++;\n          } else {\n            node[editKey] = editValue;\n          }\n        }\n      }\n\n      index = stack.index;\n      keys = stack.keys;\n      edits = stack.edits;\n      inArray = stack.inArray;\n      stack = stack.prev;\n    } else {\n      key = parent ? inArray ? index : keys[index] : undefined;\n      node = parent ? parent[key] : newRoot;\n\n      if (node === null || node === undefined) {\n        continue;\n      }\n\n      if (parent) {\n        path.push(key);\n      }\n    }\n\n    var result = void 0;\n\n    if (!Array.isArray(node)) {\n      if (!isNode(node)) {\n        throw new Error('Invalid AST Node: ' + inspect(node));\n      }\n\n      var visitFn = getVisitFn(visitor, node.kind, isLeaving);\n\n      if (visitFn) {\n        result = visitFn.call(visitor, node, key, parent, path, ancestors);\n\n        if (result === BREAK) {\n          break;\n        }\n\n        if (result === false) {\n          if (!isLeaving) {\n            path.pop();\n            continue;\n          }\n        } else if (result !== undefined) {\n          edits.push([key, result]);\n\n          if (!isLeaving) {\n            if (isNode(result)) {\n              node = result;\n            } else {\n              path.pop();\n              continue;\n            }\n          }\n        }\n      }\n    }\n\n    if (result === undefined && isEdited) {\n      edits.push([key, node]);\n    }\n\n    if (isLeaving) {\n      path.pop();\n    } else {\n      stack = {\n        inArray: inArray,\n        index: index,\n        keys: keys,\n        edits: edits,\n        prev: stack\n      };\n      inArray = Array.isArray(node);\n      keys = inArray ? node : visitorKeys[node.kind] || [];\n      index = -1;\n      edits = [];\n\n      if (parent) {\n        ancestors.push(parent);\n      }\n\n      parent = node;\n    }\n  } while (stack !== undefined);\n\n  if (edits.length !== 0) {\n    newRoot = edits[edits.length - 1][1];\n  }\n\n  return newRoot;\n}\n\nfunction isNode(maybeNode) {\n  return Boolean(maybeNode && typeof maybeNode.kind === 'string');\n}\n/**\n * Creates a new visitor instance which delegates to many visitors to run in\n * parallel. Each visitor will be visited for each node before moving on.\n *\n * If a prior visitor edits a node, no following visitors will see that node.\n */\n\n\nexport function visitInParallel(visitors) {\n  var skipping = new Array(visitors.length);\n  return {\n    enter: function enter(node) {\n      for (var i = 0; i < visitors.length; i++) {\n        if (!skipping[i]) {\n          var fn = getVisitFn(visitors[i], node.kind,\n          /* isLeaving */\n          false);\n\n          if (fn) {\n            var result = fn.apply(visitors[i], arguments);\n\n            if (result === false) {\n              skipping[i] = node;\n            } else if (result === BREAK) {\n              skipping[i] = BREAK;\n            } else if (result !== undefined) {\n              return result;\n            }\n          }\n        }\n      }\n    },\n    leave: function leave(node) {\n      for (var i = 0; i < visitors.length; i++) {\n        if (!skipping[i]) {\n          var fn = getVisitFn(visitors[i], node.kind,\n          /* isLeaving */\n          true);\n\n          if (fn) {\n            var result = fn.apply(visitors[i], arguments);\n\n            if (result === BREAK) {\n              skipping[i] = BREAK;\n            } else if (result !== undefined && result !== false) {\n              return result;\n            }\n          }\n        } else if (skipping[i] === node) {\n          skipping[i] = null;\n        }\n      }\n    }\n  };\n}\n/**\n * Creates a new visitor instance which maintains a provided TypeInfo instance\n * along with visiting visitor.\n */\n\nexport function visitWithTypeInfo(typeInfo, visitor) {\n  return {\n    enter: function enter(node) {\n      typeInfo.enter(node);\n      var fn = getVisitFn(visitor, node.kind,\n      /* isLeaving */\n      false);\n\n      if (fn) {\n        var result = fn.apply(visitor, arguments);\n\n        if (result !== undefined) {\n          typeInfo.leave(node);\n\n          if (isNode(result)) {\n            typeInfo.enter(result);\n          }\n        }\n\n        return result;\n      }\n    },\n    leave: function leave(node) {\n      var fn = getVisitFn(visitor, node.kind,\n      /* isLeaving */\n      true);\n      var result;\n\n      if (fn) {\n        result = fn.apply(visitor, arguments);\n      }\n\n      typeInfo.leave(node);\n      return result;\n    }\n  };\n}\n/**\n * Given a visitor instance, if it is leaving or not, and a node kind, return\n * the function the visitor runtime should call.\n */\n\nexport function getVisitFn(visitor, kind, isLeaving) {\n  var kindVisitor = visitor[kind];\n\n  if (kindVisitor) {\n    if (!isLeaving && typeof kindVisitor === 'function') {\n      // { Kind() {} }\n      return kindVisitor;\n    }\n\n    var kindSpecificVisitor = isLeaving ? kindVisitor.leave : kindVisitor.enter;\n\n    if (typeof kindSpecificVisitor === 'function') {\n      // { Kind: { enter() {}, leave() {} } }\n      return kindSpecificVisitor;\n    }\n  } else {\n    var specificVisitor = isLeaving ? visitor.leave : visitor.enter;\n\n    if (specificVisitor) {\n      if (typeof specificVisitor === 'function') {\n        // { enter() {}, leave() {} }\n        return specificVisitor;\n      }\n\n      var specificKindVisitor = specificVisitor[kind];\n\n      if (typeof specificKindVisitor === 'function') {\n        // { enter: { Kind() {} }, leave: { Kind() {} } }\n        return specificKindVisitor;\n      }\n    }\n  }\n}\n","import { visit } from './visitor';\nimport { printBlockString } from './blockString';\n/**\n * Converts an AST into a string, using one set of reasonable\n * formatting rules.\n */\n\nexport function print(ast) {\n  return visit(ast, {\n    leave: printDocASTReducer\n  });\n} // TODO: provide better type coverage in future\n\nvar printDocASTReducer = {\n  Name: function Name(node) {\n    return node.value;\n  },\n  Variable: function Variable(node) {\n    return '$' + node.name;\n  },\n  // Document\n  Document: function Document(node) {\n    return join(node.definitions, '\\n\\n') + '\\n';\n  },\n  OperationDefinition: function OperationDefinition(node) {\n    var op = node.operation;\n    var name = node.name;\n    var varDefs = wrap('(', join(node.variableDefinitions, ', '), ')');\n    var directives = join(node.directives, ' ');\n    var selectionSet = node.selectionSet; // Anonymous queries with no directives or variable definitions can use\n    // the query short form.\n\n    return !name && !directives && !varDefs && op === 'query' ? selectionSet : join([op, join([name, varDefs]), directives, selectionSet], ' ');\n  },\n  VariableDefinition: function VariableDefinition(_ref) {\n    var variable = _ref.variable,\n        type = _ref.type,\n        defaultValue = _ref.defaultValue,\n        directives = _ref.directives;\n    return variable + ': ' + type + wrap(' = ', defaultValue) + wrap(' ', join(directives, ' '));\n  },\n  SelectionSet: function SelectionSet(_ref2) {\n    var selections = _ref2.selections;\n    return block(selections);\n  },\n  Field: function Field(_ref3) {\n    var alias = _ref3.alias,\n        name = _ref3.name,\n        args = _ref3.arguments,\n        directives = _ref3.directives,\n        selectionSet = _ref3.selectionSet;\n    return join([wrap('', alias, ': ') + name + wrap('(', join(args, ', '), ')'), join(directives, ' '), selectionSet], ' ');\n  },\n  Argument: function Argument(_ref4) {\n    var name = _ref4.name,\n        value = _ref4.value;\n    return name + ': ' + value;\n  },\n  // Fragments\n  FragmentSpread: function FragmentSpread(_ref5) {\n    var name = _ref5.name,\n        directives = _ref5.directives;\n    return '...' + name + wrap(' ', join(directives, ' '));\n  },\n  InlineFragment: function InlineFragment(_ref6) {\n    var typeCondition = _ref6.typeCondition,\n        directives = _ref6.directives,\n        selectionSet = _ref6.selectionSet;\n    return join(['...', wrap('on ', typeCondition), join(directives, ' '), selectionSet], ' ');\n  },\n  FragmentDefinition: function FragmentDefinition(_ref7) {\n    var name = _ref7.name,\n        typeCondition = _ref7.typeCondition,\n        variableDefinitions = _ref7.variableDefinitions,\n        directives = _ref7.directives,\n        selectionSet = _ref7.selectionSet;\n    return (// Note: fragment variable definitions are experimental and may be changed\n      // or removed in the future.\n      \"fragment \".concat(name).concat(wrap('(', join(variableDefinitions, ', '), ')'), \" \") + \"on \".concat(typeCondition, \" \").concat(wrap('', join(directives, ' '), ' ')) + selectionSet\n    );\n  },\n  // Value\n  IntValue: function IntValue(_ref8) {\n    var value = _ref8.value;\n    return value;\n  },\n  FloatValue: function FloatValue(_ref9) {\n    var value = _ref9.value;\n    return value;\n  },\n  StringValue: function StringValue(_ref10, key) {\n    var value = _ref10.value,\n        isBlockString = _ref10.block;\n    return isBlockString ? printBlockString(value, key === 'description' ? '' : '  ') : JSON.stringify(value);\n  },\n  BooleanValue: function BooleanValue(_ref11) {\n    var value = _ref11.value;\n    return value ? 'true' : 'false';\n  },\n  NullValue: function NullValue() {\n    return 'null';\n  },\n  EnumValue: function EnumValue(_ref12) {\n    var value = _ref12.value;\n    return value;\n  },\n  ListValue: function ListValue(_ref13) {\n    var values = _ref13.values;\n    return '[' + join(values, ', ') + ']';\n  },\n  ObjectValue: function ObjectValue(_ref14) {\n    var fields = _ref14.fields;\n    return '{' + join(fields, ', ') + '}';\n  },\n  ObjectField: function ObjectField(_ref15) {\n    var name = _ref15.name,\n        value = _ref15.value;\n    return name + ': ' + value;\n  },\n  // Directive\n  Directive: function Directive(_ref16) {\n    var name = _ref16.name,\n        args = _ref16.arguments;\n    return '@' + name + wrap('(', join(args, ', '), ')');\n  },\n  // Type\n  NamedType: function NamedType(_ref17) {\n    var name = _ref17.name;\n    return name;\n  },\n  ListType: function ListType(_ref18) {\n    var type = _ref18.type;\n    return '[' + type + ']';\n  },\n  NonNullType: function NonNullType(_ref19) {\n    var type = _ref19.type;\n    return type + '!';\n  },\n  // Type System Definitions\n  SchemaDefinition: function SchemaDefinition(_ref20) {\n    var directives = _ref20.directives,\n        operationTypes = _ref20.operationTypes;\n    return join(['schema', join(directives, ' '), block(operationTypes)], ' ');\n  },\n  OperationTypeDefinition: function OperationTypeDefinition(_ref21) {\n    var operation = _ref21.operation,\n        type = _ref21.type;\n    return operation + ': ' + type;\n  },\n  ScalarTypeDefinition: addDescription(function (_ref22) {\n    var name = _ref22.name,\n        directives = _ref22.directives;\n    return join(['scalar', name, join(directives, ' ')], ' ');\n  }),\n  ObjectTypeDefinition: addDescription(function (_ref23) {\n    var name = _ref23.name,\n        interfaces = _ref23.interfaces,\n        directives = _ref23.directives,\n        fields = _ref23.fields;\n    return join(['type', name, wrap('implements ', join(interfaces, ' & ')), join(directives, ' '), block(fields)], ' ');\n  }),\n  FieldDefinition: addDescription(function (_ref24) {\n    var name = _ref24.name,\n        args = _ref24.arguments,\n        type = _ref24.type,\n        directives = _ref24.directives;\n    return name + (hasMultilineItems(args) ? wrap('(\\n', indent(join(args, '\\n')), '\\n)') : wrap('(', join(args, ', '), ')')) + ': ' + type + wrap(' ', join(directives, ' '));\n  }),\n  InputValueDefinition: addDescription(function (_ref25) {\n    var name = _ref25.name,\n        type = _ref25.type,\n        defaultValue = _ref25.defaultValue,\n        directives = _ref25.directives;\n    return join([name + ': ' + type, wrap('= ', defaultValue), join(directives, ' ')], ' ');\n  }),\n  InterfaceTypeDefinition: addDescription(function (_ref26) {\n    var name = _ref26.name,\n        directives = _ref26.directives,\n        fields = _ref26.fields;\n    return join(['interface', name, join(directives, ' '), block(fields)], ' ');\n  }),\n  UnionTypeDefinition: addDescription(function (_ref27) {\n    var name = _ref27.name,\n        directives = _ref27.directives,\n        types = _ref27.types;\n    return join(['union', name, join(directives, ' '), types && types.length !== 0 ? '= ' + join(types, ' | ') : ''], ' ');\n  }),\n  EnumTypeDefinition: addDescription(function (_ref28) {\n    var name = _ref28.name,\n        directives = _ref28.directives,\n        values = _ref28.values;\n    return join(['enum', name, join(directives, ' '), block(values)], ' ');\n  }),\n  EnumValueDefinition: addDescription(function (_ref29) {\n    var name = _ref29.name,\n        directives = _ref29.directives;\n    return join([name, join(directives, ' ')], ' ');\n  }),\n  InputObjectTypeDefinition: addDescription(function (_ref30) {\n    var name = _ref30.name,\n        directives = _ref30.directives,\n        fields = _ref30.fields;\n    return join(['input', name, join(directives, ' '), block(fields)], ' ');\n  }),\n  DirectiveDefinition: addDescription(function (_ref31) {\n    var name = _ref31.name,\n        args = _ref31.arguments,\n        repeatable = _ref31.repeatable,\n        locations = _ref31.locations;\n    return 'directive @' + name + (hasMultilineItems(args) ? wrap('(\\n', indent(join(args, '\\n')), '\\n)') : wrap('(', join(args, ', '), ')')) + (repeatable ? ' repeatable' : '') + ' on ' + join(locations, ' | ');\n  }),\n  SchemaExtension: function SchemaExtension(_ref32) {\n    var directives = _ref32.directives,\n        operationTypes = _ref32.operationTypes;\n    return join(['extend schema', join(directives, ' '), block(operationTypes)], ' ');\n  },\n  ScalarTypeExtension: function ScalarTypeExtension(_ref33) {\n    var name = _ref33.name,\n        directives = _ref33.directives;\n    return join(['extend scalar', name, join(directives, ' ')], ' ');\n  },\n  ObjectTypeExtension: function ObjectTypeExtension(_ref34) {\n    var name = _ref34.name,\n        interfaces = _ref34.interfaces,\n        directives = _ref34.directives,\n        fields = _ref34.fields;\n    return join(['extend type', name, wrap('implements ', join(interfaces, ' & ')), join(directives, ' '), block(fields)], ' ');\n  },\n  InterfaceTypeExtension: function InterfaceTypeExtension(_ref35) {\n    var name = _ref35.name,\n        directives = _ref35.directives,\n        fields = _ref35.fields;\n    return join(['extend interface', name, join(directives, ' '), block(fields)], ' ');\n  },\n  UnionTypeExtension: function UnionTypeExtension(_ref36) {\n    var name = _ref36.name,\n        directives = _ref36.directives,\n        types = _ref36.types;\n    return join(['extend union', name, join(directives, ' '), types && types.length !== 0 ? '= ' + join(types, ' | ') : ''], ' ');\n  },\n  EnumTypeExtension: function EnumTypeExtension(_ref37) {\n    var name = _ref37.name,\n        directives = _ref37.directives,\n        values = _ref37.values;\n    return join(['extend enum', name, join(directives, ' '), block(values)], ' ');\n  },\n  InputObjectTypeExtension: function InputObjectTypeExtension(_ref38) {\n    var name = _ref38.name,\n        directives = _ref38.directives,\n        fields = _ref38.fields;\n    return join(['extend input', name, join(directives, ' '), block(fields)], ' ');\n  }\n};\n\nfunction addDescription(cb) {\n  return function (node) {\n    return join([node.description, cb(node)], '\\n');\n  };\n}\n/**\n * Given maybeArray, print an empty string if it is null or empty, otherwise\n * print all items together separated by separator if provided\n */\n\n\nfunction join(maybeArray, separator) {\n  return maybeArray ? maybeArray.filter(function (x) {\n    return x;\n  }).join(separator || '') : '';\n}\n/**\n * Given array, print each item on its own line, wrapped in an\n * indented \"{ }\" block.\n */\n\n\nfunction block(array) {\n  return array && array.length !== 0 ? '{\\n' + indent(join(array, '\\n')) + '\\n}' : '';\n}\n/**\n * If maybeString is not null or empty, then wrap with start and end, otherwise\n * print an empty string.\n */\n\n\nfunction wrap(start, maybeString, end) {\n  return maybeString ? start + maybeString + (end || '') : '';\n}\n\nfunction indent(maybeString) {\n  return maybeString && '  ' + maybeString.replace(/\\n/g, '\\n  ');\n}\n\nfunction isMultiline(string) {\n  return string.indexOf('\\n') !== -1;\n}\n\nfunction hasMultilineItems(maybeArray) {\n  return maybeArray && maybeArray.some(isMultiline);\n}\n","function _typeof(obj) { if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }; } return _typeof(obj); }\n\nimport nodejsCustomInspectSymbol from './nodejsCustomInspectSymbol';\nvar MAX_ARRAY_LENGTH = 10;\nvar MAX_RECURSIVE_DEPTH = 2;\n/**\n * Used to print values in error messages.\n */\n\nexport default function inspect(value) {\n  return formatValue(value, []);\n}\n\nfunction formatValue(value, seenValues) {\n  switch (_typeof(value)) {\n    case 'string':\n      return JSON.stringify(value);\n\n    case 'function':\n      return value.name ? \"[function \".concat(value.name, \"]\") : '[function]';\n\n    case 'object':\n      if (value === null) {\n        return 'null';\n      }\n\n      return formatObjectValue(value, seenValues);\n\n    default:\n      return String(value);\n  }\n}\n\nfunction formatObjectValue(value, previouslySeenValues) {\n  if (previouslySeenValues.indexOf(value) !== -1) {\n    return '[Circular]';\n  }\n\n  var seenValues = [].concat(previouslySeenValues, [value]);\n  var customInspectFn = getCustomFn(value);\n\n  if (customInspectFn !== undefined) {\n    // $FlowFixMe(>=0.90.0)\n    var customValue = customInspectFn.call(value); // check for infinite recursion\n\n    if (customValue !== value) {\n      return typeof customValue === 'string' ? customValue : formatValue(customValue, seenValues);\n    }\n  } else if (Array.isArray(value)) {\n    return formatArray(value, seenValues);\n  }\n\n  return formatObject(value, seenValues);\n}\n\nfunction formatObject(object, seenValues) {\n  var keys = Object.keys(object);\n\n  if (keys.length === 0) {\n    return '{}';\n  }\n\n  if (seenValues.length > MAX_RECURSIVE_DEPTH) {\n    return '[' + getObjectTag(object) + ']';\n  }\n\n  var properties = keys.map(function (key) {\n    var value = formatValue(object[key], seenValues);\n    return key + ': ' + value;\n  });\n  return '{ ' + properties.join(', ') + ' }';\n}\n\nfunction formatArray(array, seenValues) {\n  if (array.length === 0) {\n    return '[]';\n  }\n\n  if (seenValues.length > MAX_RECURSIVE_DEPTH) {\n    return '[Array]';\n  }\n\n  var len = Math.min(MAX_ARRAY_LENGTH, array.length);\n  var remaining = array.length - len;\n  var items = [];\n\n  for (var i = 0; i < len; ++i) {\n    items.push(formatValue(array[i], seenValues));\n  }\n\n  if (remaining === 1) {\n    items.push('... 1 more item');\n  } else if (remaining > 1) {\n    items.push(\"... \".concat(remaining, \" more items\"));\n  }\n\n  return '[' + items.join(', ') + ']';\n}\n\nfunction getCustomFn(object) {\n  var customInspectFn = object[String(nodejsCustomInspectSymbol)];\n\n  if (typeof customInspectFn === 'function') {\n    return customInspectFn;\n  }\n\n  if (typeof object.inspect === 'function') {\n    return object.inspect;\n  }\n}\n\nfunction getObjectTag(object) {\n  var tag = Object.prototype.toString.call(object).replace(/^\\[object /, '').replace(/]$/, '');\n\n  if (tag === 'Object' && typeof object.constructor === 'function') {\n    var name = object.constructor.name;\n\n    if (typeof name === 'string' && name !== '') {\n      return name;\n    }\n  }\n\n  return tag;\n}\n"],"sourceRoot":""}