{"version":3,"sources":["webpack://uconn-today-plugin/./node_modules/@ungap/global-this/esm/index.js","webpack://uconn-today-plugin/./node_modules/@wry/context/lib/context.esm.js","webpack://uconn-today-plugin/./node_modules/@wry/equality/lib/equality.esm.js","webpack://uconn-today-plugin/./node_modules/dlv/dist/dlv.umd.js","webpack://uconn-today-plugin/./node_modules/fast-json-stable-stringify/index.js","webpack://uconn-today-plugin/./node_modules/graphql/jsutils/defineInspect.js","webpack://uconn-today-plugin/./node_modules/graphql/jsutils/inspect.js","webpack://uconn-today-plugin/./node_modules/graphql/jsutils/inspect.mjs","webpack://uconn-today-plugin/./node_modules/graphql/jsutils/invariant.js","webpack://uconn-today-plugin/./node_modules/graphql/jsutils/nodejsCustomInspectSymbol.js","webpack://uconn-today-plugin/./node_modules/graphql/jsutils/nodejsCustomInspectSymbol.mjs","webpack://uconn-today-plugin/./node_modules/graphql/language/ast.js","webpack://uconn-today-plugin/./node_modules/graphql/jsutils/defineInspect.mjs","webpack://uconn-today-plugin/./node_modules/graphql/jsutils/invariant.mjs","webpack://uconn-today-plugin/./node_modules/graphql/language/ast.mjs","webpack://uconn-today-plugin/./node_modules/graphql/language/blockString.mjs","webpack://uconn-today-plugin/./node_modules/graphql/jsutils/isObjectLike.mjs","webpack://uconn-today-plugin/./node_modules/graphql/polyfills/symbols.mjs","webpack://uconn-today-plugin/./node_modules/graphql/language/location.mjs","webpack://uconn-today-plugin/./node_modules/graphql/language/printLocation.mjs","webpack://uconn-today-plugin/./node_modules/graphql/error/GraphQLError.mjs","webpack://uconn-today-plugin/./node_modules/graphql/error/syntaxError.mjs","webpack://uconn-today-plugin/./node_modules/graphql/language/kinds.mjs","webpack://uconn-today-plugin/./node_modules/graphql/language/tokenKind.mjs","webpack://uconn-today-plugin/./node_modules/graphql/jsutils/devAssert.mjs","webpack://uconn-today-plugin/./node_modules/graphql/language/source.mjs","webpack://uconn-today-plugin/./node_modules/graphql/language/directiveLocation.mjs","webpack://uconn-today-plugin/./node_modules/graphql/language/lexer.mjs","webpack://uconn-today-plugin/./node_modules/graphql/language/parser.mjs","webpack://uconn-today-plugin/./node_modules/graphql/language/printer.mjs","webpack://uconn-today-plugin/./node_modules/graphql/language/visitor.js","webpack://uconn-today-plugin/./node_modules/graphql/language/visitor.mjs","webpack://uconn-today-plugin/./node_modules/hoist-non-react-statics/dist/hoist-non-react-statics.cjs.js","webpack://uconn-today-plugin/./node_modules/@babel/runtime/helpers/esm/setPrototypeOf.js","webpack://uconn-today-plugin/./node_modules/@babel/runtime/helpers/esm/inheritsLoose.js","webpack://uconn-today-plugin/./node_modules/mini-create-react-context/dist/esm/index.js","webpack://uconn-today-plugin/./node_modules/object-assign/index.js","webpack://uconn-today-plugin/./node_modules/@wry/trie/lib/trie.esm.js","webpack://uconn-today-plugin/./node_modules/optimism/lib/bundle.esm.js","webpack://uconn-today-plugin/./node_modules/prop-types/factoryWithThrowingShims.js","webpack://uconn-today-plugin/./node_modules/prop-types/index.js","webpack://uconn-today-plugin/./node_modules/prop-types/lib/ReactPropTypesSecret.js","webpack://uconn-today-plugin/./node_modules/regenerator-runtime/runtime.js","webpack://uconn-today-plugin/./node_modules/unfetch/dist/unfetch.module.js","webpack://uconn-today-plugin/./node_modules/zen-observable/index.js","webpack://uconn-today-plugin/./node_modules/zen-observable/lib/Observable.js"],"names":["Object","get","global","this","self","globalThis","prototype","_T_","defineProperty","configurable","currentContext","MISSING_VALUE","idCounter","globalKey","host","Array","Slot","id","Date","now","Math","random","toString","slice","join","hasValue","context_1","parent","slots","value","getValue","withValue","callback","args","thisArg","_a","__proto__","apply","bind","context","saved","arguments","noContext","enumerable","writable","hasOwnProperty","fnToStr","Function","previousComparisons","Map","equal","a","b","check","clear","full","suffix","fromIndex","aTag","call","length","previouslyCompared","aKeys","definedKeys","bKeys","keyCount","k","key","name","message","size","aIterator","entries","isMap","info","next","done","aKey","aValue","has","aCode","nativeCodeSuffix","indexOf","obj","keys","filter","isDefinedKey","bSet","set","Set","add","module","exports","t","n","e","i","o","split","data","opts","cmp","f","cycles","node","aobj","bobj","seen","stringify","toJSON","undefined","isFinite","JSON","out","isArray","TypeError","seenIndex","push","sort","splice","default","classObject","fn","_invariant","inspect","_nodejsCustomInspectSymbol","_interopRequireDefault","__esModule","formatValue","_typeof","Symbol","iterator","constructor","seenValues","concat","previouslySeenValues","customInspectFn","object","String","getCustomFn","customValue","array","len","min","remaining","items","formatArray","tag","replace","getObjectTag","map","formatObject","formatObjectValue","condition","Boolean","Error","_default","for","nodejsCustomInspectSymbol","isNode","maybeNode","kind","Token","Location","_defineInspect","startToken","endToken","source","start","end","line","column","prev","defineInspect","invariant","dedentBlockStringValue","rawString","lines","commonIndent","_commonIndent","isFirstLine","isEmptyLine","indent","charCodeAt","getBlockStringIndentation","startLine","isBlank","endLine","str","printBlockString","indentation","preferMultipleLines","isSingleLine","hasLeadingSpace","hasTrailingQuote","hasTrailingSlash","printAsMultipleLines","result","asyncIterator","SYMBOL_TO_STRING_TAG","toStringTag","getLocation","position","match","lineRegexp","exec","body","index","printLocation","location","printSourceLocation","sourceLocation","firstLineColumnOffset","locationOffset","whitespace","lineIndex","lineOffset","lineNum","columnOffset","columnNum","locationStr","locationLine","subLineIndex","floor","subLineColumnNum","subLines","printPrefixedLines","subLine","existingLines","_ref","padLen","max","_ref2","_ref3","prefix","_defineProperties","target","props","descriptor","_possibleConstructorReturn","_assertThisInitialized","ReferenceError","_wrapNativeSuper","Class","_cache","Wrapper","_construct","_getPrototypeOf","create","_setPrototypeOf","Parent","_isNativeReflectConstruct","Reflect","construct","instance","sham","Proxy","p","setPrototypeOf","getPrototypeOf","GraphQLError","_Error","subClass","superClass","_inherits","Derived","hasNativeReflectConstruct","Constructor","protoProps","_super","Super","NewTarget","nodes","positions","path","originalError","extensions","_locations2","_source2","_positions2","_extensions2","_this","_classCallCheck","_nodes$0$loc","_nodes","_source","loc","_locations","_positions","reduce","list","pos","_extensions","originalExtensions","defineProperties","locations","stack","captureStackTrace","error","output","_i2","_error$nodes2","_i4","_error$locations2","printError","syntaxError","description","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","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","devAssert","Source","DirectiveLocation","QUERY","MUTATION","SUBSCRIPTION","SCHEMA","SCALAR","ARGUMENT_DEFINITION","INTERFACE","UNION","ENUM_VALUE","INPUT_OBJECT","INPUT_FIELD_DEFINITION","Lexer","startOfFileToken","lastToken","token","lineStart","_proto","advance","lookahead","_token$next","readToken","printCharCode","code","isNaN","fromCharCode","toUpperCase","lexer","bodyLength","_line","_col","readComment","readBlockString","readString","readNumber","readName","unexpectedCharacterMessage","col","firstCode","isFloat","readDigits","isNameStart","c","d","chunkStart","charCode","char2hex","invalidSequence","rawValue","parse","options","Parser","parseDocument","sourceObj","isSource","_lexer","_options","parseName","expectToken","definitions","many","parseDefinition","peek","parseOperationDefinition","parseFragmentDefinition","parseTypeSystemDefinition","parseTypeSystemExtension","peekDescription","unexpected","operation","variableDefinitions","directives","selectionSet","parseSelectionSet","parseOperationType","parseVariableDefinitions","parseDirectives","operationToken","optionalMany","parseVariableDefinition","variable","parseVariable","type","parseTypeReference","defaultValue","expectOptionalToken","parseValueLiteral","selections","parseSelection","parseFragment","parseField","alias","nameOrAlias","parseArguments","isConst","item","parseConstArgument","parseArgument","hasTypeCondition","expectOptionalKeyword","parseFragmentName","typeCondition","parseNamedType","_this$_options","expectKeyword","experimentalFragmentVariables","parseList","parseObject","parseStringLiteral","block","values","any","_this2","fields","parseObjectField","parseDirective","keywordToken","parseSchemaDefinition","parseScalarTypeDefinition","parseObjectTypeDefinition","parseInterfaceTypeDefinition","parseUnionTypeDefinition","parseEnumTypeDefinition","parseInputObjectTypeDefinition","parseDirectiveDefinition","parseDescription","operationTypes","parseOperationTypeDefinition","interfaces","parseImplementsInterfaces","parseFieldsDefinition","_this$_options2","allowLegacySDLImplementsInterfaces","types","delimitedMany","_this$_options3","allowLegacySDLEmptyFields","parseFieldDefinition","parseArgumentDefs","parseInputValueDef","parseUnionMemberTypes","parseEnumValuesDefinition","parseEnumValueDefinition","parseInputFieldsDefinition","parseSchemaExtension","parseScalarTypeExtension","parseObjectTypeExtension","parseInterfaceTypeExtension","parseUnionTypeExtension","parseEnumTypeExtension","parseInputObjectTypeExtension","repeatable","parseDirectiveLocations","parseDirectiveLocation","_this$_options4","noLocation","getTokenKindDesc","getTokenDesc","atToken","openKind","parseFn","closeKind","delimiterKind","isPunctuatorTokenKind","print","ast","leave","printDocASTReducer","Name","Variable","Document","OperationDefinition","op","varDefs","wrap","VariableDefinition","SelectionSet","Field","argsLine","Argument","_ref4","FragmentSpread","_ref5","InlineFragment","_ref6","FragmentDefinition","_ref7","IntValue","_ref8","FloatValue","_ref9","StringValue","_ref10","BooleanValue","_ref11","NullValue","EnumValue","_ref12","ListValue","_ref13","ObjectValue","_ref14","ObjectField","_ref15","Directive","_ref16","NamedType","_ref17","ListType","_ref18","NonNullType","_ref19","SchemaDefinition","addDescription","_ref20","OperationTypeDefinition","_ref21","ScalarTypeDefinition","_ref22","ObjectTypeDefinition","_ref23","FieldDefinition","_ref24","hasMultilineItems","InputValueDefinition","_ref25","InterfaceTypeDefinition","_ref26","UnionTypeDefinition","_ref27","EnumTypeDefinition","_ref28","EnumValueDefinition","_ref29","InputObjectTypeDefinition","_ref30","DirectiveDefinition","_ref31","SchemaExtension","_ref32","ScalarTypeExtension","_ref33","ObjectTypeExtension","_ref34","InterfaceTypeExtension","_ref35","UnionTypeExtension","_ref36","EnumTypeExtension","_ref37","InputObjectTypeExtension","_ref38","cb","maybeArray","_maybeArray$filter$jo","separator","x","maybeString","isMultiline","some","root","visitor","visitorKeys","QueryDocumentKeys","inArray","edits","ancestors","newRoot","isLeaving","isEdited","pop","clone","_Object$keys2","editOffset","ii","editKey","editValue","_visitorKeys$node$kin","_ast","_inspect","visitFn","getVisitFn","BREAK","kindVisitor","kindSpecificVisitor","enter","specificVisitor","specificKindVisitor","visit","reactIs","REACT_STATICS","childContextTypes","contextType","contextTypes","defaultProps","displayName","getDefaultProps","getDerivedStateFromError","getDerivedStateFromProps","mixins","propTypes","KNOWN_STATICS","caller","callee","arity","MEMO_STATICS","compare","TYPE_STATICS","getStatics","component","isMemo","ForwardRef","render","Memo","getOwnPropertyNames","getOwnPropertySymbols","getOwnPropertyDescriptor","objectPrototype","hoistNonReactStatics","targetComponent","sourceComponent","blacklist","inheritedComponent","targetStatics","sourceStatics","_inheritsLoose","MAX_SIGNED_31_BIT_INT","commonjsGlobal","window","g","createEventEmitter","handlers","on","handler","off","h","newValue","changedBits","forEach","calculateChangedBits","_Provider$childContex","_Consumer$contextType","contextProp","Provider","_Component","emitter","getChildContext","componentWillReceiveProps","nextProps","oldValue","y","children","Component","Consumer","_Component2","state","onUpdate","observedBits","setState","_proto2","componentDidMount","componentWillUnmount","propIsEnumerable","propertyIsEnumerable","toObject","val","assign","test1","test2","test3","letter","err","shouldUseNative","from","symbols","to","s","defaultMakeData","Trie","weakness","makeData","lookup","_i","lookupArray","getChildTrie","isObjRef","weak","WeakMap","strong","child","defaultDispose","Cache","dispose","Infinity","newest","oldest","entry","getEntry","older","newer","clean","delete","parentEntrySlot","maybeUnsubscribe","entryOrDep","unsubscribe","emptySetPool","assert","optionalMessage","valueGet","Entry","parents","childValues","dirtyChildren","dirty","recomputing","deps","count","mightBeDirty","recompute","reportDirtyChild","reportCleanChild","forgetChildren","recomputeNewValue","subscribe","setDirty","maybeSubscribe","reportClean","setClean","reallyRecompute","reportDirty","forgetChild","dependOn","dep","forgetDeps","childValue","removeDirtyChild","dc","_value","depsByKey","depend","dep_1","keyTrie","defaultMakeCacheKey","caches","originalFunction","cache","pow","keyArgs","makeCacheKey","optimistic","forget","ReactPropTypesSecret","emptyFunction","emptyFunctionWithReset","resetWarningCache","shim","propName","componentName","propFullName","secret","getShim","isRequired","ReactPropTypes","bool","func","number","string","symbol","arrayOf","element","elementType","instanceOf","objectOf","oneOf","oneOfType","shape","exact","checkPropTypes","PropTypes","runtime","Op","hasOwn","$Symbol","iteratorSymbol","asyncIteratorSymbol","toStringTagSymbol","define","innerFn","outerFn","tryLocsList","protoGenerator","Generator","generator","Context","_invoke","GenStateSuspendedStart","method","arg","GenStateExecuting","GenStateCompleted","doneResult","delegate","delegateResult","maybeInvokeDelegate","ContinueSentinel","sent","_sent","dispatchException","abrupt","record","tryCatch","GenStateSuspendedYield","makeInvokeMethod","GeneratorFunction","GeneratorFunctionPrototype","IteratorPrototype","getProto","NativeIteratorPrototype","Gp","defineIteratorMethods","AsyncIterator","PromiseImpl","invoke","resolve","reject","__await","then","unwrapped","previousPromise","callInvokeWithMethodAndArg","resultName","nextLoc","pushTryEntry","locs","tryLoc","catchLoc","finallyLoc","afterLoc","tryEntries","resetTryEntry","completion","reset","iterable","iteratorMethod","isGeneratorFunction","genFun","ctor","mark","awrap","async","Promise","iter","reverse","skipTempReset","charAt","stop","rootRecord","rval","exception","handle","caught","hasCatch","hasFinally","finallyEntry","complete","finish","thrown","delegateYield","regeneratorRuntime","accidentalStrictMode","r","XMLHttpRequest","u","ok","status","statusText","url","responseURL","text","responseText","json","blob","Blob","response","headers","toLowerCase","l","open","onload","getAllResponseHeaders","onerror","withCredentials","credentials","setRequestHeader","send","_createClass","staticProps","Observable","hasSymbols","hasSymbol","getSymbol","observable","SymbolIterator","SymbolObservable","SymbolSpecies","getMethod","getSpecies","isObservable","hostReportError","log","setTimeout","enqueue","cleanupSubscription","subscription","cleanup","_cleanup","closeSubscription","_observer","_queue","_state","notifySubscription","observer","m","onNotify","queue","flushSubscription","Subscription","subscriber","subscriptionObserver","SubscriptionObserver","_subscription","_subscriber","_this3","_this4","C","hasSeed","seed","acc","first","_this5","_len","sources","_key","startNext","v","_this6","subscriptions","outer","inner","completeIfDone","closed","_iteratorNormalCompletion","_didIteratorError","_iteratorError","_step","_iterator","_item","return","_len2","_key2"],"mappings":"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","file":"vendor.f377fc23b2bcfc4426d0.js","sourcesContent":["(function (Object) {\n typeof globalThis !== 'object' && (\n this ?\n get() :\n (Object.defineProperty(Object.prototype, '_T_', {\n configurable: true,\n get: get\n }), _T_)\n );\n function get() {\n var global = this || self;\n global.globalThis = global;\n delete Object.prototype._T_;\n }\n}(Object));\nexport default globalThis;\n","// This currentContext variable will only be used if the makeSlotClass\r\n// function is called, which happens only if this is the first copy of the\r\n// @wry/context package to be imported.\r\nvar currentContext = null;\r\n// This unique internal object is used to denote the absence of a value\r\n// for a given Slot, and is never exposed to outside code.\r\nvar MISSING_VALUE = {};\r\nvar idCounter = 1;\r\n// Although we can't do anything about the cost of duplicated code from\r\n// accidentally bundling multiple copies of the @wry/context package, we can\r\n// avoid creating the Slot class more than once using makeSlotClass.\r\nvar makeSlotClass = function () { return /** @class */ (function () {\r\n function Slot() {\r\n // If you have a Slot object, you can find out its slot.id, but you cannot\r\n // guess the slot.id of a Slot you don't have access to, thanks to the\r\n // randomized suffix.\r\n this.id = [\r\n \"slot\",\r\n idCounter++,\r\n Date.now(),\r\n Math.random().toString(36).slice(2),\r\n ].join(\":\");\r\n }\r\n Slot.prototype.hasValue = function () {\r\n for (var context_1 = currentContext; context_1; context_1 = context_1.parent) {\r\n // We use the Slot object iself as a key to its value, which means the\r\n // value cannot be obtained without a reference to the Slot object.\r\n if (this.id in context_1.slots) {\r\n var value = context_1.slots[this.id];\r\n if (value === MISSING_VALUE)\r\n break;\r\n if (context_1 !== currentContext) {\r\n // Cache the value in currentContext.slots so the next lookup will\r\n // be faster. This caching is safe because the tree of contexts and\r\n // the values of the slots are logically immutable.\r\n currentContext.slots[this.id] = value;\r\n }\r\n return true;\r\n }\r\n }\r\n if (currentContext) {\r\n // If a value was not found for this Slot, it's never going to be found\r\n // no matter how many times we look it up, so we might as well cache\r\n // the absence of the value, too.\r\n currentContext.slots[this.id] = MISSING_VALUE;\r\n }\r\n return false;\r\n };\r\n Slot.prototype.getValue = function () {\r\n if (this.hasValue()) {\r\n return currentContext.slots[this.id];\r\n }\r\n };\r\n Slot.prototype.withValue = function (value, callback, \r\n // Given the prevalence of arrow functions, specifying arguments is likely\r\n // to be much more common than specifying `this`, hence this ordering:\r\n args, thisArg) {\r\n var _a;\r\n var slots = (_a = {\r\n __proto__: null\r\n },\r\n _a[this.id] = value,\r\n _a);\r\n var parent = currentContext;\r\n currentContext = { parent: parent, slots: slots };\r\n try {\r\n // Function.prototype.apply allows the arguments array argument to be\r\n // omitted or undefined, so args! is fine here.\r\n return callback.apply(thisArg, args);\r\n }\r\n finally {\r\n currentContext = parent;\r\n }\r\n };\r\n // Capture the current context and wrap a callback function so that it\r\n // reestablishes the captured context when called.\r\n Slot.bind = function (callback) {\r\n var context = currentContext;\r\n return function () {\r\n var saved = currentContext;\r\n try {\r\n currentContext = context;\r\n return callback.apply(this, arguments);\r\n }\r\n finally {\r\n currentContext = saved;\r\n }\r\n };\r\n };\r\n // Immediately run a callback function without any captured context.\r\n Slot.noContext = function (callback, \r\n // Given the prevalence of arrow functions, specifying arguments is likely\r\n // to be much more common than specifying `this`, hence this ordering:\r\n args, thisArg) {\r\n if (currentContext) {\r\n var saved = currentContext;\r\n try {\r\n currentContext = null;\r\n // Function.prototype.apply allows the arguments array argument to be\r\n // omitted or undefined, so args! is fine here.\r\n return callback.apply(thisArg, args);\r\n }\r\n finally {\r\n currentContext = saved;\r\n }\r\n }\r\n else {\r\n return callback.apply(thisArg, args);\r\n }\r\n };\r\n return Slot;\r\n}()); };\r\n// We store a single global implementation of the Slot class as a permanent\r\n// non-enumerable symbol property of the Array constructor. This obfuscation\r\n// does nothing to prevent access to the Slot class, but at least it ensures\r\n// the implementation (i.e. currentContext) cannot be tampered with, and all\r\n// copies of the @wry/context package (hopefully just one) will share the\r\n// same Slot implementation. Since the first copy of the @wry/context package\r\n// to be imported wins, this technique imposes a very high cost for any\r\n// future breaking changes to the Slot class.\r\nvar globalKey = \"@wry/context:Slot\";\r\nvar host = Array;\r\nvar Slot = host[globalKey] || function () {\r\n var Slot = makeSlotClass();\r\n try {\r\n Object.defineProperty(host, globalKey, {\r\n value: host[globalKey] = Slot,\r\n enumerable: false,\r\n writable: false,\r\n configurable: false,\r\n });\r\n }\r\n finally {\r\n return Slot;\r\n }\r\n}();\n\nvar bind = Slot.bind, noContext = Slot.noContext;\r\nfunction setTimeoutWithContext(callback, delay) {\r\n return setTimeout(bind(callback), delay);\r\n}\r\n// Turn any generator function into an async function (using yield instead\r\n// of await), with context automatically preserved across yields.\r\nfunction asyncFromGen(genFn) {\r\n return function () {\r\n var gen = genFn.apply(this, arguments);\r\n var boundNext = bind(gen.next);\r\n var boundThrow = bind(gen.throw);\r\n return new Promise(function (resolve, reject) {\r\n function invoke(method, argument) {\r\n try {\r\n var result = method.call(gen, argument);\r\n }\r\n catch (error) {\r\n return reject(error);\r\n }\r\n var next = result.done ? resolve : invokeNext;\r\n if (isPromiseLike(result.value)) {\r\n result.value.then(next, result.done ? reject : invokeThrow);\r\n }\r\n else {\r\n next(result.value);\r\n }\r\n }\r\n var invokeNext = function (value) { return invoke(boundNext, value); };\r\n var invokeThrow = function (error) { return invoke(boundThrow, error); };\r\n invokeNext();\r\n });\r\n };\r\n}\r\nfunction isPromiseLike(value) {\r\n return value && typeof value.then === \"function\";\r\n}\r\n// If you use the fibers npm package to implement coroutines in Node.js,\r\n// you should call this function at least once to ensure context management\r\n// remains coherent across any yields.\r\nvar wrappedFibers = [];\r\nfunction wrapYieldingFiberMethods(Fiber) {\r\n // There can be only one implementation of Fiber per process, so this array\r\n // should never grow longer than one element.\r\n if (wrappedFibers.indexOf(Fiber) < 0) {\r\n var wrap = function (obj, method) {\r\n var fn = obj[method];\r\n obj[method] = function () {\r\n return noContext(fn, arguments, this);\r\n };\r\n };\r\n // These methods can yield, according to\r\n // https://github.com/laverdet/node-fibers/blob/ddebed9b8ae3883e57f822e2108e6943e5c8d2a8/fibers.js#L97-L100\r\n wrap(Fiber, \"yield\");\r\n wrap(Fiber.prototype, \"run\");\r\n wrap(Fiber.prototype, \"throwInto\");\r\n wrappedFibers.push(Fiber);\r\n }\r\n return Fiber;\r\n}\n\nexport { Slot, asyncFromGen, bind, noContext, setTimeoutWithContext as setTimeout, wrapYieldingFiberMethods };\n//# sourceMappingURL=context.esm.js.map\n","var _a = Object.prototype, toString = _a.toString, hasOwnProperty = _a.hasOwnProperty;\r\nvar fnToStr = Function.prototype.toString;\r\nvar previousComparisons = new Map();\r\n/**\r\n * Performs a deep equality check on two JavaScript values, tolerating cycles.\r\n */\r\nfunction equal(a, b) {\r\n try {\r\n return check(a, b);\r\n }\r\n finally {\r\n previousComparisons.clear();\r\n }\r\n}\r\nfunction check(a, b) {\r\n // If the two values are strictly equal, our job is easy.\r\n if (a === b) {\r\n return true;\r\n }\r\n // Object.prototype.toString returns a representation of the runtime type of\r\n // the given value that is considerably more precise than typeof.\r\n var aTag = toString.call(a);\r\n var bTag = toString.call(b);\r\n // If the runtime types of a and b are different, they could maybe be equal\r\n // under some interpretation of equality, but for simplicity and performance\r\n // we just return false instead.\r\n if (aTag !== bTag) {\r\n return false;\r\n }\r\n switch (aTag) {\r\n case '[object Array]':\r\n // Arrays are a lot like other objects, but we can cheaply compare their\r\n // lengths as a short-cut before comparing their elements.\r\n if (a.length !== b.length)\r\n return false;\r\n // Fall through to object case...\r\n case '[object Object]': {\r\n if (previouslyCompared(a, b))\r\n return true;\r\n var aKeys = definedKeys(a);\r\n var bKeys = definedKeys(b);\r\n // If `a` and `b` have a different number of enumerable keys, they\r\n // must be different.\r\n var keyCount = aKeys.length;\r\n if (keyCount !== bKeys.length)\r\n return false;\r\n // Now make sure they have the same keys.\r\n for (var k = 0; k < keyCount; ++k) {\r\n if (!hasOwnProperty.call(b, aKeys[k])) {\r\n return false;\r\n }\r\n }\r\n // Finally, check deep equality of all child properties.\r\n for (var k = 0; k < keyCount; ++k) {\r\n var key = aKeys[k];\r\n if (!check(a[key], b[key])) {\r\n return false;\r\n }\r\n }\r\n return true;\r\n }\r\n case '[object Error]':\r\n return a.name === b.name && a.message === b.message;\r\n case '[object Number]':\r\n // Handle NaN, which is !== itself.\r\n if (a !== a)\r\n return b !== b;\r\n // Fall through to shared +a === +b case...\r\n case '[object Boolean]':\r\n case '[object Date]':\r\n return +a === +b;\r\n case '[object RegExp]':\r\n case '[object String]':\r\n return a == \"\" + b;\r\n case '[object Map]':\r\n case '[object Set]': {\r\n if (a.size !== b.size)\r\n return false;\r\n if (previouslyCompared(a, b))\r\n return true;\r\n var aIterator = a.entries();\r\n var isMap = aTag === '[object Map]';\r\n while (true) {\r\n var info = aIterator.next();\r\n if (info.done)\r\n break;\r\n // If a instanceof Set, aValue === aKey.\r\n var _a = info.value, aKey = _a[0], aValue = _a[1];\r\n // So this works the same way for both Set and Map.\r\n if (!b.has(aKey)) {\r\n return false;\r\n }\r\n // However, we care about deep equality of values only when dealing\r\n // with Map structures.\r\n if (isMap && !check(aValue, b.get(aKey))) {\r\n return false;\r\n }\r\n }\r\n return true;\r\n }\r\n case '[object Function]': {\r\n var aCode = fnToStr.call(a);\r\n if (aCode !== fnToStr.call(b)) {\r\n return false;\r\n }\r\n // We consider non-native functions equal if they have the same code\r\n // (native functions require === because their code is censored).\r\n // Note that this behavior is not entirely sound, since !== function\r\n // objects with the same code can behave differently depending on\r\n // their closure scope. However, any function can behave differently\r\n // depending on the values of its input arguments (including this)\r\n // and its calling context (including its closure scope), even\r\n // though the function object is === to itself; and it is entirely\r\n // possible for functions that are not === to behave exactly the\r\n // same under all conceivable circumstances. Because none of these\r\n // factors are statically decidable in JavaScript, JS function\r\n // equality is not well-defined. This ambiguity allows us to\r\n // consider the best possible heuristic among various imperfect\r\n // options, and equating non-native functions that have the same\r\n // code has enormous practical benefits, such as when comparing\r\n // functions that are repeatedly passed as fresh function\r\n // expressions within objects that are otherwise deeply equal. Since\r\n // any function created from the same syntactic expression (in the\r\n // same code location) will always stringify to the same code\r\n // according to fnToStr.call, we can reasonably expect these\r\n // repeatedly passed function expressions to have the same code, and\r\n // thus behave \"the same\" (with all the caveats mentioned above),\r\n // even though the runtime function objects are !== to one another.\r\n return !endsWith(aCode, nativeCodeSuffix);\r\n }\r\n }\r\n // Otherwise the values are not equal.\r\n return false;\r\n}\r\nfunction definedKeys(obj) {\r\n // Remember that the second argument to Array.prototype.filter will be\r\n // used as `this` within the callback function.\r\n return Object.keys(obj).filter(isDefinedKey, obj);\r\n}\r\nfunction isDefinedKey(key) {\r\n return this[key] !== void 0;\r\n}\r\nvar nativeCodeSuffix = \"{ [native code] }\";\r\nfunction endsWith(full, suffix) {\r\n var fromIndex = full.length - suffix.length;\r\n return fromIndex >= 0 &&\r\n full.indexOf(suffix, fromIndex) === fromIndex;\r\n}\r\nfunction previouslyCompared(a, b) {\r\n // Though cyclic references can make an object graph appear infinite from the\r\n // perspective of a depth-first traversal, the graph still contains a finite\r\n // number of distinct object references. We use the previousComparisons cache\r\n // to avoid comparing the same pair of object references more than once, which\r\n // guarantees termination (even if we end up comparing every object in one\r\n // graph to every object in the other graph, which is extremely unlikely),\r\n // while still allowing weird isomorphic structures (like rings with different\r\n // lengths) a chance to pass the equality test.\r\n var bSet = previousComparisons.get(a);\r\n if (bSet) {\r\n // Return true here because we can be sure false will be returned somewhere\r\n // else if the objects are not equivalent.\r\n if (bSet.has(b))\r\n return true;\r\n }\r\n else {\r\n previousComparisons.set(a, bSet = new Set);\r\n }\r\n bSet.add(b);\r\n return false;\r\n}\n\nexport default equal;\nexport { equal };\n//# sourceMappingURL=equality.esm.js.map\n","!function(t,n){\"object\"==typeof exports&&\"undefined\"!=typeof module?module.exports=function(t,n,e,i,o){for(n=n.split?n.split(\".\"):n,i=0;i 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.default)];\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","function _typeof(obj) { \"@babel/helpers - typeof\"; 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/* eslint-disable flowtype/no-weak-types */\nimport nodejsCustomInspectSymbol from \"./nodejsCustomInspectSymbol.mjs\";\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 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","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.default = invariant;\n\nfunction invariant(condition, message) {\n var booleanCondition = Boolean(condition); // istanbul ignore else (See transformation done in './resources/inlineInvariant.js')\n\n if (!booleanCondition) {\n throw new Error(message != null ? message : 'Unexpected invariant triggered.');\n }\n}\n","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.default = void 0;\n// istanbul ignore next (See: 'https://github.com/graphql/graphql-js/issues/2317')\nvar nodejsCustomInspectSymbol = typeof Symbol === 'function' && typeof Symbol.for === 'function' ? Symbol.for('nodejs.util.inspect.custom') : undefined;\nvar _default = nodejsCustomInspectSymbol;\nexports.default = _default;\n","// istanbul ignore next (See: 'https://github.com/graphql/graphql-js/issues/2317')\nvar nodejsCustomInspectSymbol = typeof Symbol === 'function' && typeof Symbol.for === 'function' ? Symbol.for('nodejs.util.inspect.custom') : undefined;\nexport default nodejsCustomInspectSymbol;\n","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.isNode = isNode;\nexports.Token = exports.Location = void 0;\n\nvar _defineInspect = _interopRequireDefault(require(\"../jsutils/defineInspect.js\"));\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\n/**\n * Contains a range of UTF-8 character offsets and token references that\n * identify the region of the source from which the AST derived.\n */\nvar Location = /*#__PURE__*/function () {\n /**\n * The character offset at which this Node begins.\n */\n\n /**\n * The character offset at which this Node ends.\n */\n\n /**\n * The Token at which this Node begins.\n */\n\n /**\n * The Token at which this Node ends.\n */\n\n /**\n * The Source document the AST represents.\n */\n function Location(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 }\n\n var _proto = Location.prototype;\n\n _proto.toJSON = function toJSON() {\n return {\n start: this.start,\n end: this.end\n };\n };\n\n return Location;\n}(); // Print a simplified form when appearing in `inspect` and `util.inspect`.\n\n\nexports.Location = Location;\n(0, _defineInspect.default)(Location);\n/**\n * Represents a range of characters represented by a lexical token\n * within a Source.\n */\n\nvar Token = /*#__PURE__*/function () {\n /**\n * The kind of Token.\n */\n\n /**\n * The character offset at which this Node begins.\n */\n\n /**\n * The character offset at which this Node ends.\n */\n\n /**\n * The 1-indexed line number on which this Token appears.\n */\n\n /**\n * The 1-indexed column number at which this Token begins.\n */\n\n /**\n * For non-punctuation tokens, represents the interpreted value of the token.\n */\n\n /**\n * Tokens exist as nodes in a double-linked-list amongst all tokens\n * including ignored tokens. is always the first node and \n * the last.\n */\n function Token(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 }\n\n var _proto2 = Token.prototype;\n\n _proto2.toJSON = function toJSON() {\n return {\n kind: this.kind,\n value: this.value,\n line: this.line,\n column: this.column\n };\n };\n\n return Token;\n}(); // Print a simplified form when appearing in `inspect` and `util.inspect`.\n\n\nexports.Token = Token;\n(0, _defineInspect.default)(Token);\n/**\n * @internal\n */\n\nfunction isNode(maybeNode) {\n return maybeNode != null && typeof maybeNode.kind === 'string';\n}\n/**\n * The list of all possible AST node types.\n */\n","import invariant from \"./invariant.mjs\";\nimport nodejsCustomInspectSymbol from \"./nodejsCustomInspectSymbol.mjs\";\n/**\n * The `defineInspect()` function defines `inspect()` prototype method as alias of `toJSON`\n */\n\nexport default function defineInspect(classObject) {\n var fn = classObject.prototype.toJSON;\n typeof fn === 'function' || invariant(0);\n classObject.prototype.inspect = fn; // istanbul ignore else (See: 'https://github.com/graphql/graphql-js/issues/2317')\n\n if (nodejsCustomInspectSymbol) {\n classObject.prototype[nodejsCustomInspectSymbol] = fn;\n }\n}\n","export default function invariant(condition, message) {\n var booleanCondition = Boolean(condition); // istanbul ignore else (See transformation done in './resources/inlineInvariant.js')\n\n if (!booleanCondition) {\n throw new Error(message != null ? message : 'Unexpected invariant triggered.');\n }\n}\n","import defineInspect from \"../jsutils/defineInspect.mjs\";\n\n/**\n * Contains a range of UTF-8 character offsets and token references that\n * identify the region of the source from which the AST derived.\n */\nexport var Location = /*#__PURE__*/function () {\n /**\n * The character offset at which this Node begins.\n */\n\n /**\n * The character offset at which this Node ends.\n */\n\n /**\n * The Token at which this Node begins.\n */\n\n /**\n * The Token at which this Node ends.\n */\n\n /**\n * The Source document the AST represents.\n */\n function Location(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 }\n\n var _proto = Location.prototype;\n\n _proto.toJSON = function toJSON() {\n return {\n start: this.start,\n end: this.end\n };\n };\n\n return Location;\n}(); // Print a simplified form when appearing in `inspect` and `util.inspect`.\n\ndefineInspect(Location);\n/**\n * Represents a range of characters represented by a lexical token\n * within a Source.\n */\n\nexport var Token = /*#__PURE__*/function () {\n /**\n * The kind of Token.\n */\n\n /**\n * The character offset at which this Node begins.\n */\n\n /**\n * The character offset at which this Node ends.\n */\n\n /**\n * The 1-indexed line number on which this Token appears.\n */\n\n /**\n * The 1-indexed column number at which this Token begins.\n */\n\n /**\n * For non-punctuation tokens, represents the interpreted value of the token.\n */\n\n /**\n * Tokens exist as nodes in a double-linked-list amongst all tokens\n * including ignored tokens. is always the first node and \n * the last.\n */\n function Token(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 }\n\n var _proto2 = Token.prototype;\n\n _proto2.toJSON = function toJSON() {\n return {\n kind: this.kind,\n value: this.value,\n line: this.line,\n column: this.column\n };\n };\n\n return Token;\n}(); // Print a simplified form when appearing in `inspect` and `util.inspect`.\n\ndefineInspect(Token);\n/**\n * @internal\n */\n\nexport function isNode(maybeNode) {\n return maybeNode != null && typeof maybeNode.kind === 'string';\n}\n/**\n * The list of all possible AST node types.\n */\n","/**\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 *\n * @internal\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(rawString);\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 var startLine = 0;\n\n while (startLine < lines.length && isBlank(lines[startLine])) {\n ++startLine;\n }\n\n var endLine = lines.length;\n\n while (endLine > startLine && isBlank(lines[endLine - 1])) {\n --endLine;\n } // Return a string of the lines joined with U+000A.\n\n\n return lines.slice(startLine, endLine).join('\\n');\n}\n\nfunction isBlank(str) {\n for (var i = 0; i < str.length; ++i) {\n if (str[i] !== ' ' && str[i] !== '\\t') {\n return false;\n }\n }\n\n return true;\n}\n/**\n * @internal\n */\n\n\nexport function getBlockStringIndentation(value) {\n var _commonIndent;\n\n var isFirstLine = true;\n var isEmptyLine = true;\n var indent = 0;\n var commonIndent = null;\n\n for (var i = 0; i < value.length; ++i) {\n switch (value.charCodeAt(i)) {\n case 13:\n // \\r\n if (value.charCodeAt(i + 1) === 10) {\n ++i; // skip \\r\\n as one symbol\n }\n\n // falls through\n\n case 10:\n // \\n\n isFirstLine = false;\n isEmptyLine = true;\n indent = 0;\n break;\n\n case 9: // \\t\n\n case 32:\n // \n ++indent;\n break;\n\n default:\n if (isEmptyLine && !isFirstLine && (commonIndent === null || indent < commonIndent)) {\n commonIndent = indent;\n }\n\n isEmptyLine = false;\n }\n }\n\n return (_commonIndent = commonIndent) !== null && _commonIndent !== void 0 ? _commonIndent : 0;\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 * @internal\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 hasTrailingSlash = value[value.length - 1] === '\\\\';\n var printAsMultipleLines = !isSingleLine || hasTrailingQuote || hasTrailingSlash || 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","function _typeof(obj) { \"@babel/helpers - typeof\"; 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","// In ES2015 (or a polyfilled) environment, this will be Symbol.iterator\n// istanbul ignore next (See: 'https://github.com/graphql/graphql-js/issues/2317')\nexport var SYMBOL_ITERATOR = typeof Symbol === 'function' && Symbol.iterator != null ? Symbol.iterator : '@@iterator'; // In ES2017 (or a polyfilled) environment, this will be Symbol.asyncIterator\n// istanbul ignore next (See: 'https://github.com/graphql/graphql-js/issues/2317')\n\nexport var SYMBOL_ASYNC_ITERATOR = typeof Symbol === 'function' && Symbol.asyncIterator != null ? Symbol.asyncIterator : '@@asyncIterator'; // istanbul ignore next (See: 'https://github.com/graphql/graphql-js/issues/2317')\n\nexport var SYMBOL_TO_STRING_TAG = typeof Symbol === 'function' && Symbol.toStringTag != null ? Symbol.toStringTag : '@@toStringTag';\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 \"./location.mjs\";\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 leftPad(padLen, prefix) + (line ? ' | ' + line : ' |');\n }).join('\\n');\n}\n\nfunction whitespace(len) {\n return Array(len + 1).join(' ');\n}\n\nfunction leftPad(len, str) {\n return whitespace(len - str.length) + str;\n}\n","function _typeof(obj) { \"@babel/helpers - typeof\"; 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\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }\n\nfunction _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function\"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }\n\nfunction _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }\n\nfunction _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === \"object\" || typeof call === \"function\")) { return call; } return _assertThisInitialized(self); }\n\nfunction _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return self; }\n\nfunction _wrapNativeSuper(Class) { var _cache = typeof Map === \"function\" ? new Map() : undefined; _wrapNativeSuper = function _wrapNativeSuper(Class) { if (Class === null || !_isNativeFunction(Class)) return Class; if (typeof Class !== \"function\") { throw new TypeError(\"Super expression must either be null or a function\"); } if (typeof _cache !== \"undefined\") { if (_cache.has(Class)) return _cache.get(Class); _cache.set(Class, Wrapper); } function Wrapper() { return _construct(Class, arguments, _getPrototypeOf(this).constructor); } Wrapper.prototype = Object.create(Class.prototype, { constructor: { value: Wrapper, enumerable: false, writable: true, configurable: true } }); return _setPrototypeOf(Wrapper, Class); }; return _wrapNativeSuper(Class); }\n\nfunction _construct(Parent, args, Class) { if (_isNativeReflectConstruct()) { _construct = Reflect.construct; } else { _construct = function _construct(Parent, args, Class) { var a = [null]; a.push.apply(a, args); var Constructor = Function.bind.apply(Parent, a); var instance = new Constructor(); if (Class) _setPrototypeOf(instance, Class.prototype); return instance; }; } return _construct.apply(null, arguments); }\n\nfunction _isNativeReflectConstruct() { if (typeof Reflect === \"undefined\" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === \"function\") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }\n\nfunction _isNativeFunction(fn) { return Function.toString.call(fn).indexOf(\"[native code]\") !== -1; }\n\nfunction _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }\n\nfunction _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }\n\n// FIXME:\n// flowlint uninitialized-instance-property:off\nimport isObjectLike from \"../jsutils/isObjectLike.mjs\";\nimport { SYMBOL_TO_STRING_TAG } from \"../polyfills/symbols.mjs\";\nimport { getLocation } from \"../language/location.mjs\";\nimport { printLocation, printSourceLocation } from \"../language/printLocation.mjs\";\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 var GraphQLError = /*#__PURE__*/function (_Error) {\n _inherits(GraphQLError, _Error);\n\n var _super = _createSuper(GraphQLError);\n\n /**\n * A message describing the Error for debugging purposes.\n *\n * Enumerable, and appears in the result of JSON.stringify().\n *\n * Note: should be treated as readonly, despite invariant usage.\n */\n\n /**\n * An array of { line, column } locations within the source GraphQL document\n * which correspond to this error.\n *\n * Errors during validation often contain multiple locations, for example to\n * point out two things with the same name. Errors during execution include a\n * single location, the field which produced the error.\n *\n * Enumerable, and appears in the result of JSON.stringify().\n */\n\n /**\n * An array describing the JSON-path into the execution response which\n * corresponds to this error. Only included for errors during execution.\n *\n * Enumerable, and appears in the result of JSON.stringify().\n */\n\n /**\n * An array of GraphQL AST Nodes corresponding to this error.\n */\n\n /**\n * The source GraphQL document for the first location of this error.\n *\n * Note that if this Error represents more than one node, the source may not\n * represent nodes after the first node.\n */\n\n /**\n * An array of character offsets within the source GraphQL document\n * which correspond to this error.\n */\n\n /**\n * The original error thrown from a field resolver during execution.\n */\n\n /**\n * Extension fields to add to the formatted error.\n */\n function GraphQLError(message, nodes, source, positions, path, originalError, extensions) {\n var _locations2, _source2, _positions2, _extensions2;\n\n var _this;\n\n _classCallCheck(this, GraphQLError);\n\n _this = _super.call(this, message); // Compute list of blame nodes.\n\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 _nodes$0$loc;\n\n _source = (_nodes$0$loc = _nodes[0].loc) === null || _nodes$0$loc === void 0 ? void 0 : _nodes$0$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(_assertThisInitialized(_this), {\n name: {\n value: 'GraphQLError'\n },\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 falsy values to undefined ensures they will not be included\n // in JSON.stringify() when not provided.\n value: (_locations2 = _locations) !== null && _locations2 !== void 0 ? _locations2 : 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: _locations != null\n },\n path: {\n // Coercing falsy values to undefined ensures they will not be included\n // in JSON.stringify() when not provided.\n value: path !== null && path !== void 0 ? 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: path != null\n },\n nodes: {\n value: _nodes !== null && _nodes !== void 0 ? _nodes : undefined\n },\n source: {\n value: (_source2 = _source) !== null && _source2 !== void 0 ? _source2 : undefined\n },\n positions: {\n value: (_positions2 = _positions) !== null && _positions2 !== void 0 ? _positions2 : undefined\n },\n originalError: {\n value: originalError\n },\n extensions: {\n // Coercing falsy values to undefined ensures they will not be included\n // in JSON.stringify() when not provided.\n value: (_extensions2 = _extensions) !== null && _extensions2 !== void 0 ? _extensions2 : 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: _extensions != null\n }\n }); // Include (non-enumerable) stack trace.\n\n if (originalError !== null && originalError !== void 0 && originalError.stack) {\n Object.defineProperty(_assertThisInitialized(_this), 'stack', {\n value: originalError.stack,\n writable: true,\n configurable: true\n });\n return _possibleConstructorReturn(_this);\n } // istanbul ignore next (See: 'https://github.com/graphql/graphql-js/issues/2317')\n\n\n if (Error.captureStackTrace) {\n Error.captureStackTrace(_assertThisInitialized(_this), GraphQLError);\n } else {\n Object.defineProperty(_assertThisInitialized(_this), 'stack', {\n value: Error().stack,\n writable: true,\n configurable: true\n });\n }\n\n return _this;\n }\n\n _createClass(GraphQLError, [{\n key: \"toString\",\n value: function toString() {\n return printError(this);\n } // FIXME: workaround to not break chai comparisons, should be remove in v16\n // $FlowFixMe[unsupported-syntax] Flow doesn't support computed properties yet\n\n }, {\n key: SYMBOL_TO_STRING_TAG,\n get: function get() {\n return 'Object';\n }\n }]);\n\n return GraphQLError;\n}( /*#__PURE__*/_wrapNativeSuper(Error));\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.mjs\";\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 * An exported enum describing the different kinds of tokens that the\n * lexer emits.\n */\nexport var TokenKind = Object.freeze({\n SOF: '',\n 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","export default function devAssert(condition, message) {\n var booleanCondition = Boolean(condition); // istanbul ignore else (See transformation done in './resources/inlineInvariant.js')\n\n if (!booleanCondition) {\n throw new Error(message);\n }\n}\n","function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }\n\nfunction _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }\n\nimport { SYMBOL_TO_STRING_TAG } from \"../polyfills/symbols.mjs\";\nimport inspect from \"../jsutils/inspect.mjs\";\nimport devAssert from \"../jsutils/devAssert.mjs\";\nimport instanceOf from \"../jsutils/instanceOf.mjs\";\n\n/**\n * A representation of source input to GraphQL. The `name` and `locationOffset` parameters are\n * optional, but they are useful for clients who store GraphQL documents in source files.\n * For example, if the GraphQL input starts at line 40 in a file named `Foo.graphql`, it might\n * be useful for `name` to be `\"Foo.graphql\"` and location to be `{ line: 40, column: 1 }`.\n * The `line` and `column` properties in `locationOffset` are 1-indexed.\n */\nexport var Source = /*#__PURE__*/function () {\n function Source(body) {\n var name = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'GraphQL request';\n var locationOffset = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {\n line: 1,\n column: 1\n };\n typeof body === 'string' || devAssert(0, \"Body must be a string. Received: \".concat(inspect(body), \".\"));\n this.body = body;\n this.name = name;\n this.locationOffset = locationOffset;\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 } // $FlowFixMe[unsupported-syntax] Flow doesn't support computed properties yet\n\n\n _createClass(Source, [{\n key: SYMBOL_TO_STRING_TAG,\n get: function get() {\n return 'Source';\n }\n }]);\n\n return Source;\n}();\n/**\n * Test if the given value is a Source object.\n *\n * @internal\n */\n\n// eslint-disable-next-line no-redeclare\nexport function isSource(source) {\n return instanceOf(source, Source);\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 { syntaxError } from \"../error/syntaxError.mjs\";\nimport { Token } from \"./ast.mjs\";\nimport { TokenKind } from \"./tokenKind.mjs\";\nimport { dedentBlockStringValue } from \"./blockString.mjs\";\n/**\n * Given a Source object, creates 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 var Lexer = /*#__PURE__*/function () {\n /**\n * The previously focused non-ignored token.\n */\n\n /**\n * The currently focused non-ignored token.\n */\n\n /**\n * The (1-indexed) line containing the current token.\n */\n\n /**\n * The character offset at which the current line begins.\n */\n function Lexer(source) {\n var startOfFileToken = new Token(TokenKind.SOF, 0, 0, 0, 0, null);\n this.source = source;\n this.lastToken = startOfFileToken;\n this.token = startOfFileToken;\n this.line = 1;\n this.lineStart = 0;\n }\n /**\n * Advances the token stream to the next non-ignored token.\n */\n\n\n var _proto = Lexer.prototype;\n\n _proto.advance = function advance() {\n this.lastToken = this.token;\n var token = this.token = this.lookahead();\n return token;\n }\n /**\n * Looks ahead and returns the next non-ignored token, but does not change\n * the state of Lexer.\n */\n ;\n\n _proto.lookahead = function lookahead() {\n var token = this.token;\n\n if (token.kind !== TokenKind.EOF) {\n do {\n var _token$next;\n\n // Note: next is only mutable during parsing, so we cast to allow this.\n token = (_token$next = token.next) !== null && _token$next !== void 0 ? _token$next : token.next = readToken(this, token);\n } while (token.kind === TokenKind.COMMENT);\n }\n\n return token;\n };\n\n return Lexer;\n}();\n/**\n * @internal\n */\n\nexport function isPunctuatorTokenKind(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\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 = prev.end;\n\n while (pos < bodyLength) {\n var code = body.charCodeAt(pos);\n var _line = lexer.line;\n\n var _col = 1 + pos - lexer.lineStart; // SourceCharacter\n\n\n switch (code) {\n case 0xfeff: // \n\n case 9: // \\t\n\n case 32: // \n\n case 44:\n // ,\n ++pos;\n continue;\n\n case 10:\n // \\n\n ++pos;\n ++lexer.line;\n lexer.lineStart = pos;\n continue;\n\n case 13:\n // \\r\n if (body.charCodeAt(pos + 1) === 10) {\n pos += 2;\n } else {\n ++pos;\n }\n\n ++lexer.line;\n lexer.lineStart = pos;\n continue;\n\n case 33:\n // !\n return new Token(TokenKind.BANG, pos, pos + 1, _line, _col, prev);\n\n case 35:\n // #\n return readComment(source, pos, _line, _col, prev);\n\n case 36:\n // $\n return new Token(TokenKind.DOLLAR, pos, pos + 1, _line, _col, prev);\n\n case 38:\n // &\n return new Token(TokenKind.AMP, pos, pos + 1, _line, _col, prev);\n\n case 40:\n // (\n return new Token(TokenKind.PAREN_L, pos, pos + 1, _line, _col, prev);\n\n case 41:\n // )\n return new Token(TokenKind.PAREN_R, pos, pos + 1, _line, _col, prev);\n\n case 46:\n // .\n if (body.charCodeAt(pos + 1) === 46 && body.charCodeAt(pos + 2) === 46) {\n return new Token(TokenKind.SPREAD, pos, pos + 3, _line, _col, prev);\n }\n\n break;\n\n case 58:\n // :\n return new Token(TokenKind.COLON, pos, pos + 1, _line, _col, prev);\n\n case 61:\n // =\n return new Token(TokenKind.EQUALS, pos, pos + 1, _line, _col, prev);\n\n case 64:\n // @\n return new Token(TokenKind.AT, pos, pos + 1, _line, _col, prev);\n\n case 91:\n // [\n return new Token(TokenKind.BRACKET_L, pos, pos + 1, _line, _col, prev);\n\n case 93:\n // ]\n return new Token(TokenKind.BRACKET_R, pos, pos + 1, _line, _col, prev);\n\n case 123:\n // {\n return new Token(TokenKind.BRACE_L, pos, pos + 1, _line, _col, prev);\n\n case 124:\n // |\n return new Token(TokenKind.PIPE, pos, pos + 1, _line, _col, prev);\n\n case 125:\n // }\n return new Token(TokenKind.BRACE_R, pos, pos + 1, _line, _col, prev);\n\n case 34:\n // \"\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 case 45: // -\n\n case 48: // 0\n\n case 49: // 1\n\n case 50: // 2\n\n case 51: // 3\n\n case 52: // 4\n\n case 53: // 5\n\n case 54: // 6\n\n case 55: // 7\n\n case 56: // 8\n\n case 57:\n // 9\n return readNumber(source, pos, code, _line, _col, prev);\n\n case 65: // A\n\n case 66: // B\n\n case 67: // C\n\n case 68: // D\n\n case 69: // E\n\n case 70: // F\n\n case 71: // G\n\n case 72: // H\n\n case 73: // I\n\n case 74: // J\n\n case 75: // K\n\n case 76: // L\n\n case 77: // M\n\n case 78: // N\n\n case 79: // O\n\n case 80: // P\n\n case 81: // Q\n\n case 82: // R\n\n case 83: // S\n\n case 84: // T\n\n case 85: // U\n\n case 86: // V\n\n case 87: // W\n\n case 88: // X\n\n case 89: // Y\n\n case 90: // Z\n\n case 95: // _\n\n case 97: // a\n\n case 98: // b\n\n case 99: // c\n\n case 100: // d\n\n case 101: // e\n\n case 102: // f\n\n case 103: // g\n\n case 104: // h\n\n case 105: // i\n\n case 106: // j\n\n case 107: // k\n\n case 108: // l\n\n case 109: // m\n\n case 110: // n\n\n case 111: // o\n\n case 112: // p\n\n case 113: // q\n\n case 114: // r\n\n case 115: // s\n\n case 116: // t\n\n case 117: // u\n\n case 118: // v\n\n case 119: // w\n\n case 120: // x\n\n case 121: // y\n\n case 122:\n // z\n return readName(source, pos, _line, _col, prev);\n }\n\n throw syntaxError(source, pos, unexpectedCharacterMessage(code));\n }\n\n var line = lexer.line;\n var col = 1 + pos - lexer.lineStart;\n return new Token(TokenKind.EOF, bodyLength, bodyLength, line, col, prev);\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 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 Token(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 NameStart\n\n\n if (code === 46 || isNameStart(code)) {\n throw syntaxError(source, position, \"Invalid number, expected digit but got: \".concat(printCharCode(code), \".\"));\n }\n\n return new Token(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 Token(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 Token(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 Token(TokenKind.NAME, start, position, line, col, prev, body.slice(start, position));\n} // _ A-Z a-z\n\n\nfunction isNameStart(code) {\n return code === 95 || code >= 65 && code <= 90 || code >= 97 && code <= 122;\n}\n","import { syntaxError } from \"../error/syntaxError.mjs\";\nimport { Kind } from \"./kinds.mjs\";\nimport { Location } from \"./ast.mjs\";\nimport { TokenKind } from \"./tokenKind.mjs\";\nimport { Source, isSource } from \"./source.mjs\";\nimport { DirectiveLocation } from \"./directiveLocation.mjs\";\nimport { Lexer, isPunctuatorTokenKind } from \"./lexer.mjs\";\n/**\n * Configuration options to control parser behavior\n */\n\n/**\n * Given a GraphQL source, parses it into a Document.\n * Throws GraphQLError if a syntax error is encountered.\n */\nexport function parse(source, options) {\n 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/**\n * This class is exported only to assist people in implementing their own parsers\n * without duplicating too much code and should be used only as last resort for cases\n * such as experimental syntax or if certain features could not be contributed upstream.\n *\n * It is still part of the internal API and is versioned, so any changes to it are never\n * considered breaking changes. If you still need to support multiple versions of the\n * library, please use the `versionInfo` variable for version detection.\n *\n * @internal\n */\n\nexport var Parser = /*#__PURE__*/function () {\n function Parser(source, options) {\n var sourceObj = isSource(source) ? source : new Source(source);\n this._lexer = new Lexer(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 _this$_options;\n\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 = this._options) === null || _this$_options === void 0 ? void 0 : _this$_options.experimentalFragmentVariables) === true) {\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 this._lexer.advance();\n\n switch (token.value) {\n case 'true':\n return {\n kind: Kind.BOOLEAN,\n value: true,\n loc: this.loc(token)\n };\n\n case 'false':\n return {\n kind: Kind.BOOLEAN,\n value: false,\n loc: this.loc(token)\n };\n\n case 'null':\n return {\n kind: Kind.NULL,\n loc: this.loc(token)\n };\n\n default:\n return {\n kind: Kind.ENUM,\n value: token.value,\n loc: this.loc(token)\n };\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 : Description? schema Directives[Const]? { OperationTypeDefinition+ }\n */\n ;\n\n _proto.parseSchemaDefinition = function parseSchemaDefinition() {\n var start = this._lexer.token;\n var description = this.parseDescription();\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 description: description,\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 _this$_options2;\n\n if (!this.expectOptionalKeyword('implements')) {\n return [];\n }\n\n if (((_this$_options2 = this._options) === null || _this$_options2 === void 0 ? void 0 : _this$_options2.allowLegacySDLImplementsInterfaces) === true) {\n var types = []; // Optional leading ampersand\n\n this.expectOptionalToken(TokenKind.AMP);\n\n do {\n types.push(this.parseNamedType());\n } while (this.expectOptionalToken(TokenKind.AMP) || this.peek(TokenKind.NAME));\n\n return types;\n }\n\n return this.delimitedMany(TokenKind.AMP, this.parseNamedType);\n }\n /**\n * FieldsDefinition : { FieldDefinition+ }\n */\n ;\n\n _proto.parseFieldsDefinition = function parseFieldsDefinition() {\n var _this$_options3;\n\n // Legacy support for the SDL?\n if (((_this$_options3 = this._options) === null || _this$_options3 === void 0 ? void 0 : _this$_options3.allowLegacySDLEmptyFields) === true && 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 interfaces = this.parseImplementsInterfaces();\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 interfaces: interfaces,\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 return this.expectOptionalToken(TokenKind.EQUALS) ? this.delimitedMany(TokenKind.PIPE, this.parseNamedType) : [];\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 ImplementsInterfaces? Directives[Const]? FieldsDefinition\n * - extend interface Name ImplementsInterfaces? Directives[Const]\n * - extend interface Name ImplementsInterfaces\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 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.INTERFACE_TYPE_EXTENSION,\n name: name,\n interfaces: interfaces,\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 return this.delimitedMany(TokenKind.PIPE, this.parseDirectiveLocation);\n }\n /*\n * DirectiveLocation :\n * - ExecutableDirectiveLocation\n * - TypeSystemDirectiveLocation\n *\n * ExecutableDirectiveLocation : one of\n * `QUERY`\n * `MUTATION`\n * `SUBSCRIPTION`\n * `FIELD`\n * `FRAGMENT_DEFINITION`\n * `FRAGMENT_SPREAD`\n * `INLINE_FRAGMENT`\n *\n * TypeSystemDirectiveLocation : one of\n * `SCHEMA`\n * `SCALAR`\n * `OBJECT`\n * `FIELD_DEFINITION`\n * `ARGUMENT_DEFINITION`\n * `INTERFACE`\n * `UNION`\n * `ENUM`\n * `ENUM_VALUE`\n * `INPUT_OBJECT`\n * `INPUT_FIELD_DEFINITION`\n */\n ;\n\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 the source that created a given parsed object.\n */\n ;\n\n _proto.loc = function loc(startToken) {\n var _this$_options4;\n\n if (((_this$_options4 = this._options) === null || _this$_options4 === void 0 ? void 0 : _this$_options4.noLocation) !== true) {\n return new Location(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 the lexer.\n * 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(getTokenKindDesc(kind), \", found \").concat(getTokenDesc(token), \".\"));\n }\n /**\n * If the next token is of the given kind, return that token after advancing the lexer.\n * Otherwise, do not change the parser state and 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 the lexer.\n * 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 is encountered.\n */\n ;\n\n _proto.unexpected = function unexpected(atToken) {\n var token = atToken !== null && atToken !== void 0 ? 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 the parseFn.\n * This list begins with a lex token of openKind and ends with a lex token of closeKind.\n * Advances the parser to the next lex token after the closing token.\n */\n ;\n\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 return non-empty list\n * that begins with a lex token of openKind and ends with a lex token of closeKind.\n * Advances the parser to the next lex token after the closing token.\n */\n ;\n\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 the parseFn.\n * This list begins with a lex token of openKind and ends with a lex token of closeKind.\n * Advances the parser to the next lex token after the closing token.\n */\n ;\n\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 * Returns a non-empty list of parse nodes, determined by the parseFn.\n * This list may begin with a lex token of delimiterKind followed by items separated by lex tokens of tokenKind.\n * Advances the parser to the next lex token after last item in the list.\n */\n ;\n\n _proto.delimitedMany = function delimitedMany(delimiterKind, parseFn) {\n this.expectOptionalToken(delimiterKind);\n var nodes = [];\n\n do {\n nodes.push(parseFn.call(this));\n } while (this.expectOptionalToken(delimiterKind));\n\n return nodes;\n };\n\n return Parser;\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 getTokenKindDesc(token.kind) + (value != null ? \" \\\"\".concat(value, \"\\\"\") : '');\n}\n/**\n * A helper function to describe a token kind as a string for debugging.\n */\n\n\nfunction getTokenKindDesc(kind) {\n return isPunctuatorTokenKind(kind) ? \"\\\"\".concat(kind, \"\\\"\") : kind;\n}\n","import { visit } from \"./visitor.mjs\";\nimport { printBlockString } from \"./blockString.mjs\";\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}\nvar MAX_LINE_LENGTH = 80; // 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 var prefix = wrap('', alias, ': ') + name;\n var argsLine = prefix + wrap('(', join(args, ', '), ')');\n\n if (argsLine.length > MAX_LINE_LENGTH) {\n argsLine = prefix + wrap('(\\n', indent(join(args, '\\n')), '\\n)');\n }\n\n return join([argsLine, 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: addDescription(function (_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 interfaces = _ref26.interfaces,\n directives = _ref26.directives,\n fields = _ref26.fields;\n return join(['interface', name, wrap('implements ', join(interfaces, ' & ')), 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 interfaces = _ref35.interfaces,\n directives = _ref35.directives,\n fields = _ref35.fields;\n return join(['extend interface', name, wrap('implements ', join(interfaces, ' & ')), 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) {\n var _maybeArray$filter$jo;\n\n var separator = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';\n return (_maybeArray$filter$jo = maybeArray === null || maybeArray === void 0 ? void 0 : maybeArray.filter(function (x) {\n return x;\n }).join(separator)) !== null && _maybeArray$filter$jo !== void 0 ? _maybeArray$filter$jo : '';\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 wrap('{\\n', indent(join(array, '\\n')), '\\n}');\n}\n/**\n * If maybeString is not null or empty, then wrap with start and end, otherwise print an empty string.\n */\n\n\nfunction wrap(start, maybeString) {\n var end = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '';\n return maybeString != null && maybeString !== '' ? start + maybeString + end : '';\n}\n\nfunction indent(str) {\n return wrap(' ', str.replace(/\\n/g, '\\n '));\n}\n\nfunction isMultiline(str) {\n return str.indexOf('\\n') !== -1;\n}\n\nfunction hasMultilineItems(maybeArray) {\n return maybeArray != null && maybeArray.some(isMultiline);\n}\n","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.visit = visit;\nexports.visitInParallel = visitInParallel;\nexports.getVisitFn = getVisitFn;\nexports.BREAK = exports.QueryDocumentKeys = void 0;\n\nvar _inspect = _interopRequireDefault(require(\"../jsutils/inspect.js\"));\n\nvar _ast = require(\"./ast.js\");\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nvar 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: ['description', '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', 'interfaces', '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', 'interfaces', 'directives', 'fields'],\n UnionTypeExtension: ['name', 'directives', 'types'],\n EnumTypeExtension: ['name', 'directives', 'values'],\n InputObjectTypeExtension: ['name', 'directives', 'fields']\n};\nexports.QueryDocumentKeys = QueryDocumentKeys;\nvar 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 the\n * visitor API:\n *\n * 1) Named visitors triggered when entering a node of 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\nexports.BREAK = BREAK;\n\nfunction 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 (!(0, _ast.isNode)(node)) {\n throw new Error(\"Invalid AST Node: \".concat((0, _inspect.default)(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 ((0, _ast.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 var _visitorKeys$node$kin;\n\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$kin = visitorKeys[node.kind]) !== null && _visitorKeys$node$kin !== void 0 ? _visitorKeys$node$kin : [];\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/**\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\nfunction 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] == null) {\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] == null) {\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 * 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\n\nfunction 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 inspect from \"../jsutils/inspect.mjs\";\nimport { isNode } from \"./ast.mjs\";\n/**\n * A visitor is provided to visit, it contains the collection of\n * relevant functions to be called during the visitor's traversal.\n */\n\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: ['description', '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', 'interfaces', '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', 'interfaces', '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 the\n * visitor API:\n *\n * 1) Named visitors triggered when entering a node of 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: \".concat(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 var _visitorKeys$node$kin;\n\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$kin = visitorKeys[node.kind]) !== null && _visitorKeys$node$kin !== void 0 ? _visitorKeys$node$kin : [];\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/**\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\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] == null) {\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] == null) {\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 * 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","'use strict';\n\nvar reactIs = require('react-is');\n\n/**\n * Copyright 2015, Yahoo! Inc.\n * Copyrights licensed under the New BSD License. See the accompanying LICENSE file for terms.\n */\nvar REACT_STATICS = {\n childContextTypes: true,\n contextType: true,\n contextTypes: true,\n defaultProps: true,\n displayName: true,\n getDefaultProps: true,\n getDerivedStateFromError: true,\n getDerivedStateFromProps: true,\n mixins: true,\n propTypes: true,\n type: true\n};\nvar KNOWN_STATICS = {\n name: true,\n length: true,\n prototype: true,\n caller: true,\n callee: true,\n arguments: true,\n arity: true\n};\nvar FORWARD_REF_STATICS = {\n '$$typeof': true,\n render: true,\n defaultProps: true,\n displayName: true,\n propTypes: true\n};\nvar MEMO_STATICS = {\n '$$typeof': true,\n compare: true,\n defaultProps: true,\n displayName: true,\n propTypes: true,\n type: true\n};\nvar TYPE_STATICS = {};\nTYPE_STATICS[reactIs.ForwardRef] = FORWARD_REF_STATICS;\nTYPE_STATICS[reactIs.Memo] = MEMO_STATICS;\n\nfunction getStatics(component) {\n // React v16.11 and below\n if (reactIs.isMemo(component)) {\n return MEMO_STATICS;\n } // React v16.12 and above\n\n\n return TYPE_STATICS[component['$$typeof']] || REACT_STATICS;\n}\n\nvar defineProperty = Object.defineProperty;\nvar getOwnPropertyNames = Object.getOwnPropertyNames;\nvar getOwnPropertySymbols = Object.getOwnPropertySymbols;\nvar getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;\nvar getPrototypeOf = Object.getPrototypeOf;\nvar objectPrototype = Object.prototype;\nfunction hoistNonReactStatics(targetComponent, sourceComponent, blacklist) {\n if (typeof sourceComponent !== 'string') {\n // don't hoist over string (html) components\n if (objectPrototype) {\n var inheritedComponent = getPrototypeOf(sourceComponent);\n\n if (inheritedComponent && inheritedComponent !== objectPrototype) {\n hoistNonReactStatics(targetComponent, inheritedComponent, blacklist);\n }\n }\n\n var keys = getOwnPropertyNames(sourceComponent);\n\n if (getOwnPropertySymbols) {\n keys = keys.concat(getOwnPropertySymbols(sourceComponent));\n }\n\n var targetStatics = getStatics(targetComponent);\n var sourceStatics = getStatics(sourceComponent);\n\n for (var i = 0; i < keys.length; ++i) {\n var key = keys[i];\n\n if (!KNOWN_STATICS[key] && !(blacklist && blacklist[key]) && !(sourceStatics && sourceStatics[key]) && !(targetStatics && targetStatics[key])) {\n var descriptor = getOwnPropertyDescriptor(sourceComponent, key);\n\n try {\n // Avoid failures from read-only properties\n defineProperty(targetComponent, key, descriptor);\n } catch (e) {}\n }\n }\n }\n\n return targetComponent;\n}\n\nmodule.exports = hoistNonReactStatics;\n","export default function _setPrototypeOf(o, p) {\n _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {\n o.__proto__ = p;\n return o;\n };\n\n return _setPrototypeOf(o, p);\n}","import setPrototypeOf from \"@babel/runtime/helpers/esm/setPrototypeOf\";\nexport default function _inheritsLoose(subClass, superClass) {\n subClass.prototype = Object.create(superClass.prototype);\n subClass.prototype.constructor = subClass;\n setPrototypeOf(subClass, superClass);\n}","import React, { Component } from 'react';\nimport _inheritsLoose from '@babel/runtime/helpers/esm/inheritsLoose';\nimport PropTypes from 'prop-types';\nimport warning from 'tiny-warning';\n\nvar MAX_SIGNED_31_BIT_INT = 1073741823;\nvar commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : {};\n\nfunction getUniqueId() {\n var key = '__global_unique_id__';\n return commonjsGlobal[key] = (commonjsGlobal[key] || 0) + 1;\n}\n\nfunction objectIs(x, y) {\n if (x === y) {\n return x !== 0 || 1 / x === 1 / y;\n } else {\n return x !== x && y !== y;\n }\n}\n\nfunction createEventEmitter(value) {\n var handlers = [];\n return {\n on: function on(handler) {\n handlers.push(handler);\n },\n off: function off(handler) {\n handlers = handlers.filter(function (h) {\n return h !== handler;\n });\n },\n get: function get() {\n return value;\n },\n set: function set(newValue, changedBits) {\n value = newValue;\n handlers.forEach(function (handler) {\n return handler(value, changedBits);\n });\n }\n };\n}\n\nfunction onlyChild(children) {\n return Array.isArray(children) ? children[0] : children;\n}\n\nfunction createReactContext(defaultValue, calculateChangedBits) {\n var _Provider$childContex, _Consumer$contextType;\n\n var contextProp = '__create-react-context-' + getUniqueId() + '__';\n\n var Provider = /*#__PURE__*/function (_Component) {\n _inheritsLoose(Provider, _Component);\n\n function Provider() {\n var _this;\n\n _this = _Component.apply(this, arguments) || this;\n _this.emitter = createEventEmitter(_this.props.value);\n return _this;\n }\n\n var _proto = Provider.prototype;\n\n _proto.getChildContext = function getChildContext() {\n var _ref;\n\n return _ref = {}, _ref[contextProp] = this.emitter, _ref;\n };\n\n _proto.componentWillReceiveProps = function componentWillReceiveProps(nextProps) {\n if (this.props.value !== nextProps.value) {\n var oldValue = this.props.value;\n var newValue = nextProps.value;\n var changedBits;\n\n if (objectIs(oldValue, newValue)) {\n changedBits = 0;\n } else {\n changedBits = typeof calculateChangedBits === 'function' ? calculateChangedBits(oldValue, newValue) : MAX_SIGNED_31_BIT_INT;\n\n if (process.env.NODE_ENV !== 'production') {\n warning((changedBits & MAX_SIGNED_31_BIT_INT) === changedBits, 'calculateChangedBits: Expected the return value to be a ' + '31-bit integer. Instead received: ' + changedBits);\n }\n\n changedBits |= 0;\n\n if (changedBits !== 0) {\n this.emitter.set(nextProps.value, changedBits);\n }\n }\n }\n };\n\n _proto.render = function render() {\n return this.props.children;\n };\n\n return Provider;\n }(Component);\n\n Provider.childContextTypes = (_Provider$childContex = {}, _Provider$childContex[contextProp] = PropTypes.object.isRequired, _Provider$childContex);\n\n var Consumer = /*#__PURE__*/function (_Component2) {\n _inheritsLoose(Consumer, _Component2);\n\n function Consumer() {\n var _this2;\n\n _this2 = _Component2.apply(this, arguments) || this;\n _this2.state = {\n value: _this2.getValue()\n };\n\n _this2.onUpdate = function (newValue, changedBits) {\n var observedBits = _this2.observedBits | 0;\n\n if ((observedBits & changedBits) !== 0) {\n _this2.setState({\n value: _this2.getValue()\n });\n }\n };\n\n return _this2;\n }\n\n var _proto2 = Consumer.prototype;\n\n _proto2.componentWillReceiveProps = function componentWillReceiveProps(nextProps) {\n var observedBits = nextProps.observedBits;\n this.observedBits = observedBits === undefined || observedBits === null ? MAX_SIGNED_31_BIT_INT : observedBits;\n };\n\n _proto2.componentDidMount = function componentDidMount() {\n if (this.context[contextProp]) {\n this.context[contextProp].on(this.onUpdate);\n }\n\n var observedBits = this.props.observedBits;\n this.observedBits = observedBits === undefined || observedBits === null ? MAX_SIGNED_31_BIT_INT : observedBits;\n };\n\n _proto2.componentWillUnmount = function componentWillUnmount() {\n if (this.context[contextProp]) {\n this.context[contextProp].off(this.onUpdate);\n }\n };\n\n _proto2.getValue = function getValue() {\n if (this.context[contextProp]) {\n return this.context[contextProp].get();\n } else {\n return defaultValue;\n }\n };\n\n _proto2.render = function render() {\n return onlyChild(this.props.children)(this.state.value);\n };\n\n return Consumer;\n }(Component);\n\n Consumer.contextTypes = (_Consumer$contextType = {}, _Consumer$contextType[contextProp] = PropTypes.object, _Consumer$contextType);\n return {\n Provider: Provider,\n Consumer: Consumer\n };\n}\n\nvar index = React.createContext || createReactContext;\n\nexport default index;\n","/*\nobject-assign\n(c) Sindre Sorhus\n@license MIT\n*/\n\n'use strict';\n/* eslint-disable no-unused-vars */\nvar getOwnPropertySymbols = Object.getOwnPropertySymbols;\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\nvar propIsEnumerable = Object.prototype.propertyIsEnumerable;\n\nfunction toObject(val) {\n\tif (val === null || val === undefined) {\n\t\tthrow new TypeError('Object.assign cannot be called with null or undefined');\n\t}\n\n\treturn Object(val);\n}\n\nfunction shouldUseNative() {\n\ttry {\n\t\tif (!Object.assign) {\n\t\t\treturn false;\n\t\t}\n\n\t\t// Detect buggy property enumeration order in older V8 versions.\n\n\t\t// https://bugs.chromium.org/p/v8/issues/detail?id=4118\n\t\tvar test1 = new String('abc'); // eslint-disable-line no-new-wrappers\n\t\ttest1[5] = 'de';\n\t\tif (Object.getOwnPropertyNames(test1)[0] === '5') {\n\t\t\treturn false;\n\t\t}\n\n\t\t// https://bugs.chromium.org/p/v8/issues/detail?id=3056\n\t\tvar test2 = {};\n\t\tfor (var i = 0; i < 10; i++) {\n\t\t\ttest2['_' + String.fromCharCode(i)] = i;\n\t\t}\n\t\tvar order2 = Object.getOwnPropertyNames(test2).map(function (n) {\n\t\t\treturn test2[n];\n\t\t});\n\t\tif (order2.join('') !== '0123456789') {\n\t\t\treturn false;\n\t\t}\n\n\t\t// https://bugs.chromium.org/p/v8/issues/detail?id=3056\n\t\tvar test3 = {};\n\t\t'abcdefghijklmnopqrst'.split('').forEach(function (letter) {\n\t\t\ttest3[letter] = letter;\n\t\t});\n\t\tif (Object.keys(Object.assign({}, test3)).join('') !==\n\t\t\t\t'abcdefghijklmnopqrst') {\n\t\t\treturn false;\n\t\t}\n\n\t\treturn true;\n\t} catch (err) {\n\t\t// We don't expect any of the above to throw, but better to be safe.\n\t\treturn false;\n\t}\n}\n\nmodule.exports = shouldUseNative() ? Object.assign : function (target, source) {\n\tvar from;\n\tvar to = toObject(target);\n\tvar symbols;\n\n\tfor (var s = 1; s < arguments.length; s++) {\n\t\tfrom = Object(arguments[s]);\n\n\t\tfor (var key in from) {\n\t\t\tif (hasOwnProperty.call(from, key)) {\n\t\t\t\tto[key] = from[key];\n\t\t\t}\n\t\t}\n\n\t\tif (getOwnPropertySymbols) {\n\t\t\tsymbols = getOwnPropertySymbols(from);\n\t\t\tfor (var i = 0; i < symbols.length; i++) {\n\t\t\t\tif (propIsEnumerable.call(from, symbols[i])) {\n\t\t\t\t\tto[symbols[i]] = from[symbols[i]];\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\treturn to;\n};\n","// A [trie](https://en.wikipedia.org/wiki/Trie) data structure that holds\r\n// object keys weakly, yet can also hold non-object keys, unlike the\r\n// native `WeakMap`.\r\n// If no makeData function is supplied, the looked-up data will be an empty,\r\n// null-prototype Object.\r\nvar defaultMakeData = function () { return Object.create(null); };\r\n// Useful for processing arguments objects as well as arrays.\r\nvar _a = Array.prototype, forEach = _a.forEach, slice = _a.slice;\r\nvar Trie = /** @class */ (function () {\r\n function Trie(weakness, makeData) {\r\n if (weakness === void 0) { weakness = true; }\r\n if (makeData === void 0) { makeData = defaultMakeData; }\r\n this.weakness = weakness;\r\n this.makeData = makeData;\r\n }\r\n Trie.prototype.lookup = function () {\r\n var array = [];\r\n for (var _i = 0; _i < arguments.length; _i++) {\r\n array[_i] = arguments[_i];\r\n }\r\n return this.lookupArray(array);\r\n };\r\n Trie.prototype.lookupArray = function (array) {\r\n var node = this;\r\n forEach.call(array, function (key) { return node = node.getChildTrie(key); });\r\n return node.data || (node.data = this.makeData(slice.call(array)));\r\n };\r\n Trie.prototype.getChildTrie = function (key) {\r\n var map = this.weakness && isObjRef(key)\r\n ? this.weak || (this.weak = new WeakMap())\r\n : this.strong || (this.strong = new Map());\r\n var child = map.get(key);\r\n if (!child)\r\n map.set(key, child = new Trie(this.weakness, this.makeData));\r\n return child;\r\n };\r\n return Trie;\r\n}());\r\nfunction isObjRef(value) {\r\n switch (typeof value) {\r\n case \"object\":\r\n if (value === null)\r\n break;\r\n // Fall through to return true...\r\n case \"function\":\r\n return true;\r\n }\r\n return false;\r\n}\n\nexport { Trie };\n//# sourceMappingURL=trie.esm.js.map\n","import { Trie } from '@wry/trie';\nexport { Trie as KeyTrie } from '@wry/trie';\nimport { Slot } from '@wry/context';\nexport { asyncFromGen, bind as bindContext, noContext, setTimeout } from '@wry/context';\n\nfunction defaultDispose() { }\r\nvar Cache = /** @class */ (function () {\r\n function Cache(max, dispose) {\r\n if (max === void 0) { max = Infinity; }\r\n if (dispose === void 0) { dispose = defaultDispose; }\r\n this.max = max;\r\n this.dispose = dispose;\r\n this.map = new Map();\r\n this.newest = null;\r\n this.oldest = null;\r\n }\r\n Cache.prototype.has = function (key) {\r\n return this.map.has(key);\r\n };\r\n Cache.prototype.get = function (key) {\r\n var entry = this.getEntry(key);\r\n return entry && entry.value;\r\n };\r\n Cache.prototype.getEntry = function (key) {\r\n var entry = this.map.get(key);\r\n if (entry && entry !== this.newest) {\r\n var older = entry.older, newer = entry.newer;\r\n if (newer) {\r\n newer.older = older;\r\n }\r\n if (older) {\r\n older.newer = newer;\r\n }\r\n entry.older = this.newest;\r\n entry.older.newer = entry;\r\n entry.newer = null;\r\n this.newest = entry;\r\n if (entry === this.oldest) {\r\n this.oldest = newer;\r\n }\r\n }\r\n return entry;\r\n };\r\n Cache.prototype.set = function (key, value) {\r\n var entry = this.getEntry(key);\r\n if (entry) {\r\n return entry.value = value;\r\n }\r\n entry = {\r\n key: key,\r\n value: value,\r\n newer: null,\r\n older: this.newest\r\n };\r\n if (this.newest) {\r\n this.newest.newer = entry;\r\n }\r\n this.newest = entry;\r\n this.oldest = this.oldest || entry;\r\n this.map.set(key, entry);\r\n return entry.value;\r\n };\r\n Cache.prototype.clean = function () {\r\n while (this.oldest && this.map.size > this.max) {\r\n this.delete(this.oldest.key);\r\n }\r\n };\r\n Cache.prototype.delete = function (key) {\r\n var entry = this.map.get(key);\r\n if (entry) {\r\n if (entry === this.newest) {\r\n this.newest = entry.older;\r\n }\r\n if (entry === this.oldest) {\r\n this.oldest = entry.newer;\r\n }\r\n if (entry.newer) {\r\n entry.newer.older = entry.older;\r\n }\r\n if (entry.older) {\r\n entry.older.newer = entry.newer;\r\n }\r\n this.map.delete(key);\r\n this.dispose(entry.value, key);\r\n return true;\r\n }\r\n return false;\r\n };\r\n return Cache;\r\n}());\n\nvar parentEntrySlot = new Slot();\n\nfunction maybeUnsubscribe(entryOrDep) {\r\n var unsubscribe = entryOrDep.unsubscribe;\r\n if (typeof unsubscribe === \"function\") {\r\n entryOrDep.unsubscribe = void 0;\r\n unsubscribe();\r\n }\r\n}\n\nvar emptySetPool = [];\r\nvar POOL_TARGET_SIZE = 100;\r\n// Since this package might be used browsers, we should avoid using the\r\n// Node built-in assert module.\r\nfunction assert(condition, optionalMessage) {\r\n if (!condition) {\r\n throw new Error(optionalMessage || \"assertion failure\");\r\n }\r\n}\r\nfunction valueIs(a, b) {\r\n var len = a.length;\r\n return (\r\n // Unknown values are not equal to each other.\r\n len > 0 &&\r\n // Both values must be ordinary (or both exceptional) to be equal.\r\n len === b.length &&\r\n // The underlying value or exception must be the same.\r\n a[len - 1] === b[len - 1]);\r\n}\r\nfunction valueGet(value) {\r\n switch (value.length) {\r\n case 0: throw new Error(\"unknown value\");\r\n case 1: return value[0];\r\n case 2: throw value[1];\r\n }\r\n}\r\nfunction valueCopy(value) {\r\n return value.slice(0);\r\n}\r\nvar Entry = /** @class */ (function () {\r\n function Entry(fn) {\r\n this.fn = fn;\r\n this.parents = new Set();\r\n this.childValues = new Map();\r\n // When this Entry has children that are dirty, this property becomes\r\n // a Set containing other Entry objects, borrowed from emptySetPool.\r\n // When the set becomes empty, it gets recycled back to emptySetPool.\r\n this.dirtyChildren = null;\r\n this.dirty = true;\r\n this.recomputing = false;\r\n this.value = [];\r\n this.deps = null;\r\n ++Entry.count;\r\n }\r\n Entry.prototype.peek = function () {\r\n if (this.value.length === 1 && !mightBeDirty(this)) {\r\n return this.value[0];\r\n }\r\n };\r\n // This is the most important method of the Entry API, because it\r\n // determines whether the cached this.value can be returned immediately,\r\n // or must be recomputed. The overall performance of the caching system\r\n // depends on the truth of the following observations: (1) this.dirty is\r\n // usually false, (2) this.dirtyChildren is usually null/empty, and thus\r\n // (3) valueGet(this.value) is usually returned without recomputation.\r\n Entry.prototype.recompute = function (args) {\r\n assert(!this.recomputing, \"already recomputing\");\r\n rememberParent(this);\r\n return mightBeDirty(this)\r\n ? reallyRecompute(this, args)\r\n : valueGet(this.value);\r\n };\r\n Entry.prototype.setDirty = function () {\r\n if (this.dirty)\r\n return;\r\n this.dirty = true;\r\n this.value.length = 0;\r\n reportDirty(this);\r\n forgetChildren(this);\r\n // We can go ahead and unsubscribe here, since any further dirty\r\n // notifications we receive will be redundant, and unsubscribing may\r\n // free up some resources, e.g. file watchers.\r\n maybeUnsubscribe(this);\r\n };\r\n Entry.prototype.dispose = function () {\r\n var _this = this;\r\n forgetChildren(this);\r\n maybeUnsubscribe(this);\r\n // Because this entry has been kicked out of the cache (in index.js),\r\n // we've lost the ability to find out if/when this entry becomes dirty,\r\n // whether that happens through a subscription, because of a direct call\r\n // to entry.setDirty(), or because one of its children becomes dirty.\r\n // Because of this loss of future information, we have to assume the\r\n // worst (that this entry might have become dirty very soon), so we must\r\n // immediately mark this entry's parents as dirty. Normally we could\r\n // just call entry.setDirty() rather than calling parent.setDirty() for\r\n // each parent, but that would leave this entry in parent.childValues\r\n // and parent.dirtyChildren, which would prevent the child from being\r\n // truly forgotten.\r\n this.parents.forEach(function (parent) {\r\n parent.setDirty();\r\n forgetChild(parent, _this);\r\n });\r\n };\r\n Entry.prototype.dependOn = function (dep) {\r\n dep.add(this);\r\n if (!this.deps) {\r\n this.deps = emptySetPool.pop() || new Set();\r\n }\r\n this.deps.add(dep);\r\n };\r\n Entry.prototype.forgetDeps = function () {\r\n var _this = this;\r\n if (this.deps) {\r\n this.deps.forEach(function (dep) { return dep.delete(_this); });\r\n this.deps.clear();\r\n emptySetPool.push(this.deps);\r\n this.deps = null;\r\n }\r\n };\r\n Entry.count = 0;\r\n return Entry;\r\n}());\r\nfunction rememberParent(child) {\r\n var parent = parentEntrySlot.getValue();\r\n if (parent) {\r\n child.parents.add(parent);\r\n if (!parent.childValues.has(child)) {\r\n parent.childValues.set(child, []);\r\n }\r\n if (mightBeDirty(child)) {\r\n reportDirtyChild(parent, child);\r\n }\r\n else {\r\n reportCleanChild(parent, child);\r\n }\r\n return parent;\r\n }\r\n}\r\nfunction reallyRecompute(entry, args) {\r\n forgetChildren(entry);\r\n // Set entry as the parent entry while calling recomputeNewValue(entry).\r\n parentEntrySlot.withValue(entry, recomputeNewValue, [entry, args]);\r\n if (maybeSubscribe(entry, args)) {\r\n // If we successfully recomputed entry.value and did not fail to\r\n // (re)subscribe, then this Entry is no longer explicitly dirty.\r\n setClean(entry);\r\n }\r\n return valueGet(entry.value);\r\n}\r\nfunction recomputeNewValue(entry, args) {\r\n entry.recomputing = true;\r\n // Set entry.value as unknown.\r\n entry.value.length = 0;\r\n try {\r\n // If entry.fn succeeds, entry.value will become a normal Value.\r\n entry.value[0] = entry.fn.apply(null, args);\r\n }\r\n catch (e) {\r\n // If entry.fn throws, entry.value will become exceptional.\r\n entry.value[1] = e;\r\n }\r\n // Either way, this line is always reached.\r\n entry.recomputing = false;\r\n}\r\nfunction mightBeDirty(entry) {\r\n return entry.dirty || !!(entry.dirtyChildren && entry.dirtyChildren.size);\r\n}\r\nfunction setClean(entry) {\r\n entry.dirty = false;\r\n if (mightBeDirty(entry)) {\r\n // This Entry may still have dirty children, in which case we can't\r\n // let our parents know we're clean just yet.\r\n return;\r\n }\r\n reportClean(entry);\r\n}\r\nfunction reportDirty(child) {\r\n child.parents.forEach(function (parent) { return reportDirtyChild(parent, child); });\r\n}\r\nfunction reportClean(child) {\r\n child.parents.forEach(function (parent) { return reportCleanChild(parent, child); });\r\n}\r\n// Let a parent Entry know that one of its children may be dirty.\r\nfunction reportDirtyChild(parent, child) {\r\n // Must have called rememberParent(child) before calling\r\n // reportDirtyChild(parent, child).\r\n assert(parent.childValues.has(child));\r\n assert(mightBeDirty(child));\r\n if (!parent.dirtyChildren) {\r\n parent.dirtyChildren = emptySetPool.pop() || new Set;\r\n }\r\n else if (parent.dirtyChildren.has(child)) {\r\n // If we already know this child is dirty, then we must have already\r\n // informed our own parents that we are dirty, so we can terminate\r\n // the recursion early.\r\n return;\r\n }\r\n parent.dirtyChildren.add(child);\r\n reportDirty(parent);\r\n}\r\n// Let a parent Entry know that one of its children is no longer dirty.\r\nfunction reportCleanChild(parent, child) {\r\n // Must have called rememberChild(child) before calling\r\n // reportCleanChild(parent, child).\r\n assert(parent.childValues.has(child));\r\n assert(!mightBeDirty(child));\r\n var childValue = parent.childValues.get(child);\r\n if (childValue.length === 0) {\r\n parent.childValues.set(child, valueCopy(child.value));\r\n }\r\n else if (!valueIs(childValue, child.value)) {\r\n parent.setDirty();\r\n }\r\n removeDirtyChild(parent, child);\r\n if (mightBeDirty(parent)) {\r\n return;\r\n }\r\n reportClean(parent);\r\n}\r\nfunction removeDirtyChild(parent, child) {\r\n var dc = parent.dirtyChildren;\r\n if (dc) {\r\n dc.delete(child);\r\n if (dc.size === 0) {\r\n if (emptySetPool.length < POOL_TARGET_SIZE) {\r\n emptySetPool.push(dc);\r\n }\r\n parent.dirtyChildren = null;\r\n }\r\n }\r\n}\r\n// Removes all children from this entry and returns an array of the\r\n// removed children.\r\nfunction forgetChildren(parent) {\r\n if (parent.childValues.size > 0) {\r\n parent.childValues.forEach(function (_value, child) {\r\n forgetChild(parent, child);\r\n });\r\n }\r\n // Remove this parent Entry from any sets to which it was added by the\r\n // addToSet method.\r\n parent.forgetDeps();\r\n // After we forget all our children, this.dirtyChildren must be empty\r\n // and therefore must have been reset to null.\r\n assert(parent.dirtyChildren === null);\r\n}\r\nfunction forgetChild(parent, child) {\r\n child.parents.delete(parent);\r\n parent.childValues.delete(child);\r\n removeDirtyChild(parent, child);\r\n}\r\nfunction maybeSubscribe(entry, args) {\r\n if (typeof entry.subscribe === \"function\") {\r\n try {\r\n maybeUnsubscribe(entry); // Prevent double subscriptions.\r\n entry.unsubscribe = entry.subscribe.apply(null, args);\r\n }\r\n catch (e) {\r\n // If this Entry has a subscribe function and it threw an exception\r\n // (or an unsubscribe function it previously returned now throws),\r\n // return false to indicate that we were not able to subscribe (or\r\n // unsubscribe), and this Entry should remain dirty.\r\n entry.setDirty();\r\n return false;\r\n }\r\n }\r\n // Returning true indicates either that there was no entry.subscribe\r\n // function or that it succeeded.\r\n return true;\r\n}\n\nfunction dep(options) {\r\n var depsByKey = new Map();\r\n var subscribe = options && options.subscribe;\r\n function depend(key) {\r\n var parent = parentEntrySlot.getValue();\r\n if (parent) {\r\n var dep_1 = depsByKey.get(key);\r\n if (!dep_1) {\r\n depsByKey.set(key, dep_1 = new Set);\r\n }\r\n parent.dependOn(dep_1);\r\n if (typeof subscribe === \"function\") {\r\n maybeUnsubscribe(dep_1);\r\n dep_1.unsubscribe = subscribe(key);\r\n }\r\n }\r\n }\r\n depend.dirty = function dirty(key) {\r\n var dep = depsByKey.get(key);\r\n if (dep) {\r\n dep.forEach(function (entry) { return entry.setDirty(); });\r\n depsByKey.delete(key);\r\n maybeUnsubscribe(dep);\r\n }\r\n };\r\n return depend;\r\n}\n\n// The defaultMakeCacheKey function is remarkably powerful, because it gives\r\n// a unique object for any shallow-identical list of arguments. If you need\r\n// to implement a custom makeCacheKey function, you may find it helpful to\r\n// delegate the final work to defaultMakeCacheKey, which is why we export it\r\n// here. However, you may want to avoid defaultMakeCacheKey if your runtime\r\n// does not support WeakMap, or you have the ability to return a string key.\r\n// In those cases, just write your own custom makeCacheKey functions.\r\nvar keyTrie = new Trie(typeof WeakMap === \"function\");\r\nfunction defaultMakeCacheKey() {\r\n var args = [];\r\n for (var _i = 0; _i < arguments.length; _i++) {\r\n args[_i] = arguments[_i];\r\n }\r\n return keyTrie.lookupArray(args);\r\n}\r\nvar caches = new Set();\r\nfunction wrap(originalFunction, options) {\r\n if (options === void 0) { options = Object.create(null); }\r\n var cache = new Cache(options.max || Math.pow(2, 16), function (entry) { return entry.dispose(); });\r\n var keyArgs = options.keyArgs || (function () {\r\n var args = [];\r\n for (var _i = 0; _i < arguments.length; _i++) {\r\n args[_i] = arguments[_i];\r\n }\r\n return args;\r\n });\r\n var makeCacheKey = options.makeCacheKey || defaultMakeCacheKey;\r\n function optimistic() {\r\n var key = makeCacheKey.apply(null, keyArgs.apply(null, arguments));\r\n if (key === void 0) {\r\n return originalFunction.apply(null, arguments);\r\n }\r\n var entry = cache.get(key);\r\n if (!entry) {\r\n cache.set(key, entry = new Entry(originalFunction));\r\n entry.subscribe = options.subscribe;\r\n }\r\n var value = entry.recompute(Array.prototype.slice.call(arguments));\r\n // Move this entry to the front of the least-recently used queue,\r\n // since we just finished computing its value.\r\n cache.set(key, entry);\r\n caches.add(cache);\r\n // Clean up any excess entries in the cache, but only if there is no\r\n // active parent entry, meaning we're not in the middle of a larger\r\n // computation that might be flummoxed by the cleaning.\r\n if (!parentEntrySlot.hasValue()) {\r\n caches.forEach(function (cache) { return cache.clean(); });\r\n caches.clear();\r\n }\r\n return value;\r\n }\r\n function lookup() {\r\n var key = makeCacheKey.apply(null, arguments);\r\n if (key !== void 0) {\r\n return cache.get(key);\r\n }\r\n }\r\n optimistic.dirty = function () {\r\n var entry = lookup.apply(null, arguments);\r\n if (entry) {\r\n entry.setDirty();\r\n }\r\n };\r\n optimistic.peek = function () {\r\n var entry = lookup.apply(null, arguments);\r\n if (entry) {\r\n return entry.peek();\r\n }\r\n };\r\n optimistic.forget = function () {\r\n var key = makeCacheKey.apply(null, arguments);\r\n return key !== void 0 && cache.delete(key);\r\n };\r\n return optimistic;\r\n}\n\nexport { defaultMakeCacheKey, dep, wrap };\n//# sourceMappingURL=bundle.esm.js.map\n","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\n'use strict';\n\nvar ReactPropTypesSecret = require('./lib/ReactPropTypesSecret');\n\nfunction emptyFunction() {}\nfunction emptyFunctionWithReset() {}\nemptyFunctionWithReset.resetWarningCache = emptyFunction;\n\nmodule.exports = function() {\n function shim(props, propName, componentName, location, propFullName, secret) {\n if (secret === ReactPropTypesSecret) {\n // It is still safe when called from React.\n return;\n }\n var err = new Error(\n 'Calling PropTypes validators directly is not supported by the `prop-types` package. ' +\n 'Use PropTypes.checkPropTypes() to call them. ' +\n 'Read more at http://fb.me/use-check-prop-types'\n );\n err.name = 'Invariant Violation';\n throw err;\n };\n shim.isRequired = shim;\n function getShim() {\n return shim;\n };\n // Important!\n // Keep this list in sync with production version in `./factoryWithTypeCheckers.js`.\n var ReactPropTypes = {\n array: shim,\n bool: shim,\n func: shim,\n number: shim,\n object: shim,\n string: shim,\n symbol: shim,\n\n any: shim,\n arrayOf: getShim,\n element: shim,\n elementType: shim,\n instanceOf: getShim,\n node: shim,\n objectOf: getShim,\n oneOf: getShim,\n oneOfType: getShim,\n shape: getShim,\n exact: getShim,\n\n checkPropTypes: emptyFunctionWithReset,\n resetWarningCache: emptyFunction\n };\n\n ReactPropTypes.PropTypes = ReactPropTypes;\n\n return ReactPropTypes;\n};\n","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\nif (process.env.NODE_ENV !== 'production') {\n var ReactIs = require('react-is');\n\n // By explicitly using `prop-types` you are opting into new development behavior.\n // http://fb.me/prop-types-in-prod\n var throwOnDirectAccess = true;\n module.exports = require('./factoryWithTypeCheckers')(ReactIs.isElement, throwOnDirectAccess);\n} else {\n // By explicitly using `prop-types` you are opting into new production behavior.\n // http://fb.me/prop-types-in-prod\n module.exports = require('./factoryWithThrowingShims')();\n}\n","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\n'use strict';\n\nvar ReactPropTypesSecret = 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED';\n\nmodule.exports = ReactPropTypesSecret;\n","/**\n * Copyright (c) 2014-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\nvar runtime = (function (exports) {\n \"use strict\";\n\n var Op = Object.prototype;\n var hasOwn = Op.hasOwnProperty;\n var undefined; // More compressible than void 0.\n var $Symbol = typeof Symbol === \"function\" ? Symbol : {};\n var iteratorSymbol = $Symbol.iterator || \"@@iterator\";\n var asyncIteratorSymbol = $Symbol.asyncIterator || \"@@asyncIterator\";\n var toStringTagSymbol = $Symbol.toStringTag || \"@@toStringTag\";\n\n function define(obj, key, value) {\n Object.defineProperty(obj, key, {\n value: value,\n enumerable: true,\n configurable: true,\n writable: true\n });\n return obj[key];\n }\n try {\n // IE 8 has a broken Object.defineProperty that only works on DOM objects.\n define({}, \"\");\n } catch (err) {\n define = function(obj, key, value) {\n return obj[key] = value;\n };\n }\n\n function wrap(innerFn, outerFn, self, tryLocsList) {\n // If outerFn provided and outerFn.prototype is a Generator, then outerFn.prototype instanceof Generator.\n var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator;\n var generator = Object.create(protoGenerator.prototype);\n var context = new Context(tryLocsList || []);\n\n // The ._invoke method unifies the implementations of the .next,\n // .throw, and .return methods.\n generator._invoke = makeInvokeMethod(innerFn, self, context);\n\n return generator;\n }\n exports.wrap = wrap;\n\n // Try/catch helper to minimize deoptimizations. Returns a completion\n // record like context.tryEntries[i].completion. This interface could\n // have been (and was previously) designed to take a closure to be\n // invoked without arguments, but in all the cases we care about we\n // already have an existing method we want to call, so there's no need\n // to create a new function object. We can even get away with assuming\n // the method takes exactly one argument, since that happens to be true\n // in every case, so we don't have to touch the arguments object. The\n // only additional allocation required is the completion record, which\n // has a stable shape and so hopefully should be cheap to allocate.\n function tryCatch(fn, obj, arg) {\n try {\n return { type: \"normal\", arg: fn.call(obj, arg) };\n } catch (err) {\n return { type: \"throw\", arg: err };\n }\n }\n\n var GenStateSuspendedStart = \"suspendedStart\";\n var GenStateSuspendedYield = \"suspendedYield\";\n var GenStateExecuting = \"executing\";\n var GenStateCompleted = \"completed\";\n\n // Returning this object from the innerFn has the same effect as\n // breaking out of the dispatch switch statement.\n var ContinueSentinel = {};\n\n // Dummy constructor functions that we use as the .constructor and\n // .constructor.prototype properties for functions that return Generator\n // objects. For full spec compliance, you may wish to configure your\n // minifier not to mangle the names of these two functions.\n function Generator() {}\n function GeneratorFunction() {}\n function GeneratorFunctionPrototype() {}\n\n // This is a polyfill for %IteratorPrototype% for environments that\n // don't natively support it.\n var IteratorPrototype = {};\n IteratorPrototype[iteratorSymbol] = function () {\n return this;\n };\n\n var getProto = Object.getPrototypeOf;\n var NativeIteratorPrototype = getProto && getProto(getProto(values([])));\n if (NativeIteratorPrototype &&\n NativeIteratorPrototype !== Op &&\n hasOwn.call(NativeIteratorPrototype, iteratorSymbol)) {\n // This environment has a native %IteratorPrototype%; use it instead\n // of the polyfill.\n IteratorPrototype = NativeIteratorPrototype;\n }\n\n var Gp = GeneratorFunctionPrototype.prototype =\n Generator.prototype = Object.create(IteratorPrototype);\n GeneratorFunction.prototype = Gp.constructor = GeneratorFunctionPrototype;\n GeneratorFunctionPrototype.constructor = GeneratorFunction;\n GeneratorFunction.displayName = define(\n GeneratorFunctionPrototype,\n toStringTagSymbol,\n \"GeneratorFunction\"\n );\n\n // Helper for defining the .next, .throw, and .return methods of the\n // Iterator interface in terms of a single ._invoke method.\n function defineIteratorMethods(prototype) {\n [\"next\", \"throw\", \"return\"].forEach(function(method) {\n define(prototype, method, function(arg) {\n return this._invoke(method, arg);\n });\n });\n }\n\n exports.isGeneratorFunction = function(genFun) {\n var ctor = typeof genFun === \"function\" && genFun.constructor;\n return ctor\n ? ctor === GeneratorFunction ||\n // For the native GeneratorFunction constructor, the best we can\n // do is to check its .name property.\n (ctor.displayName || ctor.name) === \"GeneratorFunction\"\n : false;\n };\n\n exports.mark = function(genFun) {\n if (Object.setPrototypeOf) {\n Object.setPrototypeOf(genFun, GeneratorFunctionPrototype);\n } else {\n genFun.__proto__ = GeneratorFunctionPrototype;\n define(genFun, toStringTagSymbol, \"GeneratorFunction\");\n }\n genFun.prototype = Object.create(Gp);\n return genFun;\n };\n\n // Within the body of any async function, `await x` is transformed to\n // `yield regeneratorRuntime.awrap(x)`, so that the runtime can test\n // `hasOwn.call(value, \"__await\")` to determine if the yielded value is\n // meant to be awaited.\n exports.awrap = function(arg) {\n return { __await: arg };\n };\n\n function AsyncIterator(generator, PromiseImpl) {\n function invoke(method, arg, resolve, reject) {\n var record = tryCatch(generator[method], generator, arg);\n if (record.type === \"throw\") {\n reject(record.arg);\n } else {\n var result = record.arg;\n var value = result.value;\n if (value &&\n typeof value === \"object\" &&\n hasOwn.call(value, \"__await\")) {\n return PromiseImpl.resolve(value.__await).then(function(value) {\n invoke(\"next\", value, resolve, reject);\n }, function(err) {\n invoke(\"throw\", err, resolve, reject);\n });\n }\n\n return PromiseImpl.resolve(value).then(function(unwrapped) {\n // When a yielded Promise is resolved, its final value becomes\n // the .value of the Promise<{value,done}> result for the\n // current iteration.\n result.value = unwrapped;\n resolve(result);\n }, function(error) {\n // If a rejected Promise was yielded, throw the rejection back\n // into the async generator function so it can be handled there.\n return invoke(\"throw\", error, resolve, reject);\n });\n }\n }\n\n var previousPromise;\n\n function enqueue(method, arg) {\n function callInvokeWithMethodAndArg() {\n return new PromiseImpl(function(resolve, reject) {\n invoke(method, arg, resolve, reject);\n });\n }\n\n return previousPromise =\n // If enqueue has been called before, then we want to wait until\n // all previous Promises have been resolved before calling invoke,\n // so that results are always delivered in the correct order. If\n // enqueue has not been called before, then it is important to\n // call invoke immediately, without waiting on a callback to fire,\n // so that the async generator function has the opportunity to do\n // any necessary setup in a predictable way. This predictability\n // is why the Promise constructor synchronously invokes its\n // executor callback, and why async functions synchronously\n // execute code before the first await. Since we implement simple\n // async functions in terms of async generators, it is especially\n // important to get this right, even though it requires care.\n previousPromise ? previousPromise.then(\n callInvokeWithMethodAndArg,\n // Avoid propagating failures to Promises returned by later\n // invocations of the iterator.\n callInvokeWithMethodAndArg\n ) : callInvokeWithMethodAndArg();\n }\n\n // Define the unified helper method that is used to implement .next,\n // .throw, and .return (see defineIteratorMethods).\n this._invoke = enqueue;\n }\n\n defineIteratorMethods(AsyncIterator.prototype);\n AsyncIterator.prototype[asyncIteratorSymbol] = function () {\n return this;\n };\n exports.AsyncIterator = AsyncIterator;\n\n // Note that simple async functions are implemented on top of\n // AsyncIterator objects; they just return a Promise for the value of\n // the final result produced by the iterator.\n exports.async = function(innerFn, outerFn, self, tryLocsList, PromiseImpl) {\n if (PromiseImpl === void 0) PromiseImpl = Promise;\n\n var iter = new AsyncIterator(\n wrap(innerFn, outerFn, self, tryLocsList),\n PromiseImpl\n );\n\n return exports.isGeneratorFunction(outerFn)\n ? iter // If outerFn is a generator, return the full iterator.\n : iter.next().then(function(result) {\n return result.done ? result.value : iter.next();\n });\n };\n\n function makeInvokeMethod(innerFn, self, context) {\n var state = GenStateSuspendedStart;\n\n return function invoke(method, arg) {\n if (state === GenStateExecuting) {\n throw new Error(\"Generator is already running\");\n }\n\n if (state === GenStateCompleted) {\n if (method === \"throw\") {\n throw arg;\n }\n\n // Be forgiving, per 25.3.3.3.3 of the spec:\n // https://people.mozilla.org/~jorendorff/es6-draft.html#sec-generatorresume\n return doneResult();\n }\n\n context.method = method;\n context.arg = arg;\n\n while (true) {\n var delegate = context.delegate;\n if (delegate) {\n var delegateResult = maybeInvokeDelegate(delegate, context);\n if (delegateResult) {\n if (delegateResult === ContinueSentinel) continue;\n return delegateResult;\n }\n }\n\n if (context.method === \"next\") {\n // Setting context._sent for legacy support of Babel's\n // function.sent implementation.\n context.sent = context._sent = context.arg;\n\n } else if (context.method === \"throw\") {\n if (state === GenStateSuspendedStart) {\n state = GenStateCompleted;\n throw context.arg;\n }\n\n context.dispatchException(context.arg);\n\n } else if (context.method === \"return\") {\n context.abrupt(\"return\", context.arg);\n }\n\n state = GenStateExecuting;\n\n var record = tryCatch(innerFn, self, context);\n if (record.type === \"normal\") {\n // If an exception is thrown from innerFn, we leave state ===\n // GenStateExecuting and loop back for another invocation.\n state = context.done\n ? GenStateCompleted\n : GenStateSuspendedYield;\n\n if (record.arg === ContinueSentinel) {\n continue;\n }\n\n return {\n value: record.arg,\n done: context.done\n };\n\n } else if (record.type === \"throw\") {\n state = GenStateCompleted;\n // Dispatch the exception by looping back around to the\n // context.dispatchException(context.arg) call above.\n context.method = \"throw\";\n context.arg = record.arg;\n }\n }\n };\n }\n\n // Call delegate.iterator[context.method](context.arg) and handle the\n // result, either by returning a { value, done } result from the\n // delegate iterator, or by modifying context.method and context.arg,\n // setting context.delegate to null, and returning the ContinueSentinel.\n function maybeInvokeDelegate(delegate, context) {\n var method = delegate.iterator[context.method];\n if (method === undefined) {\n // A .throw or .return when the delegate iterator has no .throw\n // method always terminates the yield* loop.\n context.delegate = null;\n\n if (context.method === \"throw\") {\n // Note: [\"return\"] must be used for ES3 parsing compatibility.\n if (delegate.iterator[\"return\"]) {\n // If the delegate iterator has a return method, give it a\n // chance to clean up.\n context.method = \"return\";\n context.arg = undefined;\n maybeInvokeDelegate(delegate, context);\n\n if (context.method === \"throw\") {\n // If maybeInvokeDelegate(context) changed context.method from\n // \"return\" to \"throw\", let that override the TypeError below.\n return ContinueSentinel;\n }\n }\n\n context.method = \"throw\";\n context.arg = new TypeError(\n \"The iterator does not provide a 'throw' method\");\n }\n\n return ContinueSentinel;\n }\n\n var record = tryCatch(method, delegate.iterator, context.arg);\n\n if (record.type === \"throw\") {\n context.method = \"throw\";\n context.arg = record.arg;\n context.delegate = null;\n return ContinueSentinel;\n }\n\n var info = record.arg;\n\n if (! info) {\n context.method = \"throw\";\n context.arg = new TypeError(\"iterator result is not an object\");\n context.delegate = null;\n return ContinueSentinel;\n }\n\n if (info.done) {\n // Assign the result of the finished delegate to the temporary\n // variable specified by delegate.resultName (see delegateYield).\n context[delegate.resultName] = info.value;\n\n // Resume execution at the desired location (see delegateYield).\n context.next = delegate.nextLoc;\n\n // If context.method was \"throw\" but the delegate handled the\n // exception, let the outer generator proceed normally. If\n // context.method was \"next\", forget context.arg since it has been\n // \"consumed\" by the delegate iterator. If context.method was\n // \"return\", allow the original .return call to continue in the\n // outer generator.\n if (context.method !== \"return\") {\n context.method = \"next\";\n context.arg = undefined;\n }\n\n } else {\n // Re-yield the result returned by the delegate method.\n return info;\n }\n\n // The delegate iterator is finished, so forget it and continue with\n // the outer generator.\n context.delegate = null;\n return ContinueSentinel;\n }\n\n // Define Generator.prototype.{next,throw,return} in terms of the\n // unified ._invoke helper method.\n defineIteratorMethods(Gp);\n\n define(Gp, toStringTagSymbol, \"Generator\");\n\n // A Generator should always return itself as the iterator object when the\n // @@iterator function is called on it. Some browsers' implementations of the\n // iterator prototype chain incorrectly implement this, causing the Generator\n // object to not be returned from this call. This ensures that doesn't happen.\n // See https://github.com/facebook/regenerator/issues/274 for more details.\n Gp[iteratorSymbol] = function() {\n return this;\n };\n\n Gp.toString = function() {\n return \"[object Generator]\";\n };\n\n function pushTryEntry(locs) {\n var entry = { tryLoc: locs[0] };\n\n if (1 in locs) {\n entry.catchLoc = locs[1];\n }\n\n if (2 in locs) {\n entry.finallyLoc = locs[2];\n entry.afterLoc = locs[3];\n }\n\n this.tryEntries.push(entry);\n }\n\n function resetTryEntry(entry) {\n var record = entry.completion || {};\n record.type = \"normal\";\n delete record.arg;\n entry.completion = record;\n }\n\n function Context(tryLocsList) {\n // The root entry object (effectively a try statement without a catch\n // or a finally block) gives us a place to store values thrown from\n // locations where there is no enclosing try statement.\n this.tryEntries = [{ tryLoc: \"root\" }];\n tryLocsList.forEach(pushTryEntry, this);\n this.reset(true);\n }\n\n exports.keys = function(object) {\n var keys = [];\n for (var key in object) {\n keys.push(key);\n }\n keys.reverse();\n\n // Rather than returning an object with a next method, we keep\n // things simple and return the next function itself.\n return function next() {\n while (keys.length) {\n var key = keys.pop();\n if (key in object) {\n next.value = key;\n next.done = false;\n return next;\n }\n }\n\n // To avoid creating an additional object, we just hang the .value\n // and .done properties off the next function object itself. This\n // also ensures that the minifier will not anonymize the function.\n next.done = true;\n return next;\n };\n };\n\n function values(iterable) {\n if (iterable) {\n var iteratorMethod = iterable[iteratorSymbol];\n if (iteratorMethod) {\n return iteratorMethod.call(iterable);\n }\n\n if (typeof iterable.next === \"function\") {\n return iterable;\n }\n\n if (!isNaN(iterable.length)) {\n var i = -1, next = function next() {\n while (++i < iterable.length) {\n if (hasOwn.call(iterable, i)) {\n next.value = iterable[i];\n next.done = false;\n return next;\n }\n }\n\n next.value = undefined;\n next.done = true;\n\n return next;\n };\n\n return next.next = next;\n }\n }\n\n // Return an iterator with no values.\n return { next: doneResult };\n }\n exports.values = values;\n\n function doneResult() {\n return { value: undefined, done: true };\n }\n\n Context.prototype = {\n constructor: Context,\n\n reset: function(skipTempReset) {\n this.prev = 0;\n this.next = 0;\n // Resetting context._sent for legacy support of Babel's\n // function.sent implementation.\n this.sent = this._sent = undefined;\n this.done = false;\n this.delegate = null;\n\n this.method = \"next\";\n this.arg = undefined;\n\n this.tryEntries.forEach(resetTryEntry);\n\n if (!skipTempReset) {\n for (var name in this) {\n // Not sure about the optimal order of these conditions:\n if (name.charAt(0) === \"t\" &&\n hasOwn.call(this, name) &&\n !isNaN(+name.slice(1))) {\n this[name] = undefined;\n }\n }\n }\n },\n\n stop: function() {\n this.done = true;\n\n var rootEntry = this.tryEntries[0];\n var rootRecord = rootEntry.completion;\n if (rootRecord.type === \"throw\") {\n throw rootRecord.arg;\n }\n\n return this.rval;\n },\n\n dispatchException: function(exception) {\n if (this.done) {\n throw exception;\n }\n\n var context = this;\n function handle(loc, caught) {\n record.type = \"throw\";\n record.arg = exception;\n context.next = loc;\n\n if (caught) {\n // If the dispatched exception was caught by a catch block,\n // then let that catch block handle the exception normally.\n context.method = \"next\";\n context.arg = undefined;\n }\n\n return !! caught;\n }\n\n for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n var entry = this.tryEntries[i];\n var record = entry.completion;\n\n if (entry.tryLoc === \"root\") {\n // Exception thrown outside of any try block that could handle\n // it, so set the completion value of the entire function to\n // throw the exception.\n return handle(\"end\");\n }\n\n if (entry.tryLoc <= this.prev) {\n var hasCatch = hasOwn.call(entry, \"catchLoc\");\n var hasFinally = hasOwn.call(entry, \"finallyLoc\");\n\n if (hasCatch && hasFinally) {\n if (this.prev < entry.catchLoc) {\n return handle(entry.catchLoc, true);\n } else if (this.prev < entry.finallyLoc) {\n return handle(entry.finallyLoc);\n }\n\n } else if (hasCatch) {\n if (this.prev < entry.catchLoc) {\n return handle(entry.catchLoc, true);\n }\n\n } else if (hasFinally) {\n if (this.prev < entry.finallyLoc) {\n return handle(entry.finallyLoc);\n }\n\n } else {\n throw new Error(\"try statement without catch or finally\");\n }\n }\n }\n },\n\n abrupt: function(type, arg) {\n for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n var entry = this.tryEntries[i];\n if (entry.tryLoc <= this.prev &&\n hasOwn.call(entry, \"finallyLoc\") &&\n this.prev < entry.finallyLoc) {\n var finallyEntry = entry;\n break;\n }\n }\n\n if (finallyEntry &&\n (type === \"break\" ||\n type === \"continue\") &&\n finallyEntry.tryLoc <= arg &&\n arg <= finallyEntry.finallyLoc) {\n // Ignore the finally entry if control is not jumping to a\n // location outside the try/catch block.\n finallyEntry = null;\n }\n\n var record = finallyEntry ? finallyEntry.completion : {};\n record.type = type;\n record.arg = arg;\n\n if (finallyEntry) {\n this.method = \"next\";\n this.next = finallyEntry.finallyLoc;\n return ContinueSentinel;\n }\n\n return this.complete(record);\n },\n\n complete: function(record, afterLoc) {\n if (record.type === \"throw\") {\n throw record.arg;\n }\n\n if (record.type === \"break\" ||\n record.type === \"continue\") {\n this.next = record.arg;\n } else if (record.type === \"return\") {\n this.rval = this.arg = record.arg;\n this.method = \"return\";\n this.next = \"end\";\n } else if (record.type === \"normal\" && afterLoc) {\n this.next = afterLoc;\n }\n\n return ContinueSentinel;\n },\n\n finish: function(finallyLoc) {\n for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n var entry = this.tryEntries[i];\n if (entry.finallyLoc === finallyLoc) {\n this.complete(entry.completion, entry.afterLoc);\n resetTryEntry(entry);\n return ContinueSentinel;\n }\n }\n },\n\n \"catch\": function(tryLoc) {\n for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n var entry = this.tryEntries[i];\n if (entry.tryLoc === tryLoc) {\n var record = entry.completion;\n if (record.type === \"throw\") {\n var thrown = record.arg;\n resetTryEntry(entry);\n }\n return thrown;\n }\n }\n\n // The context.catch method must only be called with a location\n // argument that corresponds to a known catch block.\n throw new Error(\"illegal catch attempt\");\n },\n\n delegateYield: function(iterable, resultName, nextLoc) {\n this.delegate = {\n iterator: values(iterable),\n resultName: resultName,\n nextLoc: nextLoc\n };\n\n if (this.method === \"next\") {\n // Deliberately forget the last sent value so that we don't\n // accidentally pass it on to the delegate.\n this.arg = undefined;\n }\n\n return ContinueSentinel;\n }\n };\n\n // Regardless of whether this script is executing as a CommonJS module\n // or not, return the runtime object so that we can declare the variable\n // regeneratorRuntime in the outer scope, which allows this module to be\n // injected easily by `bin/regenerator --include-runtime script.js`.\n return exports;\n\n}(\n // If this script is executing as a CommonJS module, use module.exports\n // as the regeneratorRuntime namespace. Otherwise create a new empty\n // object. Either way, the resulting object will be used to initialize\n // the regeneratorRuntime variable at the top of this file.\n typeof module === \"object\" ? module.exports : {}\n));\n\ntry {\n regeneratorRuntime = runtime;\n} catch (accidentalStrictMode) {\n // This module should not be running in strict mode, so the above\n // assignment should always work unless something is misconfigured. Just\n // in case runtime.js accidentally runs in strict mode, we can escape\n // strict mode using a global Function call. This could conceivably fail\n // if a Content Security Policy forbids using Function, but in that case\n // the proper solution is to fix the accidental strict mode problem. If\n // you've misconfigured your bundler to force strict mode and applied a\n // CSP to forbid Function, and you're not willing to fix either of those\n // problems, please detail your unique predicament in a GitHub issue.\n Function(\"r\", \"regeneratorRuntime = r\")(runtime);\n}\n","export default function(e,n){return n=n||{},new Promise(function(t,r){var s=new XMLHttpRequest,o=[],u=[],i={},a=function(){return{ok:2==(s.status/100|0),statusText:s.statusText,status:s.status,url:s.responseURL,text:function(){return Promise.resolve(s.responseText)},json:function(){return Promise.resolve(s.responseText).then(JSON.parse)},blob:function(){return Promise.resolve(new Blob([s.response]))},clone:a,headers:{keys:function(){return o},entries:function(){return u},get:function(e){return i[e.toLowerCase()]},has:function(e){return e.toLowerCase()in i}}}};for(var l in s.open(n.method||\"get\",e,!0),s.onload=function(){s.getAllResponseHeaders().replace(/^(.*?):[^\\S\\n]*([\\s\\S]*?)$/gm,function(e,n,t){o.push(n=n.toLowerCase()),u.push([n,t]),i[n]=i[n]?i[n]+\",\"+t:t}),t(a())},s.onerror=r,s.withCredentials=\"include\"==n.credentials,n.headers)s.setRequestHeader(l,n.headers[l]);s.send(n.body||null)})}\n//# sourceMappingURL=unfetch.module.js.map\n","module.exports = require('./lib/Observable.js').Observable;\n","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\nexports.Observable = void 0;\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }\n\nfunction _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }\n\n// === Symbol Support ===\nvar hasSymbols = function () {\n return typeof Symbol === 'function';\n};\n\nvar hasSymbol = function (name) {\n return hasSymbols() && Boolean(Symbol[name]);\n};\n\nvar getSymbol = function (name) {\n return hasSymbol(name) ? Symbol[name] : '@@' + name;\n};\n\nif (hasSymbols() && !hasSymbol('observable')) {\n Symbol.observable = Symbol('observable');\n}\n\nvar SymbolIterator = getSymbol('iterator');\nvar SymbolObservable = getSymbol('observable');\nvar SymbolSpecies = getSymbol('species'); // === Abstract Operations ===\n\nfunction getMethod(obj, key) {\n var value = obj[key];\n if (value == null) return undefined;\n if (typeof value !== 'function') throw new TypeError(value + ' is not a function');\n return value;\n}\n\nfunction getSpecies(obj) {\n var ctor = obj.constructor;\n\n if (ctor !== undefined) {\n ctor = ctor[SymbolSpecies];\n\n if (ctor === null) {\n ctor = undefined;\n }\n }\n\n return ctor !== undefined ? ctor : Observable;\n}\n\nfunction isObservable(x) {\n return x instanceof Observable; // SPEC: Brand check\n}\n\nfunction hostReportError(e) {\n if (hostReportError.log) {\n hostReportError.log(e);\n } else {\n setTimeout(function () {\n throw e;\n });\n }\n}\n\nfunction enqueue(fn) {\n Promise.resolve().then(function () {\n try {\n fn();\n } catch (e) {\n hostReportError(e);\n }\n });\n}\n\nfunction cleanupSubscription(subscription) {\n var cleanup = subscription._cleanup;\n if (cleanup === undefined) return;\n subscription._cleanup = undefined;\n\n if (!cleanup) {\n return;\n }\n\n try {\n if (typeof cleanup === 'function') {\n cleanup();\n } else {\n var unsubscribe = getMethod(cleanup, 'unsubscribe');\n\n if (unsubscribe) {\n unsubscribe.call(cleanup);\n }\n }\n } catch (e) {\n hostReportError(e);\n }\n}\n\nfunction closeSubscription(subscription) {\n subscription._observer = undefined;\n subscription._queue = undefined;\n subscription._state = 'closed';\n}\n\nfunction flushSubscription(subscription) {\n var queue = subscription._queue;\n\n if (!queue) {\n return;\n }\n\n subscription._queue = undefined;\n subscription._state = 'ready';\n\n for (var i = 0; i < queue.length; ++i) {\n notifySubscription(subscription, queue[i].type, queue[i].value);\n if (subscription._state === 'closed') break;\n }\n}\n\nfunction notifySubscription(subscription, type, value) {\n subscription._state = 'running';\n var observer = subscription._observer;\n\n try {\n var m = getMethod(observer, type);\n\n switch (type) {\n case 'next':\n if (m) m.call(observer, value);\n break;\n\n case 'error':\n closeSubscription(subscription);\n if (m) m.call(observer, value);else throw value;\n break;\n\n case 'complete':\n closeSubscription(subscription);\n if (m) m.call(observer);\n break;\n }\n } catch (e) {\n hostReportError(e);\n }\n\n if (subscription._state === 'closed') cleanupSubscription(subscription);else if (subscription._state === 'running') subscription._state = 'ready';\n}\n\nfunction onNotify(subscription, type, value) {\n if (subscription._state === 'closed') return;\n\n if (subscription._state === 'buffering') {\n subscription._queue.push({\n type: type,\n value: value\n });\n\n return;\n }\n\n if (subscription._state !== 'ready') {\n subscription._state = 'buffering';\n subscription._queue = [{\n type: type,\n value: value\n }];\n enqueue(function () {\n return flushSubscription(subscription);\n });\n return;\n }\n\n notifySubscription(subscription, type, value);\n}\n\nvar Subscription =\n/*#__PURE__*/\nfunction () {\n function Subscription(observer, subscriber) {\n _classCallCheck(this, Subscription);\n\n // ASSERT: observer is an object\n // ASSERT: subscriber is callable\n this._cleanup = undefined;\n this._observer = observer;\n this._queue = undefined;\n this._state = 'initializing';\n var subscriptionObserver = new SubscriptionObserver(this);\n\n try {\n this._cleanup = subscriber.call(undefined, subscriptionObserver);\n } catch (e) {\n subscriptionObserver.error(e);\n }\n\n if (this._state === 'initializing') this._state = 'ready';\n }\n\n _createClass(Subscription, [{\n key: \"unsubscribe\",\n value: function unsubscribe() {\n if (this._state !== 'closed') {\n closeSubscription(this);\n cleanupSubscription(this);\n }\n }\n }, {\n key: \"closed\",\n get: function () {\n return this._state === 'closed';\n }\n }]);\n\n return Subscription;\n}();\n\nvar SubscriptionObserver =\n/*#__PURE__*/\nfunction () {\n function SubscriptionObserver(subscription) {\n _classCallCheck(this, SubscriptionObserver);\n\n this._subscription = subscription;\n }\n\n _createClass(SubscriptionObserver, [{\n key: \"next\",\n value: function next(value) {\n onNotify(this._subscription, 'next', value);\n }\n }, {\n key: \"error\",\n value: function error(value) {\n onNotify(this._subscription, 'error', value);\n }\n }, {\n key: \"complete\",\n value: function complete() {\n onNotify(this._subscription, 'complete');\n }\n }, {\n key: \"closed\",\n get: function () {\n return this._subscription._state === 'closed';\n }\n }]);\n\n return SubscriptionObserver;\n}();\n\nvar Observable =\n/*#__PURE__*/\nfunction () {\n function Observable(subscriber) {\n _classCallCheck(this, Observable);\n\n if (!(this instanceof Observable)) throw new TypeError('Observable cannot be called as a function');\n if (typeof subscriber !== 'function') throw new TypeError('Observable initializer must be a function');\n this._subscriber = subscriber;\n }\n\n _createClass(Observable, [{\n key: \"subscribe\",\n value: function subscribe(observer) {\n if (typeof observer !== 'object' || observer === null) {\n observer = {\n next: observer,\n error: arguments[1],\n complete: arguments[2]\n };\n }\n\n return new Subscription(observer, this._subscriber);\n }\n }, {\n key: \"forEach\",\n value: function forEach(fn) {\n var _this = this;\n\n return new Promise(function (resolve, reject) {\n if (typeof fn !== 'function') {\n reject(new TypeError(fn + ' is not a function'));\n return;\n }\n\n function done() {\n subscription.unsubscribe();\n resolve();\n }\n\n var subscription = _this.subscribe({\n next: function (value) {\n try {\n fn(value, done);\n } catch (e) {\n reject(e);\n subscription.unsubscribe();\n }\n },\n error: reject,\n complete: resolve\n });\n });\n }\n }, {\n key: \"map\",\n value: function map(fn) {\n var _this2 = this;\n\n if (typeof fn !== 'function') throw new TypeError(fn + ' is not a function');\n var C = getSpecies(this);\n return new C(function (observer) {\n return _this2.subscribe({\n next: function (value) {\n try {\n value = fn(value);\n } catch (e) {\n return observer.error(e);\n }\n\n observer.next(value);\n },\n error: function (e) {\n observer.error(e);\n },\n complete: function () {\n observer.complete();\n }\n });\n });\n }\n }, {\n key: \"filter\",\n value: function filter(fn) {\n var _this3 = this;\n\n if (typeof fn !== 'function') throw new TypeError(fn + ' is not a function');\n var C = getSpecies(this);\n return new C(function (observer) {\n return _this3.subscribe({\n next: function (value) {\n try {\n if (!fn(value)) return;\n } catch (e) {\n return observer.error(e);\n }\n\n observer.next(value);\n },\n error: function (e) {\n observer.error(e);\n },\n complete: function () {\n observer.complete();\n }\n });\n });\n }\n }, {\n key: \"reduce\",\n value: function reduce(fn) {\n var _this4 = this;\n\n if (typeof fn !== 'function') throw new TypeError(fn + ' is not a function');\n var C = getSpecies(this);\n var hasSeed = arguments.length > 1;\n var hasValue = false;\n var seed = arguments[1];\n var acc = seed;\n return new C(function (observer) {\n return _this4.subscribe({\n next: function (value) {\n var first = !hasValue;\n hasValue = true;\n\n if (!first || hasSeed) {\n try {\n acc = fn(acc, value);\n } catch (e) {\n return observer.error(e);\n }\n } else {\n acc = value;\n }\n },\n error: function (e) {\n observer.error(e);\n },\n complete: function () {\n if (!hasValue && !hasSeed) return observer.error(new TypeError('Cannot reduce an empty sequence'));\n observer.next(acc);\n observer.complete();\n }\n });\n });\n }\n }, {\n key: \"concat\",\n value: function concat() {\n var _this5 = this;\n\n for (var _len = arguments.length, sources = new Array(_len), _key = 0; _key < _len; _key++) {\n sources[_key] = arguments[_key];\n }\n\n var C = getSpecies(this);\n return new C(function (observer) {\n var subscription;\n var index = 0;\n\n function startNext(next) {\n subscription = next.subscribe({\n next: function (v) {\n observer.next(v);\n },\n error: function (e) {\n observer.error(e);\n },\n complete: function () {\n if (index === sources.length) {\n subscription = undefined;\n observer.complete();\n } else {\n startNext(C.from(sources[index++]));\n }\n }\n });\n }\n\n startNext(_this5);\n return function () {\n if (subscription) {\n subscription.unsubscribe();\n subscription = undefined;\n }\n };\n });\n }\n }, {\n key: \"flatMap\",\n value: function flatMap(fn) {\n var _this6 = this;\n\n if (typeof fn !== 'function') throw new TypeError(fn + ' is not a function');\n var C = getSpecies(this);\n return new C(function (observer) {\n var subscriptions = [];\n\n var outer = _this6.subscribe({\n next: function (value) {\n if (fn) {\n try {\n value = fn(value);\n } catch (e) {\n return observer.error(e);\n }\n }\n\n var inner = C.from(value).subscribe({\n next: function (value) {\n observer.next(value);\n },\n error: function (e) {\n observer.error(e);\n },\n complete: function () {\n var i = subscriptions.indexOf(inner);\n if (i >= 0) subscriptions.splice(i, 1);\n completeIfDone();\n }\n });\n subscriptions.push(inner);\n },\n error: function (e) {\n observer.error(e);\n },\n complete: function () {\n completeIfDone();\n }\n });\n\n function completeIfDone() {\n if (outer.closed && subscriptions.length === 0) observer.complete();\n }\n\n return function () {\n subscriptions.forEach(function (s) {\n return s.unsubscribe();\n });\n outer.unsubscribe();\n };\n });\n }\n }, {\n key: SymbolObservable,\n value: function () {\n return this;\n }\n }], [{\n key: \"from\",\n value: function from(x) {\n var C = typeof this === 'function' ? this : Observable;\n if (x == null) throw new TypeError(x + ' is not an object');\n var method = getMethod(x, SymbolObservable);\n\n if (method) {\n var observable = method.call(x);\n if (Object(observable) !== observable) throw new TypeError(observable + ' is not an object');\n if (isObservable(observable) && observable.constructor === C) return observable;\n return new C(function (observer) {\n return observable.subscribe(observer);\n });\n }\n\n if (hasSymbol('iterator')) {\n method = getMethod(x, SymbolIterator);\n\n if (method) {\n return new C(function (observer) {\n enqueue(function () {\n if (observer.closed) return;\n var _iteratorNormalCompletion = true;\n var _didIteratorError = false;\n var _iteratorError = undefined;\n\n try {\n for (var _iterator = method.call(x)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {\n var _item = _step.value;\n observer.next(_item);\n if (observer.closed) return;\n }\n } catch (err) {\n _didIteratorError = true;\n _iteratorError = err;\n } finally {\n try {\n if (!_iteratorNormalCompletion && _iterator.return != null) {\n _iterator.return();\n }\n } finally {\n if (_didIteratorError) {\n throw _iteratorError;\n }\n }\n }\n\n observer.complete();\n });\n });\n }\n }\n\n if (Array.isArray(x)) {\n return new C(function (observer) {\n enqueue(function () {\n if (observer.closed) return;\n\n for (var i = 0; i < x.length; ++i) {\n observer.next(x[i]);\n if (observer.closed) return;\n }\n\n observer.complete();\n });\n });\n }\n\n throw new TypeError(x + ' is not observable');\n }\n }, {\n key: \"of\",\n value: function of() {\n for (var _len2 = arguments.length, items = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {\n items[_key2] = arguments[_key2];\n }\n\n var C = typeof this === 'function' ? this : Observable;\n return new C(function (observer) {\n enqueue(function () {\n if (observer.closed) return;\n\n for (var i = 0; i < items.length; ++i) {\n observer.next(items[i]);\n if (observer.closed) return;\n }\n\n observer.complete();\n });\n });\n }\n }, {\n key: SymbolSpecies,\n get: function () {\n return this;\n }\n }]);\n\n return Observable;\n}();\n\nexports.Observable = Observable;\n\nif (hasSymbols()) {\n Object.defineProperty(Observable, Symbol('extensions'), {\n value: {\n symbol: SymbolObservable,\n hostReportError: hostReportError\n },\n configurable: true\n });\n}"],"sourceRoot":""}