{"version":3,"sources":["webpack:///./node_modules/markdown-it/lib/common/utils.js","webpack:///./node_modules/graphql-language-service-parser/dist/index.js","webpack:///./node_modules/graphiql/dist/components/DocExplorer/TypeLink.js","webpack:///./node_modules/graphql-language-service-interface/node_modules/graphql-language-service-utils/dist/index.js","webpack:///./node_modules/markdown-it/index.js","webpack:///./node_modules/uc.micro/categories/P/regex.js","webpack:///./node_modules/markdown-it/lib/ruler.js","webpack:///./node_modules/markdown-it/lib/token.js","webpack:///./node_modules/graphiql/dist/utility/commonKeys.js","webpack:///./node_modules/graphql-language-service-interface/dist/getAutocompleteSuggestions.js","webpack:///./node_modules/graphiql/dist/components/DocExplorer/Argument.js","webpack:///./node_modules/graphiql/dist/components/DocExplorer/MarkdownContent.js","webpack:///./node_modules/markdown-it/lib/common/entities.js","webpack:///./node_modules/mdurl/index.js","webpack:///./node_modules/uc.micro/properties/Any/regex.js","webpack:///./node_modules/uc.micro/categories/Cc/regex.js","webpack:///./node_modules/uc.micro/categories/Z/regex.js","webpack:///./node_modules/markdown-it/lib/common/html_re.js","webpack:///./node_modules/markdown-it/lib/rules_inline/strikethrough.js","webpack:///./node_modules/markdown-it/lib/rules_inline/emphasis.js","webpack:///./node_modules/graphiql/dist/utility/onHasCompletion.js","webpack:///./node_modules/graphql-language-service-interface/dist/index.js","webpack:///./node_modules/graphql-language-service-interface/dist/autocompleteUtils.js","webpack:///./node_modules/vscode-languageserver-types/lib/umd/main.js","webpack:///./node_modules/graphql-language-service-parser/dist/Rules.js","webpack:///./node_modules/graphql-language-service-parser/dist/RuleHelpers.js","webpack:///./node_modules/graphql-language-service-interface/dist/getDefinition.js","webpack:///./node_modules/graphql-language-service-interface/dist/getDiagnostics.js","webpack:///./node_modules/graphql-language-service-interface/dist/getOutline.js","webpack:///./node_modules/graphql-language-service-interface/dist/getHoverInformation.js","webpack:///./node_modules/codemirror-graphql/utils/getTypeInfo.js","webpack:///./node_modules/codemirror-graphql/utils/forEachState.js","webpack:///./node_modules/codemirror-graphql/utils/SchemaReference.js","webpack:///./node_modules/codemirror-graphql/utils/info-addon.js","webpack:///./node_modules/graphiql/dist/components/DocExplorer/DefaultValue.js","webpack:///./node_modules/graphiql/dist/utility/debounce.js","webpack:///./node_modules/graphiql/dist/index.js","webpack:///./node_modules/graphiql/node_modules/regenerator-runtime/runtime.js","webpack:///./node_modules/graphiql/dist/components/GraphiQL.js","webpack:///./node_modules/copy-to-clipboard/index.js","webpack:///./node_modules/toggle-selection/index.js","webpack:///./node_modules/graphiql/dist/components/ExecuteButton.js","webpack:///./node_modules/graphiql/dist/components/ImagePreview.js","webpack:///./node_modules/graphiql/dist/components/ToolbarButton.js","webpack:///./node_modules/graphiql/dist/components/ToolbarGroup.js","webpack:///./node_modules/graphiql/dist/components/ToolbarMenu.js","webpack:///./node_modules/graphiql/dist/components/ToolbarSelect.js","webpack:///./node_modules/graphiql/dist/components/QueryEditor.js","webpack:///./node_modules/markdown-it/lib/index.js","webpack:///./node_modules/mdurl/encode.js","webpack:///./node_modules/mdurl/decode.js","webpack:///./node_modules/mdurl/format.js","webpack:///./node_modules/mdurl/parse.js","webpack:///./node_modules/uc.micro/index.js","webpack:///./node_modules/uc.micro/categories/Cf/regex.js","webpack:///./node_modules/markdown-it/lib/helpers/index.js","webpack:///./node_modules/markdown-it/lib/helpers/parse_link_label.js","webpack:///./node_modules/markdown-it/lib/helpers/parse_link_destination.js","webpack:///./node_modules/markdown-it/lib/helpers/parse_link_title.js","webpack:///./node_modules/markdown-it/lib/renderer.js","webpack:///./node_modules/markdown-it/lib/parser_core.js","webpack:///./node_modules/markdown-it/lib/rules_core/normalize.js","webpack:///./node_modules/markdown-it/lib/rules_core/block.js","webpack:///./node_modules/markdown-it/lib/rules_core/inline.js","webpack:///./node_modules/markdown-it/lib/rules_core/linkify.js","webpack:///./node_modules/markdown-it/lib/rules_core/replacements.js","webpack:///./node_modules/markdown-it/lib/rules_core/smartquotes.js","webpack:///./node_modules/markdown-it/lib/rules_core/state_core.js","webpack:///./node_modules/markdown-it/lib/parser_block.js","webpack:///./node_modules/markdown-it/lib/rules_block/table.js","webpack:///./node_modules/markdown-it/lib/rules_block/code.js","webpack:///./node_modules/markdown-it/lib/rules_block/fence.js","webpack:///./node_modules/markdown-it/lib/rules_block/blockquote.js","webpack:///./node_modules/markdown-it/lib/rules_block/hr.js","webpack:///./node_modules/markdown-it/lib/rules_block/list.js","webpack:///./node_modules/markdown-it/lib/rules_block/reference.js","webpack:///./node_modules/markdown-it/lib/rules_block/heading.js","webpack:///./node_modules/markdown-it/lib/rules_block/lheading.js","webpack:///./node_modules/markdown-it/lib/rules_block/html_block.js","webpack:///./node_modules/markdown-it/lib/common/html_blocks.js","webpack:///./node_modules/markdown-it/lib/rules_block/paragraph.js","webpack:///./node_modules/markdown-it/lib/rules_block/state_block.js","webpack:///./node_modules/markdown-it/lib/parser_inline.js","webpack:///./node_modules/markdown-it/lib/rules_inline/text.js","webpack:///./node_modules/markdown-it/lib/rules_inline/newline.js","webpack:///./node_modules/markdown-it/lib/rules_inline/escape.js","webpack:///./node_modules/markdown-it/lib/rules_inline/backticks.js","webpack:///./node_modules/markdown-it/lib/rules_inline/link.js","webpack:///./node_modules/markdown-it/lib/rules_inline/image.js","webpack:///./node_modules/markdown-it/lib/rules_inline/autolink.js","webpack:///./node_modules/markdown-it/lib/rules_inline/html_inline.js","webpack:///./node_modules/markdown-it/lib/rules_inline/entity.js","webpack:///./node_modules/markdown-it/lib/rules_inline/balance_pairs.js","webpack:///./node_modules/markdown-it/lib/rules_inline/text_collapse.js","webpack:///./node_modules/markdown-it/lib/rules_inline/state_inline.js","webpack:///./node_modules/linkify-it/index.js","webpack:///./node_modules/linkify-it/lib/re.js","webpack:///./node_modules/node-libs-browser/node_modules/punycode/punycode.js","webpack:///./node_modules/markdown-it/lib/presets/default.js","webpack:///./node_modules/markdown-it/lib/presets/zero.js","webpack:///./node_modules/markdown-it/lib/presets/commonmark.js","webpack:///./node_modules/graphiql/dist/utility/normalizeWhitespace.js","webpack:///./node_modules/codemirror-graphql/hint.js","webpack:///./node_modules/graphql-language-service-parser/dist/CharacterStream.js","webpack:///./node_modules/graphql-language-service-parser/dist/onlineParser.js","webpack:///./node_modules/graphql-language-service-parser/dist/types.js","webpack:///./node_modules/graphql-language-service-interface/node_modules/graphql-language-service-utils/dist/getASTNodeAtPosition.js","webpack:///./node_modules/graphql-language-service-interface/node_modules/graphql-language-service-utils/dist/Range.js","webpack:///./node_modules/graphql-language-service-interface/node_modules/graphql-language-service-utils/dist/validateWithCustomRules.js","webpack:///./node_modules/graphql-language-service-interface/dist/GraphQLLanguageService.js","webpack:///./node_modules/codemirror-graphql/lint.js","webpack:///./node_modules/codemirror-graphql/info.js","webpack:///./node_modules/codemirror-graphql/jump.js","webpack:///./node_modules/codemirror-graphql/utils/jump-addon.js","webpack:///./node_modules/codemirror-graphql/mode.js","webpack:///./node_modules/graphiql/dist/components/VariableEditor.js","webpack:///./node_modules/codemirror-graphql/variables/hint.js","webpack:///./node_modules/codemirror-graphql/utils/hintList.js","webpack:///./node_modules/codemirror-graphql/variables/lint.js","webpack:///./node_modules/codemirror-graphql/utils/jsonParse.js","webpack:///./node_modules/codemirror-graphql/variables/mode.js","webpack:///./node_modules/graphiql/dist/components/ResultViewer.js","webpack:///./node_modules/codemirror-graphql/results/mode.js","webpack:///./node_modules/graphiql/dist/components/DocExplorer.js","webpack:///./node_modules/graphiql/dist/components/DocExplorer/FieldDoc.js","webpack:///./node_modules/graphiql/dist/components/DocExplorer/SchemaDoc.js","webpack:///./node_modules/graphiql/dist/components/DocExplorer/SearchBox.js","webpack:///./node_modules/graphiql/dist/components/DocExplorer/SearchResults.js","webpack:///./node_modules/graphiql/dist/components/DocExplorer/TypeDoc.js","webpack:///./node_modules/graphiql/dist/components/QueryHistory.js","webpack:///./node_modules/graphiql/dist/utility/QueryStore.js","webpack:///./node_modules/graphiql/dist/components/HistoryQuery.js","webpack:///./node_modules/graphiql/dist/utility/CodeMirrorSizer.js","webpack:///./node_modules/graphiql/dist/utility/StorageAPI.js","webpack:///./node_modules/graphiql/dist/utility/getQueryFacts.js","webpack:///./node_modules/graphiql/dist/utility/getSelectedOperationName.js","webpack:///./node_modules/graphiql/dist/utility/find.js","webpack:///./node_modules/graphiql/dist/utility/fillLeafs.js","webpack:///./node_modules/graphiql/dist/utility/elementPosition.js","webpack:///./node_modules/graphiql/dist/utility/mergeAst.js","webpack:///./node_modules/graphiql/dist/utility/introspectionQueries.js"],"names":["_hasOwnProperty","Object","prototype","hasOwnProperty","has","object","key","call","isValidEntityCode","c","fromCodePoint","surrogate1","surrogate2","String","fromCharCode","UNESCAPE_MD_RE","UNESCAPE_ALL_RE","RegExp","source","DIGITAL_ENTITY_TEST_RE","entities","HTML_ESCAPE_TEST_RE","HTML_ESCAPE_REPLACE_RE","HTML_REPLACEMENTS","replaceUnsafeChar","ch","REGEXP_ESCAPE_RE","UNICODE_PUNCT_RE","exports","lib","mdurl","ucmicro","assign","obj","Array","slice","arguments","forEach","TypeError","keys","isString","toString","_class","unescapeMd","str","indexOf","replace","unescapeAll","match","escaped","entity","name","code","charCodeAt","test","toLowerCase","parseInt","replaceEntityPattern","escapeHtml","arrayReplaceAt","src","pos","newElements","concat","isSpace","isWhiteSpace","isMdAsciiPunct","isPunctChar","escapeRE","normalizeReference","trim","toUpperCase","defineProperty","value","CharacterStream_1","CharacterStream","default","Rules_1","LexRules","ParseRules","isIgnored","RuleHelpers_1","butNot","list","opt","p","t","onlineParser_1","onlineParser","m","__export","_react","_interopRequireDefault","_propTypes","_graphql","__esModule","TypeLink","Component","nextProps","this","props","type","renderType","onClick","GraphQLNonNull","createElement","ofType","GraphQLList","className","event","preventDefault","href","func","enumerable","configurable","writable","getASTNodeAtPosition_1","getASTNodeAtPosition","pointToOffset","Range_1","Position","Range","locToRange","offsetToPosition","validateWithCustomRules_1","validateWithCustomRules","module","Ruler","__rules__","__cache__","__find__","i","length","__compile__","self","chains","rule","enabled","alt","altName","push","chain","fn","at","options","index","Error","before","beforeName","ruleName","splice","after","afterName","enable","ignoreInvalid","isArray","result","idx","enableOnly","disable","getRules","chainName","Token","tag","nesting","attrs","map","level","children","content","markup","info","meta","block","hidden","attrIndex","len","attrPush","attrData","attrSet","attrGet","attrJoin","isMacOs","window","navigator","platform","_default","__assign","s","n","apply","vscode_languageserver_types_1","graphql_1","graphql_language_service_parser_1","autocompleteUtils_1","getFragmentDefinitions","queryText","fragmentDefs","runOnlineParser","_","state","kind","RuleKinds","FRAGMENT_DEFINITION","selectionSet","SELECTION_SET","selections","typeCondition","NAMED_TYPE","getTokenAtPosition","cursor","styleAtCursor","stateAtCursor","stringAtCursor","token","stream","style","line","getCurrentPosition","character","current","start","end","string","callback","lines","split","parser","startState","eol","getStartOfToken","canUseDirective","directive","locations","QUERY","MUTATION","SUBSCRIPTION","FIELD","ALIASED_FIELD","FRAGMENT_SPREAD","INLINE_FRAGMENT","SCHEMA_DEF","SCALAR_DEF","OBJECT_TYPE_DEF","FIELD_DEF","INTERFACE_DEF","UNION_DEF","ENUM_DEF","ENUM_VALUE","INPUT_DEF","INPUT_VALUE_DEF","prevState","ARGUMENTS_DEF","getTypeInfo","schema","tokenState","argDef","argDefs","directiveDef","enumValue","fieldDef","inputType","objectFieldDefs","parentType","forEachState","getQueryType","getMutationType","getSubscriptionType","getType","getFieldDef","getNamedType","DIRECTIVE","getDirective","ARGUMENTS","args","name_1","field","ARGUMENT","enumType","GraphQLEnumType","array","predicate","find","getValues","val","LIST_VALUE","nullableType","getNullableType","OBJECT_VALUE","objectType","GraphQLInputObjectType","getFields","OBJECT_FIELD","objectField","getAutocompleteSuggestions","contextToken","step","typeInfo","DOCUMENT","hintList","label","CompletionItemKind","Function","Constructor","_kind","fields","objectValues","isCompositeType","TypeNameMetaFieldDef","SchemaMetaFieldDef","TypeMetaFieldDef","_a","sortText","detail","documentation","description","undefined","deprecated","isDeprecated","deprecationReason","Field","getSuggestionsForFieldNames","Variable","objectFields","completionKind_1","Value","namedInputType","values","EnumMember","GraphQLBoolean","getSuggestionsForInputValues","TYPE_CONDITION","possibleTypes","isAbstractType","abstractType","assertAbstractType","possibleObjTypes","getPossibleTypes","possibleIfaceMap_1","create","getInterfaces","iface","typeMap","getTypeMap","filter","namedType","getSuggestionsForFragmentTypeConditions","defState","getDefinitionState","relevantFrags","frag","doTypesOverlap","getSuggestionsForFragmentSpread","VARIABLE_DEFINITION","LIST_TYPE","inputTypeMap","inputTypes","isInputType","getSuggestionsForVariableDefinition","directives","getDirectives","getSuggestionsForDirective","Argument","_TypeLink","_DefaultValue","arg","onClickType","showDefaultValue","propTypes","isRequired","bool","md","MarkdownContent","markdown","dangerouslySetInnerHTML","__html","render","encode","decode","format","parse","open_tag","close_tag","HTML_TAG_RE","HTML_OPEN_CLOSE_TAG_RE","postProcess","delimiters","j","startDelim","endDelim","loneMarkers","max","marker","tokens","pop","tokenize","silent","scanned","scanDelims","jump","open","can_open","close","can_close","curr","tokens_meta","isStrong","cm","data","onHintInformationRender","information","deprecation","on","ctx","el","hintsUl","parentNode","onRemoveFn","document","appendChild","addEventListener","target","removeEventListener","innerHTML","reason","display","getOutline_1","getOutline","getHoverInformation_1","getHoverInformation","introspection_1","stack","reverseStateStack","filterNonEmpty","filtered","normalizeText","text","getProximity","suggestion","proximity","a","b","d","aLength","bLength","cost","Math","min","lexicalDistance","definitionState","fieldName","entry","pair","sort","filterAndSortList","v","factory","require","Location","Color","DiagnosticRelatedInformation","Diagnostic","Command","TextEdit","TextDocumentEdit","CreateFile","RenameFile","DeleteFile","WorkspaceEdit","is","candidate","Is","objectLiteral","number","one","two","three","four","uri","range","defined","LocationLink","targetUri","targetRange","targetSelectionRange","originSelectionRange","red","green","blue","alpha","ColorInformation","color","ColorPresentation","textEdit","additionalTextEdits","typedArray","FoldingRangeKind","FoldingRange","startLine","endLine","startCharacter","endCharacter","location","message","DiagnosticSeverity","Warning","Information","Hint","DiagnosticTag","Unnecessary","Deprecated","severity","relatedInformation","title","command","_i","newText","insert","position","del","textDocument","edits","VersionedTextDocumentIdentifier","overwrite","ignoreIfExists","boolean","oldUri","newUri","recursive","ignoreIfNotExists","changes","documentChanges","every","change","MarkupKind","MarkupContent","MarkedString","TextEditChangeImpl","delete","add","edit","all","clear","WorkspaceChange","workspaceEdit","_this","_textEditChanges","_workspaceEdit","textEditChange","get","getTextEditChange","textDocumentEdit","createFile","checkDocumentChanges","renameFile","deleteFile","TextDocumentIdentifier","version","TextDocumentItem","languageId","PlainText","Markdown","Text","Method","Class","Interface","Module","Property","Unit","Enum","Keyword","Snippet","File","Reference","Folder","Constant","Struct","Event","Operator","TypeParameter","InsertTextFormat","CompletionItemTag","CompletionItem","CompletionList","items","isIncomplete","fromPlainText","plainText","language","Hover","contents","ParameterInformation","SignatureInformation","parameters","DocumentHighlightKind","Read","Write","DocumentHighlight","SymbolKind","Namespace","Package","Number","Boolean","Key","Null","SymbolTag","SymbolInformation","containerName","DocumentSymbol","selectionRange","CodeActionKind","Empty","QuickFix","Refactor","RefactorExtract","RefactorInline","RefactorRewrite","Source","SourceOrganizeImports","SourceFixAll","CodeActionContext","diagnostics","only","CodeAction","commandOrEdit","isPreferred","CodeLens","FormattingOptions","tabSize","insertSpaces","DocumentLink","SelectionRange","parent","EOL","TextDocument","FullTextDocument","lineCount","getText","positionAt","offsetAt","applyEdits","sortedEdits","mergeSort","compare","left","right","leftIdx","rightIdx","ret","diff","lastModifiedOffset","e","startOffset","endOffset","substring","_uri","_languageId","_version","_content","_lineOffsets","update","getLineOffsets","lineOffsets","isLineStart","charAt","offset","low","high","mid","floor","lineOffset","nextLineOffset","check","word","Name","Punctuation","Comment","Document","Definition","ShortQuery","Query","Mutation","Subscription","VariableDefinitions","VariableDefinition","DefaultValue","SelectionSet","Selection","AliasedField","Arguments","FragmentSpread","InlineFragment","FragmentDefinition","TypeCondition","NumberValue","StringValue","BooleanValue","NullValue","EnumValue","ListValue","ObjectValue","ObjectField","Type","ListType","NonNullType","NamedType","Directive","SchemaDef","OperationTypeDef","ScalarDef","ObjectTypeDef","Implements","FieldDef","ArgumentsDef","InputValueDef","InterfaceDef","UnionDef","UnionMember","EnumDef","EnumValueDef","InputDef","ExtendDef","DirectiveDef","DirectiveLocation","ofRule","separator","isList","exclusions","ruleMatch","exclusion","__awaiter","thisArg","_arguments","P","generator","Promise","resolve","reject","fulfilled","next","rejected","done","then","__generator","body","f","y","g","sent","trys","ops","verb","Symbol","iterator","op","__importDefault","mod","graphql_language_service_utils_1","assert_1","getRange","node","loc","getPosition","getDefinitionForFragmentDefinition","path","definition","LANGUAGE","projectRoot","getDefinitionQueryResultForNamedType","dependencies","defNodes","definitions","getDefinitionForNodeDefinition","filePath","queryRange","getDefinitionQueryResultForFragmentSpread","fragment","getDefinitionQueryResultForDefinitionNode","validateQuery","ast","customRules","isRelayCompatMode","validationErrorAnnotations","mapCat","error","annotations","DIAGNOSTIC_SEVERITY","deprecationWarningAnnotations","findDeprecatedUsages","mapper","nodes","highlightedNodes","highlightNode","variable","highlightLoc","getLocation","column","SEVERITY","getDiagnostics","query","Kind","buildToken","documentText","docText","visitorFns","representativeName","startPosition","endPosition","tokenizedText","alias","OperationDefinition","operation","arr","res","x","concatMap","child","InterfaceTypeDefinition","EnumTypeDefinition","EnumValueDefinition","ObjectTypeDefinition","InputObjectTypeDefinition","InputValueDefinition","FieldDefinition","outlineTrees","visit","leave","getAutocompleteSuggestions_1","renderQualifiedField","into","renderDirective","_options","renderTypeAnnotation","renderDescription","def","renderDeprecation","renderField","join","renderArg","renderEnumValue","_forEachState","parentDef","_introspection","getFieldReference","isMetaField","getDirectiveReference","getArgumentReference","argument","getEnumValueReference","getTypeReference","_codemirror","onMouseOver","srcElement","nodeName","hoverTimeout","box","getBoundingClientRect","onMouseMove","clearTimeout","setTimeout","onHover","hoverTime","onMouseOut","off","getWrapperElement","coordsChar","top","bottom","getHelper","getTokenAt","popup","popupBox","popupStyle","currentStyle","getComputedStyle","popupWidth","parseFloat","marginLeft","marginRight","popupHeight","marginTop","marginBottom","topPos","innerHeight","popupTimeout","leftPos","innerWidth","opacity","onMouseOverPopup","hidePopup","removeChild","showPopup","onMouseHover","getHoverTime","defineOption","old","Init","oldOnMouseOver","createState","bind","defaultValue","print","astFromValue","duration","timeout","GraphiQL","runtime","Op","hasOwn","$Symbol","iteratorSymbol","asyncIteratorSymbol","asyncIterator","toStringTagSymbol","toStringTag","wrap","innerFn","outerFn","tryLocsList","protoGenerator","Generator","context","Context","_invoke","GenStateSuspendedStart","method","GenStateExecuting","GenStateCompleted","doneResult","delegate","delegateResult","maybeInvokeDelegate","ContinueSentinel","_sent","dispatchException","abrupt","record","tryCatch","GenStateSuspendedYield","makeInvokeMethod","err","GeneratorFunction","GeneratorFunctionPrototype","IteratorPrototype","getProto","getPrototypeOf","NativeIteratorPrototype","Gp","defineIteratorMethods","AsyncIterator","previousPromise","callInvokeWithMethodAndArg","invoke","__await","unwrapped","resultName","nextLoc","pushTryEntry","locs","tryLoc","catchLoc","finallyLoc","afterLoc","tryEntries","resetTryEntry","completion","reset","iterable","iteratorMethod","isNaN","constructor","displayName","isGeneratorFunction","genFun","ctor","mark","setPrototypeOf","__proto__","awrap","async","iter","reverse","skipTempReset","prev","stop","rootRecord","rval","exception","handle","caught","hasCatch","hasFinally","finallyEntry","complete","finish","thrown","delegateYield","regeneratorRuntime","accidentalStrictMode","_reactDom","_copyToClipboard","_ExecuteButton","_ImagePreview","_ToolbarButton","_ToolbarGroup","_ToolbarMenu","_ToolbarSelect","_QueryEditor","_VariableEditor","_ResultViewer","_DocExplorer","_QueryHistory","_CodeMirrorSizer","_StorageAPI","_getQueryFacts","_getSelectedOperationName","_debounce","_find","_fillLeafs","_elementPosition","_mergeAst","_introspectionQueries","_defineProperty","DEFAULT_DOC_EXPLORER_WIDTH","super","reference","setState","docExplorerOpen","docExplorerComponent","showDocForReference","selectedOperationName","_editorQueryID","queryID","editedQuery","autoCompleteLeafs","variables","operationName","handleEditOperationName","isWaitingForResponse","response","subscription","_fetchQuery","formatResult","unsubscribe","editor","getQueryEditor","editorContent","getValue","prettifiedEditorContent","setValue","variableEditor","getVariableEditor","variableEditorContent","prettifiedVariableEditorContent","JSON","stringify","mergeAst","queryFacts","_updateQueryFacts","operations","onEditQuery","onCopyQuery","prevOperations","updatedOperationName","onEditOperationName","onEditVariables","elem","_onClickHintInformation","_runQueryAtCursor","typeName","showDoc","onToggleDocs","onToggleHistory","historyPaneOpen","handleEditQuery","handleEditVariables","downEvent","_didClickDragBar","clientX","getLeft","moveEvent","buttons","onMouseUp","editorBar","findDOMNode","editorBarComponent","leftSize","rightSize","clientWidth","editorFlex","hadWidth","docExplorerWidth","app","cursorPos","docsSize","didMove","wasOpen","variableEditorOpen","hadHeight","variableEditorHeight","clientY","getTop","topSize","bottomSize","clientHeight","fetcher","_storage","storage","_query","defaultQuery","_queryFacts","_variables","_operationName","defaultVariableEditorOpen","componentWillUnmount","_fetchSchema","codeMirrorSizer","global","nextSchema","nextQuery","nextVariables","nextOperationName","nextResponse","updatedQueryAttributes","updateSizes","queryEditorComponent","variableEditorComponent","resultComponent","set","Children","toArray","logo","Logo","toolbar","Toolbar","ToolbarButton","handlePrettifyQuery","handleMergeQuery","handleCopyQuery","handleToggleHistory","footer","Footer","queryWrapStyle","WebkitFlex","flex","docWrapStyle","width","docExplorerWrapClasses","historyPaneStyle","zIndex","variableOpen","variableStyle","height","QueryHistory","onSelectQuery","handleSelectHistoryQuery","ExecuteButton","isRunning","onRun","handleRunQuery","onStop","handleStopQuery","handleToggleDocs","ref","onDoubleClick","handleResetResize","onMouseDown","handleResizeStart","QueryEditor","onEdit","handleHintInformationRender","onClickReference","handleClickReference","onPrettifyQuery","onMergeQuery","onRunQuery","handleEditorRunQuery","editorTheme","readOnly","id","handleVariableResizeStart","VariableEditor","variableToType","ResultViewer","ResultsTooltip","ImagePreview","handleDocsResetResize","handleDocsResizeStart","DocExplorer","getCodeMirror","refresh","insertions","fillLeafs","getDefaultFieldNames","getCursor","cursorIndex","indexFromPos","added","markers","markText","posFromIndex","clearOnEnter","newCursorIndex","setCursor","fetch","observableToPromise","introspectionQuery","introspectionQueryName","isPromise","fetch2","introspectionQuerySansSubscriptions","buildClientSchema","responseString","catch","formatError","cb","jsonVariables","isObservable","subscribe","hasFocus","button","ctrlKey","resultWindow","instanceOf","GraphQLSchema","shape","getItem","setItem","removeItem","any","role","Button","Group","ToolbarGroup","Menu","ToolbarMenu","MenuItem","ToolbarMenuItem","Select","ToolbarSelect","SelectOption","ToolbarSelectOption","formatSingleError","rawError","observable","deselectCurrent","defaultMessage","debug","reselectPrevious","selection","success","createRange","getSelection","textContent","clip","whiteSpace","webkitUserSelect","MozUserSelect","msUserSelect","userSelect","stopPropagation","clipboardData","clearData","setData","selectNodeContents","addRange","execCommand","console","warn","copyKey","userAgent","prompt","removeRange","removeAllRanges","rangeCount","active","activeElement","ranges","getRangeAt","tagName","blur","focus","optionsOpen","initialPress","downTarget","highlight","upEvent","compareDocumentPosition","Node","DOCUMENT_POSITION_CONTAINED_BY","hasOptions","_onOptionSelected","_onClick","_onOptionsOpen","pathJSX","tokenToURL","URL","protocol","host","url","pathname","isImageURL","mime","_updateMetadata","dims","dimensions","onLoad","_node","naturalWidth","naturalHeight","headers","handleClick","visible","_subscribe","_release","handleOpen","fill","_listener","onSelect","_extends","selectedChild","optionChildren","selected","onChildSelect","points","_markdownIt","_normalizeWhitespace","_onHasCompletion","_commonKeys","AUTO_COMPLETE_AFTER_KEY","ignoreChangeEvent","cachedValue","CodeMirror","lineNumbers","mode","theme","keyMap","autoCloseBrackets","matchBrackets","showCursorWhenSelecting","foldGutter","minFoldSize","lint","hintOptions","closeOnUnfocus","completeSingle","container","gutters","extraKeys","showHint","_onEdit","_onKeyUp","_onBeforeChange","prevProps","signal","instance","origin","normalizeWhitespace","from","to","utils","helpers","Renderer","ParserCore","ParserBlock","ParserInline","LinkifyIt","punycode","config","zero","commonmark","BAD_PROTO_RE","GOOD_DATA_RE","validateLink","RECODE_HOSTNAME_FOR","normalizeLink","parsed","hostname","toASCII","er","normalizeLinkText","toUnicode","MarkdownIt","presetName","inline","core","renderer","linkify","configure","presets","components","rules","ruler","rules2","ruler2","missed","use","plugin","env","State","process","parseInline","inlineMode","renderInline","encodeCache","exclude","keepEscaped","l","nextCode","cache","defaultChars","getEncodeCache","encodeURIComponent","componentChars","decodeCache","getDecodeCache","seq","b1","b2","b3","b4","chr","slashes","auth","port","search","hash","Url","protocolPattern","portPattern","simplePathPattern","unwise","autoEscape","nonHostChars","hostEndingChars","hostnamePartPattern","hostnamePartStart","hostlessProtocol","slashedProtocol","slashesDenoteHost","lowerProto","hec","rest","simplePath","exec","proto","substr","atSign","hostEnd","lastIndexOf","parseHost","ipv6Hostname","hostparts","part","newpart","k","validParts","notHost","bit","unshift","qm","u","Any","Cc","Cf","Z","parseLinkLabel","parseLinkDestination","parseLinkTitle","disableNested","found","prevPos","labelEnd","posMax","oldPos","skipToken","ok","default_rules","code_inline","slf","renderAttrs","code_block","fence","highlighted","tmpAttrs","tmpToken","langName","langPrefix","image","renderInlineAsText","renderToken","hardbreak","xhtmlOut","softbreak","breaks","html_block","html_inline","nextToken","needLf","_rules","Core","NEWLINES_RE","NULL_RE","tok","isLinkClose","currentToken","ln","lastPos","htmlLinkLevel","fullUrl","urlText","links","blockTokens","pretest","lastIndex","RARE_RE","SCOPED_ABBR_TEST_RE","SCOPED_ABBR_RE","SCOPED_ABBR","r","tm","replaceFn","replace_scoped","inlineTokens","inside_autolink","replace_rare","blkIdx","typographer","QUOTE_TEST_RE","QUOTE_RE","APOSTROPHE","replaceAt","process_inlines","thisLevel","item","lastChar","nextChar","isLastPunctChar","isNextPunctChar","isLastWhiteSpace","isNextWhiteSpace","canOpen","canClose","isSingle","openQuote","closeQuote","OUTER","single","quotes","StateCore","hasEmptyLines","maxNesting","skipEmptyLines","sCount","blkIndent","tight","isEmpty","outTokens","lineMax","getLine","bMarks","eMarks","escapedSplit","escapes","backTicked","lastBackTick","lineText","nextLine","columns","columnCount","aligns","tableLines","tbodyLines","tShift","last","getLines","params","mem","haveEndMarker","skipChars","skipSpaces","adjustTab","initial","lastLineEmpty","oldBMarks","oldBSCount","oldIndent","oldParentType","oldSCount","oldTShift","spaceAfterMarker","terminate","terminatorRules","wasOutdented","oldLineMax","bsCount","cnt","skipBulletListMarker","skipOrderedListMarker","contentStart","indent","indentAfterMarker","isOrdered","itemLines","listLines","listTokIdx","markerCharCode","markerValue","oldListIndent","oldTight","posAfterMarker","prevEmptyEnd","isTerminatingParagraph","listIndent","markTightParagraphs","_endLine","destEndPos","destEndLineNo","references","tmp","skipSpacesBack","skipCharsBack","block_names","HTML_SEQUENCES","html","StateBlock","indent_found","ddIndent","begin","keepLastLF","lineIndent","first","queue","lineStart","_rules2","pending","pushPending","isTerminatorChar","pmax","ESCAPED","matchStart","matchEnd","labelStart","parseReference","EMAIL_RE","AUTOLINK_RE","tail","linkMatch","emailMatch","lc","isLetter","DIGITAL_RE","NAMED_RE","processDelimiters","closerIdx","openerIdx","closer","opener","minOpenerIdx","newMinOpenerIdx","isOddMatch","lastJump","openersBottom","StateInline","pendingLevel","_prev_delimiters","token_meta","canSplitWord","count","left_flanking","right_flanking","isFunction","defaultOptions","fuzzyLink","fuzzyEmail","fuzzyIP","defaultSchemas","validate","re","http","src_auth","src_host_port_strict","src_path","no_http","src_domain","src_domain_root","src_port","src_host_terminator","mailto","src_email_name","src_host_strict","tlds_2ch_src_re","tlds_default","compile","__opts__","tlds","__tlds__","untpl","tpl","src_tlds","onCompile","__tlds_replaced__","src_xn","email_fuzzy","tpl_email_fuzzy","link_fuzzy","tpl_link_fuzzy","link_no_ip_fuzzy","tpl_link_no_ip_fuzzy","host_fuzzy_test","tpl_host_fuzzy_test","aliases","schemaError","__compiled__","__schemas__","compiled","link","isRegExp","createValidator","normalize","slist","schema_test","src_ZPCc","schema_search","__index__","__text_cache__","resetScanCache","Match","shift","__last_index__","__schema__","raw","createMatch","schemas","reduce","acc","ml","me","tld_pos","testSchemaAt","keepOld","opts","src_Any","src_Cc","src_Z","src_P","src_ZCc","src_pseudo_letter","src_ip4","src_host","tpl_host_fuzzy","tpl_host_no_ip_fuzzy","tpl_host_fuzzy_strict","tpl_host_port_fuzzy_strict","tpl_host_port_no_ip_fuzzy_strict","root","nodeType","freeGlobal","maxInt","base","tMin","tMax","skew","damp","initialBias","initialN","delimiter","regexPunycode","regexNonASCII","regexSeparators","errors","baseMinusTMin","stringFromCharCode","RangeError","mapDomain","parts","ucs2decode","extra","output","counter","ucs2encode","digitToBasic","digit","flag","adapt","delta","numPoints","firstTime","input","out","basic","oldi","w","baseMinusT","codePoint","inputLength","bias","handledCPCount","basicLength","q","currentValue","handledCPCountPlusOne","qMinusT","sanitizeRegex","invalidCharacters","_graphqlLanguageServiceInterface","registerHelper","cur","rawResults","tokenStart","results","Pos","sourceText","_start","_pos","_sourceText","sol","peek","char","eat","pattern","_testNextCharacter","eatWhile","isMatched","didEat","eatSpace","skipToEnd","skipTo","consume","caseFold","startsWith","backUp","num","indentation","whitespaces","eatWhitespace","lexRules","parseRules","editorConfig","initialState","needsSeperator","pushRule","popRule","needsAdvance","advanceRule","indentLevel","kinds","lex","SpecialParseRules","backupState","levels","expected","unsuccessful","getToken","Invalid","ruleKind","successful","AdditionalRuleKinds","SHORT_QUERY","INVALID","COMMENT","EXTEND_DEF","DIRECTIVE_DEF","point","linesUntilPosition","nodeContainingPosition","enter","containsPosition","setStart","setEnd","lessThanOrEqualTo","setLine","setCharacter","buf","lastLineIndex","ExecutableDefinitions_1","specifiedRules","NoUnusedFragmentsRule","ExecutableDefinitions","KnownFragmentNamesRule","getDiagnostics_1","getDefinition_1","OBJECT_TYPE_DEFINITION","INTERFACE_TYPE_DEFINITION","ENUM_TYPE_DEFINITION","UNION_TYPE_DEFINITION","SCALAR_TYPE_DEFINITION","INPUT_OBJECT_TYPE_DEFINITION","SCALAR_TYPE_EXTENSION","OBJECT_TYPE_EXTENSION","INTERFACE_TYPE_EXTENSION","UNION_TYPE_EXTENSION","ENUM_TYPE_EXTENSION","INPUT_OBJECT_TYPE_EXTENSION","DIRECTIVE_DEFINITION","OPERATION_DEFINITION","KIND_TO_SYMBOL_KIND","ENUM_VALUE_DEFINITION","INPUT_VALUE_DEFINITION","FIELD_DEFINITION","FieldWithArguments","getKind","tree","GraphQLLanguageService","_graphQLCache","_graphQLConfig","getGraphQLConfig","getConfigForURI","getProjectForFile","queryHasExtensions","projectConfig","schemaPath","projectName","extensions","queryAST","fragmentDefinitions","fragmentDependencies","dependenciesSource","validationAst","customValidationRules","some","getFragmentDependencies","getSchema","getDefinition","_getDefinitionForFragmentSpread","_getDefinitionForNamedType","getDocumentSymbols","outline","_loop_1","state_1","parent_1","objectTypeDefinitions","localObjectTypeDefinitions","localOperationDefinationInfos","getObjectTypeDefinitions","getObjectTypeDependenciesForAST","localFragDefinitions","localFragInfos","getFragmentDependenciesForAST","TYPE","_getTypeInfo","_SchemaReference","descriptionDiv","createTextNode","deprecationDiv","insertBefore","firstChild","isHoldingModifier","enableJumpMode","disableJumpMode","onKeyDown","isMac","onKeyUp","clickEvent","destination","codemirrorIgnore","oldOnMouseOut","appVersion","getDestination","_graphqlLanguageServiceParser","textAfter","electricInput","indentUnit","defineMode","fold","lineComment","closeBrackets","pairs","explode","keyCode","shiftKey","thisValue","_hintList","variableNames","inputFields","valueMap","getVariablesHint","hints","_jsonParse","lintError","syntaxError","variablesAST","members","member","variableName","validateValue","valueAST","itemType","providedFields","fieldErrors","inputField","fieldType","GraphQLScalarType","parseValue","validateVariables","strLen","lastEnd","parseObj","nodeStart","expect","skip","parseMember","curToken","parseVal","parseArr","readHex","readString","readDigits","readNumber","namedKey","Tooltip","tooltipDiv","infoElements","shouldRender","unmountComponentAtNode","viewer","lineWrapping","Entry","_FieldDoc","_SchemaDoc","_SearchBox","_SearchResults","_TypeDoc","initialNav","navStack","typeOrField","showSearch","nextState","navItem","searchValue","withinType","handleClickTypeOrField","onClickField","isType","shouldSearchBoxAppear","prevName","handleNavBackClick","placeholder","onSearch","handleSearch","topNav","_Argument","_MarkdownContent","FieldDoc","argsDef","SchemaDoc","queryType","mutationType","subscriptionType","SearchBox","debouncedOnSearch","onChange","handleChange","handleClear","SearchResults","matchedWithin","matchedTypes","matchedFields","typeNames","isMatch","matchingArgs","TypeDoc","showDeprecated","typesTitle","types","typesDef","fieldsDef","deprecatedFieldsDef","valuesDef","deprecatedValuesDef","GraphQLUnionType","GraphQLInterfaceType","GraphQLObjectType","subtype","fieldMap","deprecatedFields","handleShowDeprecated","deprecatedValues","_QueryStore","_HistoryQuery","MAX_HISTORY_LENGTH","shouldSaveQuery","lastQuerySaved","favorite","favoriteStore","contains","queries","historyStore","historyQueries","fetchAll","favoriteQueries","fetchRecent","queryNodes","handleEditLabel","editLabel","handleToggleFavorite","toggleFavorite","maxSize","itemIndex","findIndex","save","attempts","isQuotaError","HistoryQuery","editable","starIcon","editField","onBlur","handleFieldBlur","handleFieldKeyDown","handleEditClick","handleStarClick","favoriteSize","sizes","component","size","getClientHeight","setSize","localStorage","quotaError","DOMException","documentStr","documentAST","collectVariables","variableDefinitions","typeFromAST","prevSelectedOperationName","names","prevIndex","docString","fieldNameFn","defaultGetDefaultFieldNames","TypeInfo","buildSelectionSet","isLeafType","fieldNames","indentStart","indentEnd","getIndentation","withInsertions","leafFieldNames","edited","initialElem","pt","offsetParent","offsetLeft","offsetTop","queryAst","fragments","_kinds","copyFragment","copyAst","resolveDefinition","_selection","getOperationAST"],"mappings":"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","file":"14.d17364fb70f93fc4442c.chunk.js","sourcesContent":["// Utilities\n//\n'use strict';\n\n\nfunction _class(obj) { return Object.prototype.toString.call(obj); }\n\nfunction isString(obj) { return _class(obj) === '[object String]'; }\n\nvar _hasOwnProperty = Object.prototype.hasOwnProperty;\n\nfunction has(object, key) {\n  return _hasOwnProperty.call(object, key);\n}\n\n// Merge objects\n//\nfunction assign(obj /*from1, from2, from3, ...*/) {\n  var sources = Array.prototype.slice.call(arguments, 1);\n\n  sources.forEach(function (source) {\n    if (!source) { return; }\n\n    if (typeof source !== 'object') {\n      throw new TypeError(source + 'must be object');\n    }\n\n    Object.keys(source).forEach(function (key) {\n      obj[key] = source[key];\n    });\n  });\n\n  return obj;\n}\n\n// Remove element from array and put another array at those position.\n// Useful for some operations with tokens\nfunction arrayReplaceAt(src, pos, newElements) {\n  return [].concat(src.slice(0, pos), newElements, src.slice(pos + 1));\n}\n\n////////////////////////////////////////////////////////////////////////////////\n\nfunction isValidEntityCode(c) {\n  /*eslint no-bitwise:0*/\n  // broken sequence\n  if (c >= 0xD800 && c <= 0xDFFF) { return false; }\n  // never used\n  if (c >= 0xFDD0 && c <= 0xFDEF) { return false; }\n  if ((c & 0xFFFF) === 0xFFFF || (c & 0xFFFF) === 0xFFFE) { return false; }\n  // control codes\n  if (c >= 0x00 && c <= 0x08) { return false; }\n  if (c === 0x0B) { return false; }\n  if (c >= 0x0E && c <= 0x1F) { return false; }\n  if (c >= 0x7F && c <= 0x9F) { return false; }\n  // out of range\n  if (c > 0x10FFFF) { return false; }\n  return true;\n}\n\nfunction fromCodePoint(c) {\n  /*eslint no-bitwise:0*/\n  if (c > 0xffff) {\n    c -= 0x10000;\n    var surrogate1 = 0xd800 + (c >> 10),\n        surrogate2 = 0xdc00 + (c & 0x3ff);\n\n    return String.fromCharCode(surrogate1, surrogate2);\n  }\n  return String.fromCharCode(c);\n}\n\n\nvar UNESCAPE_MD_RE  = /\\\\([!\"#$%&'()*+,\\-.\\/:;<=>?@[\\\\\\]^_`{|}~])/g;\nvar ENTITY_RE       = /&([a-z#][a-z0-9]{1,31});/gi;\nvar UNESCAPE_ALL_RE = new RegExp(UNESCAPE_MD_RE.source + '|' + ENTITY_RE.source, 'gi');\n\nvar DIGITAL_ENTITY_TEST_RE = /^#((?:x[a-f0-9]{1,8}|[0-9]{1,8}))/i;\n\nvar entities = require('./entities');\n\nfunction replaceEntityPattern(match, name) {\n  var code = 0;\n\n  if (has(entities, name)) {\n    return entities[name];\n  }\n\n  if (name.charCodeAt(0) === 0x23/* # */ && DIGITAL_ENTITY_TEST_RE.test(name)) {\n    code = name[1].toLowerCase() === 'x' ?\n      parseInt(name.slice(2), 16) : parseInt(name.slice(1), 10);\n\n    if (isValidEntityCode(code)) {\n      return fromCodePoint(code);\n    }\n  }\n\n  return match;\n}\n\n/*function replaceEntities(str) {\n  if (str.indexOf('&') < 0) { return str; }\n\n  return str.replace(ENTITY_RE, replaceEntityPattern);\n}*/\n\nfunction unescapeMd(str) {\n  if (str.indexOf('\\\\') < 0) { return str; }\n  return str.replace(UNESCAPE_MD_RE, '$1');\n}\n\nfunction unescapeAll(str) {\n  if (str.indexOf('\\\\') < 0 && str.indexOf('&') < 0) { return str; }\n\n  return str.replace(UNESCAPE_ALL_RE, function (match, escaped, entity) {\n    if (escaped) { return escaped; }\n    return replaceEntityPattern(match, entity);\n  });\n}\n\n////////////////////////////////////////////////////////////////////////////////\n\nvar HTML_ESCAPE_TEST_RE = /[&<>\"]/;\nvar HTML_ESCAPE_REPLACE_RE = /[&<>\"]/g;\nvar HTML_REPLACEMENTS = {\n  '&': '&amp;',\n  '<': '&lt;',\n  '>': '&gt;',\n  '\"': '&quot;'\n};\n\nfunction replaceUnsafeChar(ch) {\n  return HTML_REPLACEMENTS[ch];\n}\n\nfunction escapeHtml(str) {\n  if (HTML_ESCAPE_TEST_RE.test(str)) {\n    return str.replace(HTML_ESCAPE_REPLACE_RE, replaceUnsafeChar);\n  }\n  return str;\n}\n\n////////////////////////////////////////////////////////////////////////////////\n\nvar REGEXP_ESCAPE_RE = /[.?*+^$[\\]\\\\(){}|-]/g;\n\nfunction escapeRE(str) {\n  return str.replace(REGEXP_ESCAPE_RE, '\\\\$&');\n}\n\n////////////////////////////////////////////////////////////////////////////////\n\nfunction isSpace(code) {\n  switch (code) {\n    case 0x09:\n    case 0x20:\n      return true;\n  }\n  return false;\n}\n\n// Zs (unicode class) || [\\t\\f\\v\\r\\n]\nfunction isWhiteSpace(code) {\n  if (code >= 0x2000 && code <= 0x200A) { return true; }\n  switch (code) {\n    case 0x09: // \\t\n    case 0x0A: // \\n\n    case 0x0B: // \\v\n    case 0x0C: // \\f\n    case 0x0D: // \\r\n    case 0x20:\n    case 0xA0:\n    case 0x1680:\n    case 0x202F:\n    case 0x205F:\n    case 0x3000:\n      return true;\n  }\n  return false;\n}\n\n////////////////////////////////////////////////////////////////////////////////\n\n/*eslint-disable max-len*/\nvar UNICODE_PUNCT_RE = require('uc.micro/categories/P/regex');\n\n// Currently without astral characters support.\nfunction isPunctChar(ch) {\n  return UNICODE_PUNCT_RE.test(ch);\n}\n\n\n// Markdown ASCII punctuation characters.\n//\n// !, \", #, $, %, &, ', (, ), *, +, ,, -, ., /, :, ;, <, =, >, ?, @, [, \\, ], ^, _, `, {, |, }, or ~\n// http://spec.commonmark.org/0.15/#ascii-punctuation-character\n//\n// Don't confuse with unicode punctuation !!! It lacks some chars in ascii range.\n//\nfunction isMdAsciiPunct(ch) {\n  switch (ch) {\n    case 0x21/* ! */:\n    case 0x22/* \" */:\n    case 0x23/* # */:\n    case 0x24/* $ */:\n    case 0x25/* % */:\n    case 0x26/* & */:\n    case 0x27/* ' */:\n    case 0x28/* ( */:\n    case 0x29/* ) */:\n    case 0x2A/* * */:\n    case 0x2B/* + */:\n    case 0x2C/* , */:\n    case 0x2D/* - */:\n    case 0x2E/* . */:\n    case 0x2F/* / */:\n    case 0x3A/* : */:\n    case 0x3B/* ; */:\n    case 0x3C/* < */:\n    case 0x3D/* = */:\n    case 0x3E/* > */:\n    case 0x3F/* ? */:\n    case 0x40/* @ */:\n    case 0x5B/* [ */:\n    case 0x5C/* \\ */:\n    case 0x5D/* ] */:\n    case 0x5E/* ^ */:\n    case 0x5F/* _ */:\n    case 0x60/* ` */:\n    case 0x7B/* { */:\n    case 0x7C/* | */:\n    case 0x7D/* } */:\n    case 0x7E/* ~ */:\n      return true;\n    default:\n      return false;\n  }\n}\n\n// Hepler to unify [reference labels].\n//\nfunction normalizeReference(str) {\n  // Trim and collapse whitespace\n  //\n  str = str.trim().replace(/\\s+/g, ' ');\n\n  // In node v10 'ẞ'.toLowerCase() === 'Ṿ', which is presumed to be a bug\n  // fixed in v12 (couldn't find any details).\n  //\n  // So treat this one as a special case\n  // (remove this when node v10 is no longer supported).\n  //\n  if ('ẞ'.toLowerCase() === 'Ṿ') {\n    str = str.replace(/ẞ/g, 'ß');\n  }\n\n  // .toLowerCase().toUpperCase() should get rid of all differences\n  // between letter variants.\n  //\n  // Simple .toLowerCase() doesn't normalize 125 code points correctly,\n  // and .toUpperCase doesn't normalize 6 of them (list of exceptions:\n  // İ, ϴ, ẞ, Ω, K, Å - those are already uppercased, but have differently\n  // uppercased versions).\n  //\n  // Here's an example showing how it happens. Lets take greek letter omega:\n  // uppercase U+0398 (Θ), U+03f4 (ϴ) and lowercase U+03b8 (θ), U+03d1 (ϑ)\n  //\n  // Unicode entries:\n  // 0398;GREEK CAPITAL LETTER THETA;Lu;0;L;;;;;N;;;;03B8;\n  // 03B8;GREEK SMALL LETTER THETA;Ll;0;L;;;;;N;;;0398;;0398\n  // 03D1;GREEK THETA SYMBOL;Ll;0;L;<compat> 03B8;;;;N;GREEK SMALL LETTER SCRIPT THETA;;0398;;0398\n  // 03F4;GREEK CAPITAL THETA SYMBOL;Lu;0;L;<compat> 0398;;;;N;;;;03B8;\n  //\n  // Case-insensitive comparison should treat all of them as equivalent.\n  //\n  // But .toLowerCase() doesn't change ϑ (it's already lowercase),\n  // and .toUpperCase() doesn't change ϴ (already uppercase).\n  //\n  // Applying first lower then upper case normalizes any character:\n  // '\\u0398\\u03f4\\u03b8\\u03d1'.toLowerCase().toUpperCase() === '\\u0398\\u0398\\u0398\\u0398'\n  //\n  // Note: this is equivalent to unicode case folding; unicode normalization\n  // is a different step that is not required here.\n  //\n  // Final result should be uppercased, because it's later stored in an object\n  // (this avoid a conflict with Object.prototype members,\n  // most notably, `__proto__`)\n  //\n  return str.toLowerCase().toUpperCase();\n}\n\n////////////////////////////////////////////////////////////////////////////////\n\n// Re-export libraries commonly used in both markdown-it and its plugins,\n// so plugins won't have to depend on them explicitly, which reduces their\n// bundled size (e.g. a browser build).\n//\nexports.lib                 = {};\nexports.lib.mdurl           = require('mdurl');\nexports.lib.ucmicro         = require('uc.micro');\n\nexports.assign              = assign;\nexports.isString            = isString;\nexports.has                 = has;\nexports.unescapeMd          = unescapeMd;\nexports.unescapeAll         = unescapeAll;\nexports.isValidEntityCode   = isValidEntityCode;\nexports.fromCodePoint       = fromCodePoint;\n// exports.replaceEntities     = replaceEntities;\nexports.escapeHtml          = escapeHtml;\nexports.arrayReplaceAt      = arrayReplaceAt;\nexports.isSpace             = isSpace;\nexports.isWhiteSpace        = isWhiteSpace;\nexports.isMdAsciiPunct      = isMdAsciiPunct;\nexports.isPunctChar         = isPunctChar;\nexports.escapeRE            = escapeRE;\nexports.normalizeReference  = normalizeReference;\n","\"use strict\";\nfunction __export(m) {\n    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];\n}\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar CharacterStream_1 = require(\"./CharacterStream\");\nexports.CharacterStream = CharacterStream_1.default;\nvar Rules_1 = require(\"./Rules\");\nexports.LexRules = Rules_1.LexRules;\nexports.ParseRules = Rules_1.ParseRules;\nexports.isIgnored = Rules_1.isIgnored;\nvar RuleHelpers_1 = require(\"./RuleHelpers\");\nexports.butNot = RuleHelpers_1.butNot;\nexports.list = RuleHelpers_1.list;\nexports.opt = RuleHelpers_1.opt;\nexports.p = RuleHelpers_1.p;\nexports.t = RuleHelpers_1.t;\nvar onlineParser_1 = require(\"./onlineParser\");\nexports.onlineParser = onlineParser_1.default;\n__export(require(\"./types\"));\n//# sourceMappingURL=index.js.map","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.default = void 0;\n\nvar _react = _interopRequireDefault(require(\"react\"));\n\nvar _propTypes = _interopRequireDefault(require(\"prop-types\"));\n\nvar _graphql = require(\"graphql\");\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\nclass TypeLink extends _react.default.Component {\n  shouldComponentUpdate(nextProps) {\n    return this.props.type !== nextProps.type;\n  }\n\n  render() {\n    return renderType(this.props.type, this.props.onClick);\n  }\n\n}\n\nexports.default = TypeLink;\n\n_defineProperty(TypeLink, \"propTypes\", {\n  type: _propTypes.default.object,\n  onClick: _propTypes.default.func\n});\n\nfunction renderType(type, onClick) {\n  if (type instanceof _graphql.GraphQLNonNull) {\n    return _react.default.createElement(\"span\", null, renderType(type.ofType, onClick), '!');\n  }\n\n  if (type instanceof _graphql.GraphQLList) {\n    return _react.default.createElement(\"span\", null, '[', renderType(type.ofType, onClick), ']');\n  }\n\n  return _react.default.createElement(\"a\", {\n    className: \"type-name\",\n    onClick: event => {\n      event.preventDefault();\n      onClick(type, event);\n    },\n    href: \"#\"\n  }, type.name);\n}","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar getASTNodeAtPosition_1 = require(\"./getASTNodeAtPosition\");\nexports.getASTNodeAtPosition = getASTNodeAtPosition_1.getASTNodeAtPosition;\nexports.pointToOffset = getASTNodeAtPosition_1.pointToOffset;\nvar Range_1 = require(\"./Range\");\nexports.Position = Range_1.Position;\nexports.Range = Range_1.Range;\nexports.locToRange = Range_1.locToRange;\nexports.offsetToPosition = Range_1.offsetToPosition;\nvar validateWithCustomRules_1 = require(\"./validateWithCustomRules\");\nexports.validateWithCustomRules = validateWithCustomRules_1.validateWithCustomRules;\n//# sourceMappingURL=index.js.map","'use strict';\n\n\nmodule.exports = require('./lib/');\n","module.exports=/[!-#%-\\*,-\\/:;\\?@\\[-\\]_\\{\\}\\xA1\\xA7\\xAB\\xB6\\xB7\\xBB\\xBF\\u037E\\u0387\\u055A-\\u055F\\u0589\\u058A\\u05BE\\u05C0\\u05C3\\u05C6\\u05F3\\u05F4\\u0609\\u060A\\u060C\\u060D\\u061B\\u061E\\u061F\\u066A-\\u066D\\u06D4\\u0700-\\u070D\\u07F7-\\u07F9\\u0830-\\u083E\\u085E\\u0964\\u0965\\u0970\\u09FD\\u0A76\\u0AF0\\u0C84\\u0DF4\\u0E4F\\u0E5A\\u0E5B\\u0F04-\\u0F12\\u0F14\\u0F3A-\\u0F3D\\u0F85\\u0FD0-\\u0FD4\\u0FD9\\u0FDA\\u104A-\\u104F\\u10FB\\u1360-\\u1368\\u1400\\u166D\\u166E\\u169B\\u169C\\u16EB-\\u16ED\\u1735\\u1736\\u17D4-\\u17D6\\u17D8-\\u17DA\\u1800-\\u180A\\u1944\\u1945\\u1A1E\\u1A1F\\u1AA0-\\u1AA6\\u1AA8-\\u1AAD\\u1B5A-\\u1B60\\u1BFC-\\u1BFF\\u1C3B-\\u1C3F\\u1C7E\\u1C7F\\u1CC0-\\u1CC7\\u1CD3\\u2010-\\u2027\\u2030-\\u2043\\u2045-\\u2051\\u2053-\\u205E\\u207D\\u207E\\u208D\\u208E\\u2308-\\u230B\\u2329\\u232A\\u2768-\\u2775\\u27C5\\u27C6\\u27E6-\\u27EF\\u2983-\\u2998\\u29D8-\\u29DB\\u29FC\\u29FD\\u2CF9-\\u2CFC\\u2CFE\\u2CFF\\u2D70\\u2E00-\\u2E2E\\u2E30-\\u2E4E\\u3001-\\u3003\\u3008-\\u3011\\u3014-\\u301F\\u3030\\u303D\\u30A0\\u30FB\\uA4FE\\uA4FF\\uA60D-\\uA60F\\uA673\\uA67E\\uA6F2-\\uA6F7\\uA874-\\uA877\\uA8CE\\uA8CF\\uA8F8-\\uA8FA\\uA8FC\\uA92E\\uA92F\\uA95F\\uA9C1-\\uA9CD\\uA9DE\\uA9DF\\uAA5C-\\uAA5F\\uAADE\\uAADF\\uAAF0\\uAAF1\\uABEB\\uFD3E\\uFD3F\\uFE10-\\uFE19\\uFE30-\\uFE52\\uFE54-\\uFE61\\uFE63\\uFE68\\uFE6A\\uFE6B\\uFF01-\\uFF03\\uFF05-\\uFF0A\\uFF0C-\\uFF0F\\uFF1A\\uFF1B\\uFF1F\\uFF20\\uFF3B-\\uFF3D\\uFF3F\\uFF5B\\uFF5D\\uFF5F-\\uFF65]|\\uD800[\\uDD00-\\uDD02\\uDF9F\\uDFD0]|\\uD801\\uDD6F|\\uD802[\\uDC57\\uDD1F\\uDD3F\\uDE50-\\uDE58\\uDE7F\\uDEF0-\\uDEF6\\uDF39-\\uDF3F\\uDF99-\\uDF9C]|\\uD803[\\uDF55-\\uDF59]|\\uD804[\\uDC47-\\uDC4D\\uDCBB\\uDCBC\\uDCBE-\\uDCC1\\uDD40-\\uDD43\\uDD74\\uDD75\\uDDC5-\\uDDC8\\uDDCD\\uDDDB\\uDDDD-\\uDDDF\\uDE38-\\uDE3D\\uDEA9]|\\uD805[\\uDC4B-\\uDC4F\\uDC5B\\uDC5D\\uDCC6\\uDDC1-\\uDDD7\\uDE41-\\uDE43\\uDE60-\\uDE6C\\uDF3C-\\uDF3E]|\\uD806[\\uDC3B\\uDE3F-\\uDE46\\uDE9A-\\uDE9C\\uDE9E-\\uDEA2]|\\uD807[\\uDC41-\\uDC45\\uDC70\\uDC71\\uDEF7\\uDEF8]|\\uD809[\\uDC70-\\uDC74]|\\uD81A[\\uDE6E\\uDE6F\\uDEF5\\uDF37-\\uDF3B\\uDF44]|\\uD81B[\\uDE97-\\uDE9A]|\\uD82F\\uDC9F|\\uD836[\\uDE87-\\uDE8B]|\\uD83A[\\uDD5E\\uDD5F]/","/**\n * class Ruler\n *\n * Helper class, used by [[MarkdownIt#core]], [[MarkdownIt#block]] and\n * [[MarkdownIt#inline]] to manage sequences of functions (rules):\n *\n * - keep rules in defined order\n * - assign the name to each rule\n * - enable/disable rules\n * - add/replace rules\n * - allow assign rules to additional named chains (in the same)\n * - cacheing lists of active rules\n *\n * You will not need use this class directly until write plugins. For simple\n * rules control use [[MarkdownIt.disable]], [[MarkdownIt.enable]] and\n * [[MarkdownIt.use]].\n **/\n'use strict';\n\n\n/**\n * new Ruler()\n **/\nfunction Ruler() {\n  // List of added rules. Each element is:\n  //\n  // {\n  //   name: XXX,\n  //   enabled: Boolean,\n  //   fn: Function(),\n  //   alt: [ name2, name3 ]\n  // }\n  //\n  this.__rules__ = [];\n\n  // Cached rule chains.\n  //\n  // First level - chain name, '' for default.\n  // Second level - diginal anchor for fast filtering by charcodes.\n  //\n  this.__cache__ = null;\n}\n\n////////////////////////////////////////////////////////////////////////////////\n// Helper methods, should not be used directly\n\n\n// Find rule index by name\n//\nRuler.prototype.__find__ = function (name) {\n  for (var i = 0; i < this.__rules__.length; i++) {\n    if (this.__rules__[i].name === name) {\n      return i;\n    }\n  }\n  return -1;\n};\n\n\n// Build rules lookup cache\n//\nRuler.prototype.__compile__ = function () {\n  var self = this;\n  var chains = [ '' ];\n\n  // collect unique names\n  self.__rules__.forEach(function (rule) {\n    if (!rule.enabled) { return; }\n\n    rule.alt.forEach(function (altName) {\n      if (chains.indexOf(altName) < 0) {\n        chains.push(altName);\n      }\n    });\n  });\n\n  self.__cache__ = {};\n\n  chains.forEach(function (chain) {\n    self.__cache__[chain] = [];\n    self.__rules__.forEach(function (rule) {\n      if (!rule.enabled) { return; }\n\n      if (chain && rule.alt.indexOf(chain) < 0) { return; }\n\n      self.__cache__[chain].push(rule.fn);\n    });\n  });\n};\n\n\n/**\n * Ruler.at(name, fn [, options])\n * - name (String): rule name to replace.\n * - fn (Function): new rule function.\n * - options (Object): new rule options (not mandatory).\n *\n * Replace rule by name with new function & options. Throws error if name not\n * found.\n *\n * ##### Options:\n *\n * - __alt__ - array with names of \"alternate\" chains.\n *\n * ##### Example\n *\n * Replace existing typographer replacement rule with new one:\n *\n * ```javascript\n * var md = require('markdown-it')();\n *\n * md.core.ruler.at('replacements', function replace(state) {\n *   //...\n * });\n * ```\n **/\nRuler.prototype.at = function (name, fn, options) {\n  var index = this.__find__(name);\n  var opt = options || {};\n\n  if (index === -1) { throw new Error('Parser rule not found: ' + name); }\n\n  this.__rules__[index].fn = fn;\n  this.__rules__[index].alt = opt.alt || [];\n  this.__cache__ = null;\n};\n\n\n/**\n * Ruler.before(beforeName, ruleName, fn [, options])\n * - beforeName (String): new rule will be added before this one.\n * - ruleName (String): name of added rule.\n * - fn (Function): rule function.\n * - options (Object): rule options (not mandatory).\n *\n * Add new rule to chain before one with given name. See also\n * [[Ruler.after]], [[Ruler.push]].\n *\n * ##### Options:\n *\n * - __alt__ - array with names of \"alternate\" chains.\n *\n * ##### Example\n *\n * ```javascript\n * var md = require('markdown-it')();\n *\n * md.block.ruler.before('paragraph', 'my_rule', function replace(state) {\n *   //...\n * });\n * ```\n **/\nRuler.prototype.before = function (beforeName, ruleName, fn, options) {\n  var index = this.__find__(beforeName);\n  var opt = options || {};\n\n  if (index === -1) { throw new Error('Parser rule not found: ' + beforeName); }\n\n  this.__rules__.splice(index, 0, {\n    name: ruleName,\n    enabled: true,\n    fn: fn,\n    alt: opt.alt || []\n  });\n\n  this.__cache__ = null;\n};\n\n\n/**\n * Ruler.after(afterName, ruleName, fn [, options])\n * - afterName (String): new rule will be added after this one.\n * - ruleName (String): name of added rule.\n * - fn (Function): rule function.\n * - options (Object): rule options (not mandatory).\n *\n * Add new rule to chain after one with given name. See also\n * [[Ruler.before]], [[Ruler.push]].\n *\n * ##### Options:\n *\n * - __alt__ - array with names of \"alternate\" chains.\n *\n * ##### Example\n *\n * ```javascript\n * var md = require('markdown-it')();\n *\n * md.inline.ruler.after('text', 'my_rule', function replace(state) {\n *   //...\n * });\n * ```\n **/\nRuler.prototype.after = function (afterName, ruleName, fn, options) {\n  var index = this.__find__(afterName);\n  var opt = options || {};\n\n  if (index === -1) { throw new Error('Parser rule not found: ' + afterName); }\n\n  this.__rules__.splice(index + 1, 0, {\n    name: ruleName,\n    enabled: true,\n    fn: fn,\n    alt: opt.alt || []\n  });\n\n  this.__cache__ = null;\n};\n\n/**\n * Ruler.push(ruleName, fn [, options])\n * - ruleName (String): name of added rule.\n * - fn (Function): rule function.\n * - options (Object): rule options (not mandatory).\n *\n * Push new rule to the end of chain. See also\n * [[Ruler.before]], [[Ruler.after]].\n *\n * ##### Options:\n *\n * - __alt__ - array with names of \"alternate\" chains.\n *\n * ##### Example\n *\n * ```javascript\n * var md = require('markdown-it')();\n *\n * md.core.ruler.push('my_rule', function replace(state) {\n *   //...\n * });\n * ```\n **/\nRuler.prototype.push = function (ruleName, fn, options) {\n  var opt = options || {};\n\n  this.__rules__.push({\n    name: ruleName,\n    enabled: true,\n    fn: fn,\n    alt: opt.alt || []\n  });\n\n  this.__cache__ = null;\n};\n\n\n/**\n * Ruler.enable(list [, ignoreInvalid]) -> Array\n * - list (String|Array): list of rule names to enable.\n * - ignoreInvalid (Boolean): set `true` to ignore errors when rule not found.\n *\n * Enable rules with given names. If any rule name not found - throw Error.\n * Errors can be disabled by second param.\n *\n * Returns list of found rule names (if no exception happened).\n *\n * See also [[Ruler.disable]], [[Ruler.enableOnly]].\n **/\nRuler.prototype.enable = function (list, ignoreInvalid) {\n  if (!Array.isArray(list)) { list = [ list ]; }\n\n  var result = [];\n\n  // Search by name and enable\n  list.forEach(function (name) {\n    var idx = this.__find__(name);\n\n    if (idx < 0) {\n      if (ignoreInvalid) { return; }\n      throw new Error('Rules manager: invalid rule name ' + name);\n    }\n    this.__rules__[idx].enabled = true;\n    result.push(name);\n  }, this);\n\n  this.__cache__ = null;\n  return result;\n};\n\n\n/**\n * Ruler.enableOnly(list [, ignoreInvalid])\n * - list (String|Array): list of rule names to enable (whitelist).\n * - ignoreInvalid (Boolean): set `true` to ignore errors when rule not found.\n *\n * Enable rules with given names, and disable everything else. If any rule name\n * not found - throw Error. Errors can be disabled by second param.\n *\n * See also [[Ruler.disable]], [[Ruler.enable]].\n **/\nRuler.prototype.enableOnly = function (list, ignoreInvalid) {\n  if (!Array.isArray(list)) { list = [ list ]; }\n\n  this.__rules__.forEach(function (rule) { rule.enabled = false; });\n\n  this.enable(list, ignoreInvalid);\n};\n\n\n/**\n * Ruler.disable(list [, ignoreInvalid]) -> Array\n * - list (String|Array): list of rule names to disable.\n * - ignoreInvalid (Boolean): set `true` to ignore errors when rule not found.\n *\n * Disable rules with given names. If any rule name not found - throw Error.\n * Errors can be disabled by second param.\n *\n * Returns list of found rule names (if no exception happened).\n *\n * See also [[Ruler.enable]], [[Ruler.enableOnly]].\n **/\nRuler.prototype.disable = function (list, ignoreInvalid) {\n  if (!Array.isArray(list)) { list = [ list ]; }\n\n  var result = [];\n\n  // Search by name and disable\n  list.forEach(function (name) {\n    var idx = this.__find__(name);\n\n    if (idx < 0) {\n      if (ignoreInvalid) { return; }\n      throw new Error('Rules manager: invalid rule name ' + name);\n    }\n    this.__rules__[idx].enabled = false;\n    result.push(name);\n  }, this);\n\n  this.__cache__ = null;\n  return result;\n};\n\n\n/**\n * Ruler.getRules(chainName) -> Array\n *\n * Return array of active functions (rules) for given chain name. It analyzes\n * rules configuration, compiles caches if not exists and returns result.\n *\n * Default chain name is `''` (empty string). It can't be skipped. That's\n * done intentionally, to keep signature monomorphic for high speed.\n **/\nRuler.prototype.getRules = function (chainName) {\n  if (this.__cache__ === null) {\n    this.__compile__();\n  }\n\n  // Chain can be empty, if rules disabled. But we still have to return Array.\n  return this.__cache__[chainName] || [];\n};\n\nmodule.exports = Ruler;\n","// Token class\n\n'use strict';\n\n\n/**\n * class Token\n **/\n\n/**\n * new Token(type, tag, nesting)\n *\n * Create new token and fill passed properties.\n **/\nfunction Token(type, tag, nesting) {\n  /**\n   * Token#type -> String\n   *\n   * Type of the token (string, e.g. \"paragraph_open\")\n   **/\n  this.type     = type;\n\n  /**\n   * Token#tag -> String\n   *\n   * html tag name, e.g. \"p\"\n   **/\n  this.tag      = tag;\n\n  /**\n   * Token#attrs -> Array\n   *\n   * Html attributes. Format: `[ [ name1, value1 ], [ name2, value2 ] ]`\n   **/\n  this.attrs    = null;\n\n  /**\n   * Token#map -> Array\n   *\n   * Source map info. Format: `[ line_begin, line_end ]`\n   **/\n  this.map      = null;\n\n  /**\n   * Token#nesting -> Number\n   *\n   * Level change (number in {-1, 0, 1} set), where:\n   *\n   * -  `1` means the tag is opening\n   * -  `0` means the tag is self-closing\n   * - `-1` means the tag is closing\n   **/\n  this.nesting  = nesting;\n\n  /**\n   * Token#level -> Number\n   *\n   * nesting level, the same as `state.level`\n   **/\n  this.level    = 0;\n\n  /**\n   * Token#children -> Array\n   *\n   * An array of child nodes (inline and img tokens)\n   **/\n  this.children = null;\n\n  /**\n   * Token#content -> String\n   *\n   * In a case of self-closing tag (code, html, fence, etc.),\n   * it has contents of this tag.\n   **/\n  this.content  = '';\n\n  /**\n   * Token#markup -> String\n   *\n   * '*' or '_' for emphasis, fence string for fence, etc.\n   **/\n  this.markup   = '';\n\n  /**\n   * Token#info -> String\n   *\n   * fence infostring\n   **/\n  this.info     = '';\n\n  /**\n   * Token#meta -> Object\n   *\n   * A place for plugins to store an arbitrary data\n   **/\n  this.meta     = null;\n\n  /**\n   * Token#block -> Boolean\n   *\n   * True for block-level tokens, false for inline tokens.\n   * Used in renderer to calculate line breaks\n   **/\n  this.block    = false;\n\n  /**\n   * Token#hidden -> Boolean\n   *\n   * If it's true, ignore this element when rendering. Used for tight lists\n   * to hide paragraphs.\n   **/\n  this.hidden   = false;\n}\n\n\n/**\n * Token.attrIndex(name) -> Number\n *\n * Search attribute index by name.\n **/\nToken.prototype.attrIndex = function attrIndex(name) {\n  var attrs, i, len;\n\n  if (!this.attrs) { return -1; }\n\n  attrs = this.attrs;\n\n  for (i = 0, len = attrs.length; i < len; i++) {\n    if (attrs[i][0] === name) { return i; }\n  }\n  return -1;\n};\n\n\n/**\n * Token.attrPush(attrData)\n *\n * Add `[ name, value ]` attribute to list. Init attrs if necessary\n **/\nToken.prototype.attrPush = function attrPush(attrData) {\n  if (this.attrs) {\n    this.attrs.push(attrData);\n  } else {\n    this.attrs = [ attrData ];\n  }\n};\n\n\n/**\n * Token.attrSet(name, value)\n *\n * Set `name` attribute to `value`. Override old value if exists.\n **/\nToken.prototype.attrSet = function attrSet(name, value) {\n  var idx = this.attrIndex(name),\n      attrData = [ name, value ];\n\n  if (idx < 0) {\n    this.attrPush(attrData);\n  } else {\n    this.attrs[idx] = attrData;\n  }\n};\n\n\n/**\n * Token.attrGet(name)\n *\n * Get the value of attribute `name`, or null if it does not exist.\n **/\nToken.prototype.attrGet = function attrGet(name) {\n  var idx = this.attrIndex(name), value = null;\n  if (idx >= 0) {\n    value = this.attrs[idx][1];\n  }\n  return value;\n};\n\n\n/**\n * Token.attrJoin(name, value)\n *\n * Join value to existing attribute via space. Or create new attribute if not\n * exists. Useful to operate with token classes.\n **/\nToken.prototype.attrJoin = function attrJoin(name, value) {\n  var idx = this.attrIndex(name);\n\n  if (idx < 0) {\n    this.attrPush([ name, value ]);\n  } else {\n    this.attrs[idx][1] = this.attrs[idx][1] + ' ' + value;\n  }\n};\n\n\nmodule.exports = Token;\n","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.default = void 0;\nlet isMacOs = false;\n\nif (typeof window === 'object') {\n  isMacOs = window.navigator.platform === 'MacIntel';\n}\n\nconst commonKeys = {\n  // Persistent search box in Query Editor\n  [isMacOs ? 'Cmd-F' : 'Ctrl-F']: 'findPersistent',\n  'Cmd-G': 'findPersistent',\n  'Ctrl-G': 'findPersistent',\n  // Editor improvements\n  'Ctrl-Left': 'goSubwordLeft',\n  'Ctrl-Right': 'goSubwordRight',\n  'Alt-Left': 'goGroupLeft',\n  'Alt-Right': 'goGroupRight'\n};\nvar _default = commonKeys;\nexports.default = _default;","\"use strict\";\nvar __assign = (this && this.__assign) || function () {\n    __assign = Object.assign || function(t) {\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\n            s = arguments[i];\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))\n                t[p] = s[p];\n        }\n        return t;\n    };\n    return __assign.apply(this, arguments);\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar vscode_languageserver_types_1 = require(\"vscode-languageserver-types\");\nvar graphql_1 = require(\"graphql\");\nvar graphql_language_service_parser_1 = require(\"graphql-language-service-parser\");\nvar autocompleteUtils_1 = require(\"./autocompleteUtils\");\nfunction getAutocompleteSuggestions(schema, queryText, cursor, contextToken) {\n    var token = contextToken || getTokenAtPosition(queryText, cursor);\n    var state = token.state.kind === 'Invalid' ? token.state.prevState : token.state;\n    if (!state) {\n        return [];\n    }\n    var kind = state.kind;\n    var step = state.step;\n    var typeInfo = getTypeInfo(schema, token.state);\n    if (kind === graphql_language_service_parser_1.RuleKinds.DOCUMENT) {\n        return autocompleteUtils_1.hintList(token, [\n            { label: 'query', kind: vscode_languageserver_types_1.CompletionItemKind.Function },\n            { label: 'mutation', kind: vscode_languageserver_types_1.CompletionItemKind.Function },\n            { label: 'subscription', kind: vscode_languageserver_types_1.CompletionItemKind.Function },\n            { label: 'fragment', kind: vscode_languageserver_types_1.CompletionItemKind.Function },\n            { label: '{', kind: vscode_languageserver_types_1.CompletionItemKind.Constructor },\n        ]);\n    }\n    if (kind === graphql_language_service_parser_1.RuleKinds.SELECTION_SET ||\n        kind === graphql_language_service_parser_1.RuleKinds.FIELD ||\n        kind === graphql_language_service_parser_1.RuleKinds.ALIASED_FIELD) {\n        return getSuggestionsForFieldNames(token, typeInfo, schema, kind);\n    }\n    if (kind === graphql_language_service_parser_1.RuleKinds.ARGUMENTS ||\n        (kind === graphql_language_service_parser_1.RuleKinds.ARGUMENT && step === 0)) {\n        var argDefs = typeInfo.argDefs;\n        if (argDefs) {\n            return autocompleteUtils_1.hintList(token, argDefs.map(function (argDef) {\n                var _a;\n                return ({\n                    label: argDef.name,\n                    detail: String(argDef.type),\n                    documentation: (_a = argDef.description) !== null && _a !== void 0 ? _a : undefined,\n                    kind: vscode_languageserver_types_1.CompletionItemKind.Variable,\n                });\n            }));\n        }\n    }\n    if (kind === graphql_language_service_parser_1.RuleKinds.OBJECT_VALUE ||\n        (kind === graphql_language_service_parser_1.RuleKinds.OBJECT_FIELD && step === 0)) {\n        if (typeInfo.objectFieldDefs) {\n            var objectFields = autocompleteUtils_1.objectValues(typeInfo.objectFieldDefs);\n            var completionKind_1 = kind === graphql_language_service_parser_1.RuleKinds.OBJECT_VALUE\n                ? vscode_languageserver_types_1.CompletionItemKind.Value\n                : vscode_languageserver_types_1.CompletionItemKind.Field;\n            return autocompleteUtils_1.hintList(token, objectFields.map(function (field) {\n                var _a;\n                return ({\n                    label: field.name,\n                    detail: String(field.type),\n                    documentation: (_a = field.description) !== null && _a !== void 0 ? _a : undefined,\n                    kind: completionKind_1,\n                });\n            }));\n        }\n    }\n    if (kind === graphql_language_service_parser_1.RuleKinds.ENUM_VALUE ||\n        (kind === graphql_language_service_parser_1.RuleKinds.LIST_VALUE && step === 1) ||\n        (kind === graphql_language_service_parser_1.RuleKinds.OBJECT_FIELD && step === 2) ||\n        (kind === graphql_language_service_parser_1.RuleKinds.ARGUMENT && step === 2)) {\n        return getSuggestionsForInputValues(token, typeInfo, kind);\n    }\n    if ((kind === graphql_language_service_parser_1.RuleKinds.TYPE_CONDITION && step === 1) ||\n        (kind === graphql_language_service_parser_1.RuleKinds.NAMED_TYPE &&\n            state.prevState != null &&\n            state.prevState.kind === graphql_language_service_parser_1.RuleKinds.TYPE_CONDITION)) {\n        return getSuggestionsForFragmentTypeConditions(token, typeInfo, schema, kind);\n    }\n    if (kind === graphql_language_service_parser_1.RuleKinds.FRAGMENT_SPREAD && step === 1) {\n        return getSuggestionsForFragmentSpread(token, typeInfo, schema, queryText, kind);\n    }\n    if ((kind === graphql_language_service_parser_1.RuleKinds.VARIABLE_DEFINITION && step === 2) ||\n        (kind === graphql_language_service_parser_1.RuleKinds.LIST_TYPE && step === 1) ||\n        (kind === graphql_language_service_parser_1.RuleKinds.NAMED_TYPE &&\n            state.prevState &&\n            (state.prevState.kind === graphql_language_service_parser_1.RuleKinds.VARIABLE_DEFINITION ||\n                state.prevState.kind === graphql_language_service_parser_1.RuleKinds.LIST_TYPE))) {\n        return getSuggestionsForVariableDefinition(token, schema, kind);\n    }\n    if (kind === graphql_language_service_parser_1.RuleKinds.DIRECTIVE) {\n        return getSuggestionsForDirective(token, state, schema, kind);\n    }\n    return [];\n}\nexports.getAutocompleteSuggestions = getAutocompleteSuggestions;\nfunction getSuggestionsForFieldNames(token, typeInfo, schema, _kind) {\n    if (typeInfo.parentType) {\n        var parentType = typeInfo.parentType;\n        var fields = [];\n        if ('getFields' in parentType) {\n            fields = autocompleteUtils_1.objectValues(parentType.getFields());\n        }\n        if (graphql_1.isCompositeType(parentType)) {\n            fields.push(graphql_1.TypeNameMetaFieldDef);\n        }\n        if (parentType === schema.getQueryType()) {\n            fields.push(graphql_1.SchemaMetaFieldDef, graphql_1.TypeMetaFieldDef);\n        }\n        return autocompleteUtils_1.hintList(token, fields.map(function (field, index) {\n            var _a;\n            return ({\n                sortText: String(index) + field.name,\n                label: field.name,\n                detail: String(field.type),\n                documentation: (_a = field.description) !== null && _a !== void 0 ? _a : undefined,\n                deprecated: field.isDeprecated,\n                isDeprecated: field.isDeprecated,\n                deprecationReason: field.deprecationReason,\n                kind: vscode_languageserver_types_1.CompletionItemKind.Field,\n            });\n        }));\n    }\n    return [];\n}\nfunction getSuggestionsForInputValues(token, typeInfo, _kind) {\n    var namedInputType = graphql_1.getNamedType(typeInfo.inputType);\n    if (namedInputType instanceof graphql_1.GraphQLEnumType) {\n        var values = namedInputType.getValues();\n        return autocompleteUtils_1.hintList(token, values.map(function (value) {\n            var _a;\n            return ({\n                label: value.name,\n                detail: String(namedInputType),\n                documentation: (_a = value.description) !== null && _a !== void 0 ? _a : undefined,\n                deprecated: value.isDeprecated,\n                isDeprecated: value.isDeprecated,\n                deprecationReason: value.deprecationReason,\n                kind: vscode_languageserver_types_1.CompletionItemKind.EnumMember,\n            });\n        }));\n    }\n    else if (namedInputType === graphql_1.GraphQLBoolean) {\n        return autocompleteUtils_1.hintList(token, [\n            {\n                label: 'true',\n                detail: String(graphql_1.GraphQLBoolean),\n                documentation: 'Not false.',\n                kind: vscode_languageserver_types_1.CompletionItemKind.Variable,\n            },\n            {\n                label: 'false',\n                detail: String(graphql_1.GraphQLBoolean),\n                documentation: 'Not true.',\n                kind: vscode_languageserver_types_1.CompletionItemKind.Variable,\n            },\n        ]);\n    }\n    return [];\n}\nfunction getSuggestionsForFragmentTypeConditions(token, typeInfo, schema, _kind) {\n    var possibleTypes;\n    if (typeInfo.parentType) {\n        if (graphql_1.isAbstractType(typeInfo.parentType)) {\n            var abstractType = graphql_1.assertAbstractType(typeInfo.parentType);\n            var possibleObjTypes = schema.getPossibleTypes(abstractType);\n            var possibleIfaceMap_1 = Object.create(null);\n            possibleObjTypes.forEach(function (type) {\n                type.getInterfaces().forEach(function (iface) {\n                    possibleIfaceMap_1[iface.name] = iface;\n                });\n            });\n            possibleTypes = possibleObjTypes.concat(autocompleteUtils_1.objectValues(possibleIfaceMap_1));\n        }\n        else {\n            possibleTypes = [typeInfo.parentType];\n        }\n    }\n    else {\n        var typeMap = schema.getTypeMap();\n        possibleTypes = autocompleteUtils_1.objectValues(typeMap).filter(graphql_1.isCompositeType);\n    }\n    return autocompleteUtils_1.hintList(token, possibleTypes.map(function (type) {\n        var namedType = graphql_1.getNamedType(type);\n        return {\n            label: String(type),\n            documentation: (namedType && namedType.description) || '',\n            kind: vscode_languageserver_types_1.CompletionItemKind.Field,\n        };\n    }));\n}\nfunction getSuggestionsForFragmentSpread(token, typeInfo, schema, queryText, _kind) {\n    var typeMap = schema.getTypeMap();\n    var defState = autocompleteUtils_1.getDefinitionState(token.state);\n    var fragments = getFragmentDefinitions(queryText);\n    var relevantFrags = fragments.filter(function (frag) {\n        return typeMap[frag.typeCondition.name.value] &&\n            !(defState &&\n                defState.kind === graphql_language_service_parser_1.RuleKinds.FRAGMENT_DEFINITION &&\n                defState.name === frag.name.value) &&\n            graphql_1.isCompositeType(typeInfo.parentType) &&\n            graphql_1.isCompositeType(typeMap[frag.typeCondition.name.value]) &&\n            graphql_1.doTypesOverlap(schema, typeInfo.parentType, typeMap[frag.typeCondition.name.value]);\n    });\n    return autocompleteUtils_1.hintList(token, relevantFrags.map(function (frag) { return ({\n        label: frag.name.value,\n        detail: String(typeMap[frag.typeCondition.name.value]),\n        documentation: \"fragment \" + frag.name.value + \" on \" + frag.typeCondition.name.value,\n        kind: vscode_languageserver_types_1.CompletionItemKind.Field,\n    }); }));\n}\nfunction getFragmentDefinitions(queryText) {\n    var fragmentDefs = [];\n    runOnlineParser(queryText, function (_, state) {\n        if (state.kind === graphql_language_service_parser_1.RuleKinds.FRAGMENT_DEFINITION &&\n            state.name &&\n            state.type) {\n            fragmentDefs.push({\n                kind: graphql_language_service_parser_1.RuleKinds.FRAGMENT_DEFINITION,\n                name: {\n                    kind: 'Name',\n                    value: state.name,\n                },\n                selectionSet: {\n                    kind: graphql_language_service_parser_1.RuleKinds.SELECTION_SET,\n                    selections: [],\n                },\n                typeCondition: {\n                    kind: graphql_language_service_parser_1.RuleKinds.NAMED_TYPE,\n                    name: {\n                        kind: 'Name',\n                        value: state.type,\n                    },\n                },\n            });\n        }\n    });\n    return fragmentDefs;\n}\nexports.getFragmentDefinitions = getFragmentDefinitions;\nfunction getSuggestionsForVariableDefinition(token, schema, _kind) {\n    var inputTypeMap = schema.getTypeMap();\n    var inputTypes = autocompleteUtils_1.objectValues(inputTypeMap).filter(graphql_1.isInputType);\n    return autocompleteUtils_1.hintList(token, inputTypes.map(function (type) { return ({\n        label: type.name,\n        documentation: type.description,\n        kind: vscode_languageserver_types_1.CompletionItemKind.Variable,\n    }); }));\n}\nfunction getSuggestionsForDirective(token, state, schema, _kind) {\n    if (state.prevState && state.prevState.kind) {\n        var directives = schema\n            .getDirectives()\n            .filter(function (directive) { return canUseDirective(state.prevState, directive); });\n        return autocompleteUtils_1.hintList(token, directives.map(function (directive) { return ({\n            label: directive.name,\n            documentation: directive.description || '',\n            kind: vscode_languageserver_types_1.CompletionItemKind.Function,\n        }); }));\n    }\n    return [];\n}\nfunction getTokenAtPosition(queryText, cursor) {\n    var styleAtCursor = null;\n    var stateAtCursor = null;\n    var stringAtCursor = null;\n    var token = runOnlineParser(queryText, function (stream, state, style, index) {\n        if (index === cursor.line) {\n            if (stream.getCurrentPosition() >= cursor.character) {\n                styleAtCursor = style;\n                stateAtCursor = __assign({}, state);\n                stringAtCursor = stream.current();\n                return 'BREAK';\n            }\n        }\n    });\n    return {\n        start: token.start,\n        end: token.end,\n        string: stringAtCursor || token.string,\n        state: stateAtCursor || token.state,\n        style: styleAtCursor || token.style,\n    };\n}\nexports.getTokenAtPosition = getTokenAtPosition;\nfunction runOnlineParser(queryText, callback) {\n    var lines = queryText.split('\\n');\n    var parser = graphql_language_service_parser_1.onlineParser();\n    var state = parser.startState();\n    var style = '';\n    var stream = new graphql_language_service_parser_1.CharacterStream('');\n    for (var i = 0; i < lines.length; i++) {\n        stream = new graphql_language_service_parser_1.CharacterStream(lines[i]);\n        while (!stream.eol()) {\n            style = parser.token(stream, state);\n            var code = callback(stream, state, style, i);\n            if (code === 'BREAK') {\n                break;\n            }\n        }\n        callback(stream, state, style, i);\n        if (!state.kind) {\n            state = parser.startState();\n        }\n    }\n    return {\n        start: stream.getStartOfToken(),\n        end: stream.getCurrentPosition(),\n        string: stream.current(),\n        state: state,\n        style: style,\n    };\n}\nexports.runOnlineParser = runOnlineParser;\nfunction canUseDirective(state, directive) {\n    if (!state || !state.kind) {\n        return false;\n    }\n    var kind = state.kind;\n    var locations = directive.locations;\n    switch (kind) {\n        case graphql_language_service_parser_1.RuleKinds.QUERY:\n            return locations.indexOf('QUERY') !== -1;\n        case graphql_language_service_parser_1.RuleKinds.MUTATION:\n            return locations.indexOf('MUTATION') !== -1;\n        case graphql_language_service_parser_1.RuleKinds.SUBSCRIPTION:\n            return locations.indexOf('SUBSCRIPTION') !== -1;\n        case graphql_language_service_parser_1.RuleKinds.FIELD:\n        case graphql_language_service_parser_1.RuleKinds.ALIASED_FIELD:\n            return locations.indexOf('FIELD') !== -1;\n        case graphql_language_service_parser_1.RuleKinds.FRAGMENT_DEFINITION:\n            return locations.indexOf('FRAGMENT_DEFINITION') !== -1;\n        case graphql_language_service_parser_1.RuleKinds.FRAGMENT_SPREAD:\n            return locations.indexOf('FRAGMENT_SPREAD') !== -1;\n        case graphql_language_service_parser_1.RuleKinds.INLINE_FRAGMENT:\n            return locations.indexOf('INLINE_FRAGMENT') !== -1;\n        case graphql_language_service_parser_1.RuleKinds.SCHEMA_DEF:\n            return locations.indexOf('SCHEMA') !== -1;\n        case graphql_language_service_parser_1.RuleKinds.SCALAR_DEF:\n            return locations.indexOf('SCALAR') !== -1;\n        case graphql_language_service_parser_1.RuleKinds.OBJECT_TYPE_DEF:\n            return locations.indexOf('OBJECT') !== -1;\n        case graphql_language_service_parser_1.RuleKinds.FIELD_DEF:\n            return locations.indexOf('FIELD_DEFINITION') !== -1;\n        case graphql_language_service_parser_1.RuleKinds.INTERFACE_DEF:\n            return locations.indexOf('INTERFACE') !== -1;\n        case graphql_language_service_parser_1.RuleKinds.UNION_DEF:\n            return locations.indexOf('UNION') !== -1;\n        case graphql_language_service_parser_1.RuleKinds.ENUM_DEF:\n            return locations.indexOf('ENUM') !== -1;\n        case graphql_language_service_parser_1.RuleKinds.ENUM_VALUE:\n            return locations.indexOf('ENUM_VALUE') !== -1;\n        case graphql_language_service_parser_1.RuleKinds.INPUT_DEF:\n            return locations.indexOf('INPUT_OBJECT') !== -1;\n        case graphql_language_service_parser_1.RuleKinds.INPUT_VALUE_DEF:\n            var prevStateKind = state.prevState && state.prevState.kind;\n            switch (prevStateKind) {\n                case graphql_language_service_parser_1.RuleKinds.ARGUMENTS_DEF:\n                    return locations.indexOf('ARGUMENT_DEFINITION') !== -1;\n                case graphql_language_service_parser_1.RuleKinds.INPUT_DEF:\n                    return locations.indexOf('INPUT_FIELD_DEFINITION') !== -1;\n            }\n    }\n    return false;\n}\nexports.canUseDirective = canUseDirective;\nfunction getTypeInfo(schema, tokenState) {\n    var argDef;\n    var argDefs;\n    var directiveDef;\n    var enumValue;\n    var fieldDef;\n    var inputType;\n    var objectFieldDefs;\n    var parentType;\n    var type;\n    autocompleteUtils_1.forEachState(tokenState, function (state) {\n        switch (state.kind) {\n            case graphql_language_service_parser_1.RuleKinds.QUERY:\n            case 'ShortQuery':\n                type = schema.getQueryType();\n                break;\n            case graphql_language_service_parser_1.RuleKinds.MUTATION:\n                type = schema.getMutationType();\n                break;\n            case graphql_language_service_parser_1.RuleKinds.SUBSCRIPTION:\n                type = schema.getSubscriptionType();\n                break;\n            case graphql_language_service_parser_1.RuleKinds.INLINE_FRAGMENT:\n            case graphql_language_service_parser_1.RuleKinds.FRAGMENT_DEFINITION:\n                if (state.type) {\n                    type = schema.getType(state.type);\n                }\n                break;\n            case graphql_language_service_parser_1.RuleKinds.FIELD:\n            case graphql_language_service_parser_1.RuleKinds.ALIASED_FIELD:\n                if (!type || !state.name) {\n                    fieldDef = null;\n                }\n                else {\n                    fieldDef = parentType\n                        ? autocompleteUtils_1.getFieldDef(schema, parentType, state.name)\n                        : null;\n                    type = fieldDef ? fieldDef.type : null;\n                }\n                break;\n            case graphql_language_service_parser_1.RuleKinds.SELECTION_SET:\n                parentType = graphql_1.getNamedType(type);\n                break;\n            case graphql_language_service_parser_1.RuleKinds.DIRECTIVE:\n                directiveDef = state.name ? schema.getDirective(state.name) : null;\n                break;\n            case graphql_language_service_parser_1.RuleKinds.ARGUMENTS:\n                if (!state.prevState) {\n                    argDefs = null;\n                }\n                else {\n                    switch (state.prevState.kind) {\n                        case graphql_language_service_parser_1.RuleKinds.FIELD:\n                            argDefs = fieldDef && fieldDef.args;\n                            break;\n                        case graphql_language_service_parser_1.RuleKinds.DIRECTIVE:\n                            argDefs = directiveDef && directiveDef.args;\n                            break;\n                        case graphql_language_service_parser_1.RuleKinds.ALIASED_FIELD:\n                            var name_1 = state.prevState && state.prevState.name;\n                            if (!name_1) {\n                                argDefs = null;\n                                break;\n                            }\n                            var field = parentType\n                                ? autocompleteUtils_1.getFieldDef(schema, parentType, name_1)\n                                : null;\n                            if (!field) {\n                                argDefs = null;\n                                break;\n                            }\n                            argDefs = field.args;\n                            break;\n                        default:\n                            argDefs = null;\n                            break;\n                    }\n                }\n                break;\n            case graphql_language_service_parser_1.RuleKinds.ARGUMENT:\n                if (argDefs) {\n                    for (var i = 0; i < argDefs.length; i++) {\n                        if (argDefs[i].name === state.name) {\n                            argDef = argDefs[i];\n                            break;\n                        }\n                    }\n                }\n                inputType = argDef && argDef.type;\n                break;\n            case graphql_language_service_parser_1.RuleKinds.ENUM_VALUE:\n                var enumType = graphql_1.getNamedType(inputType);\n                enumValue =\n                    enumType instanceof graphql_1.GraphQLEnumType\n                        ? find(enumType.getValues(), function (val) { return val.value === state.name; })\n                        : null;\n                break;\n            case graphql_language_service_parser_1.RuleKinds.LIST_VALUE:\n                var nullableType = graphql_1.getNullableType(inputType);\n                inputType =\n                    nullableType instanceof graphql_1.GraphQLList ? nullableType.ofType : null;\n                break;\n            case graphql_language_service_parser_1.RuleKinds.OBJECT_VALUE:\n                var objectType = graphql_1.getNamedType(inputType);\n                objectFieldDefs =\n                    objectType instanceof graphql_1.GraphQLInputObjectType\n                        ? objectType.getFields()\n                        : null;\n                break;\n            case graphql_language_service_parser_1.RuleKinds.OBJECT_FIELD:\n                var objectField = state.name && objectFieldDefs ? objectFieldDefs[state.name] : null;\n                inputType = objectField && objectField.type;\n                break;\n            case graphql_language_service_parser_1.RuleKinds.NAMED_TYPE:\n                if (state.name) {\n                    type = schema.getType(state.name);\n                }\n                break;\n        }\n    });\n    return {\n        argDef: argDef,\n        argDefs: argDefs,\n        directiveDef: directiveDef,\n        enumValue: enumValue,\n        fieldDef: fieldDef,\n        inputType: inputType,\n        objectFieldDefs: objectFieldDefs,\n        parentType: parentType,\n        type: type,\n    };\n}\nexports.getTypeInfo = getTypeInfo;\nfunction find(array, predicate) {\n    for (var i = 0; i < array.length; i++) {\n        if (predicate(array[i])) {\n            return array[i];\n        }\n    }\n    return null;\n}\n//# sourceMappingURL=getAutocompleteSuggestions.js.map","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.default = Argument;\n\nvar _react = _interopRequireDefault(require(\"react\"));\n\nvar _propTypes = _interopRequireDefault(require(\"prop-types\"));\n\nvar _TypeLink = _interopRequireDefault(require(\"./TypeLink\"));\n\nvar _DefaultValue = _interopRequireDefault(require(\"./DefaultValue\"));\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\n/**\n *  Copyright (c) 2019 GraphQL Contributors.\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 */\nfunction Argument({\n  arg,\n  onClickType,\n  showDefaultValue\n}) {\n  return _react.default.createElement(\"span\", {\n    className: \"arg\"\n  }, _react.default.createElement(\"span\", {\n    className: \"arg-name\"\n  }, arg.name), ': ', _react.default.createElement(_TypeLink.default, {\n    type: arg.type,\n    onClick: onClickType\n  }), showDefaultValue !== false && _react.default.createElement(_DefaultValue.default, {\n    field: arg\n  }));\n}\n\nArgument.propTypes = {\n  arg: _propTypes.default.object.isRequired,\n  onClickType: _propTypes.default.func.isRequired,\n  showDefaultValue: _propTypes.default.bool\n};","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.default = void 0;\n\nvar _react = _interopRequireDefault(require(\"react\"));\n\nvar _propTypes = _interopRequireDefault(require(\"prop-types\"));\n\nvar _markdownIt = _interopRequireDefault(require(\"markdown-it\"));\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\nconst md = new _markdownIt.default();\n\nclass MarkdownContent extends _react.default.Component {\n  shouldComponentUpdate(nextProps) {\n    return this.props.markdown !== nextProps.markdown;\n  }\n\n  render() {\n    const markdown = this.props.markdown;\n\n    if (!markdown) {\n      return _react.default.createElement(\"div\", null);\n    }\n\n    return _react.default.createElement(\"div\", {\n      className: this.props.className,\n      dangerouslySetInnerHTML: {\n        __html: md.render(markdown)\n      }\n    });\n  }\n\n}\n\nexports.default = MarkdownContent;\n\n_defineProperty(MarkdownContent, \"propTypes\", {\n  markdown: _propTypes.default.string,\n  className: _propTypes.default.string\n});","// HTML5 entities map: { name -> utf16string }\n//\n'use strict';\n\n/*eslint quotes:0*/\nmodule.exports = require('entities/lib/maps/entities.json');\n","'use strict';\n\n\nmodule.exports.encode = require('./encode');\nmodule.exports.decode = require('./decode');\nmodule.exports.format = require('./format');\nmodule.exports.parse  = require('./parse');\n","module.exports=/[\\0-\\uD7FF\\uE000-\\uFFFF]|[\\uD800-\\uDBFF][\\uDC00-\\uDFFF]|[\\uD800-\\uDBFF](?![\\uDC00-\\uDFFF])|(?:[^\\uD800-\\uDBFF]|^)[\\uDC00-\\uDFFF]/","module.exports=/[\\0-\\x1F\\x7F-\\x9F]/","module.exports=/[ \\xA0\\u1680\\u2000-\\u200A\\u2028\\u2029\\u202F\\u205F\\u3000]/","// Regexps to match html elements\n\n'use strict';\n\nvar attr_name     = '[a-zA-Z_:][a-zA-Z0-9:._-]*';\n\nvar unquoted      = '[^\"\\'=<>`\\\\x00-\\\\x20]+';\nvar single_quoted = \"'[^']*'\";\nvar double_quoted = '\"[^\"]*\"';\n\nvar attr_value  = '(?:' + unquoted + '|' + single_quoted + '|' + double_quoted + ')';\n\nvar attribute   = '(?:\\\\s+' + attr_name + '(?:\\\\s*=\\\\s*' + attr_value + ')?)';\n\nvar open_tag    = '<[A-Za-z][A-Za-z0-9\\\\-]*' + attribute + '*\\\\s*\\\\/?>';\n\nvar close_tag   = '<\\\\/[A-Za-z][A-Za-z0-9\\\\-]*\\\\s*>';\nvar comment     = '<!---->|<!--(?:-?[^>-])(?:-?[^-])*-->';\nvar processing  = '<[?].*?[?]>';\nvar declaration = '<![A-Z]+\\\\s+[^>]*>';\nvar cdata       = '<!\\\\[CDATA\\\\[[\\\\s\\\\S]*?\\\\]\\\\]>';\n\nvar HTML_TAG_RE = new RegExp('^(?:' + open_tag + '|' + close_tag + '|' + comment +\n                        '|' + processing + '|' + declaration + '|' + cdata + ')');\nvar HTML_OPEN_CLOSE_TAG_RE = new RegExp('^(?:' + open_tag + '|' + close_tag + ')');\n\nmodule.exports.HTML_TAG_RE = HTML_TAG_RE;\nmodule.exports.HTML_OPEN_CLOSE_TAG_RE = HTML_OPEN_CLOSE_TAG_RE;\n","// ~~strike through~~\n//\n'use strict';\n\n\n// Insert each marker as a separate text token, and add it to delimiter list\n//\nmodule.exports.tokenize = function strikethrough(state, silent) {\n  var i, scanned, token, len, ch,\n      start = state.pos,\n      marker = state.src.charCodeAt(start);\n\n  if (silent) { return false; }\n\n  if (marker !== 0x7E/* ~ */) { return false; }\n\n  scanned = state.scanDelims(state.pos, true);\n  len = scanned.length;\n  ch = String.fromCharCode(marker);\n\n  if (len < 2) { return false; }\n\n  if (len % 2) {\n    token         = state.push('text', '', 0);\n    token.content = ch;\n    len--;\n  }\n\n  for (i = 0; i < len; i += 2) {\n    token         = state.push('text', '', 0);\n    token.content = ch + ch;\n\n    state.delimiters.push({\n      marker: marker,\n      length: 0, // disable \"rule of 3\" length checks meant for emphasis\n      jump:   i,\n      token:  state.tokens.length - 1,\n      end:    -1,\n      open:   scanned.can_open,\n      close:  scanned.can_close\n    });\n  }\n\n  state.pos += scanned.length;\n\n  return true;\n};\n\n\nfunction postProcess(state, delimiters) {\n  var i, j,\n      startDelim,\n      endDelim,\n      token,\n      loneMarkers = [],\n      max = delimiters.length;\n\n  for (i = 0; i < max; i++) {\n    startDelim = delimiters[i];\n\n    if (startDelim.marker !== 0x7E/* ~ */) {\n      continue;\n    }\n\n    if (startDelim.end === -1) {\n      continue;\n    }\n\n    endDelim = delimiters[startDelim.end];\n\n    token         = state.tokens[startDelim.token];\n    token.type    = 's_open';\n    token.tag     = 's';\n    token.nesting = 1;\n    token.markup  = '~~';\n    token.content = '';\n\n    token         = state.tokens[endDelim.token];\n    token.type    = 's_close';\n    token.tag     = 's';\n    token.nesting = -1;\n    token.markup  = '~~';\n    token.content = '';\n\n    if (state.tokens[endDelim.token - 1].type === 'text' &&\n        state.tokens[endDelim.token - 1].content === '~') {\n\n      loneMarkers.push(endDelim.token - 1);\n    }\n  }\n\n  // If a marker sequence has an odd number of characters, it's splitted\n  // like this: `~~~~~` -> `~` + `~~` + `~~`, leaving one marker at the\n  // start of the sequence.\n  //\n  // So, we have to move all those markers after subsequent s_close tags.\n  //\n  while (loneMarkers.length) {\n    i = loneMarkers.pop();\n    j = i + 1;\n\n    while (j < state.tokens.length && state.tokens[j].type === 's_close') {\n      j++;\n    }\n\n    j--;\n\n    if (i !== j) {\n      token = state.tokens[j];\n      state.tokens[j] = state.tokens[i];\n      state.tokens[i] = token;\n    }\n  }\n}\n\n\n// Walk through delimiter list and replace text tokens with tags\n//\nmodule.exports.postProcess = function strikethrough(state) {\n  var curr,\n      tokens_meta = state.tokens_meta,\n      max = state.tokens_meta.length;\n\n  postProcess(state, state.delimiters);\n\n  for (curr = 0; curr < max; curr++) {\n    if (tokens_meta[curr] && tokens_meta[curr].delimiters) {\n      postProcess(state, tokens_meta[curr].delimiters);\n    }\n  }\n};\n","// Process *this* and _that_\n//\n'use strict';\n\n\n// Insert each marker as a separate text token, and add it to delimiter list\n//\nmodule.exports.tokenize = function emphasis(state, silent) {\n  var i, scanned, token,\n      start = state.pos,\n      marker = state.src.charCodeAt(start);\n\n  if (silent) { return false; }\n\n  if (marker !== 0x5F /* _ */ && marker !== 0x2A /* * */) { return false; }\n\n  scanned = state.scanDelims(state.pos, marker === 0x2A);\n\n  for (i = 0; i < scanned.length; i++) {\n    token         = state.push('text', '', 0);\n    token.content = String.fromCharCode(marker);\n\n    state.delimiters.push({\n      // Char code of the starting marker (number).\n      //\n      marker: marker,\n\n      // Total length of these series of delimiters.\n      //\n      length: scanned.length,\n\n      // An amount of characters before this one that's equivalent to\n      // current one. In plain English: if this delimiter does not open\n      // an emphasis, neither do previous `jump` characters.\n      //\n      // Used to skip sequences like \"*****\" in one step, for 1st asterisk\n      // value will be 0, for 2nd it's 1 and so on.\n      //\n      jump:   i,\n\n      // A position of the token this delimiter corresponds to.\n      //\n      token:  state.tokens.length - 1,\n\n      // If this delimiter is matched as a valid opener, `end` will be\n      // equal to its position, otherwise it's `-1`.\n      //\n      end:    -1,\n\n      // Boolean flags that determine if this delimiter could open or close\n      // an emphasis.\n      //\n      open:   scanned.can_open,\n      close:  scanned.can_close\n    });\n  }\n\n  state.pos += scanned.length;\n\n  return true;\n};\n\n\nfunction postProcess(state, delimiters) {\n  var i,\n      startDelim,\n      endDelim,\n      token,\n      ch,\n      isStrong,\n      max = delimiters.length;\n\n  for (i = max - 1; i >= 0; i--) {\n    startDelim = delimiters[i];\n\n    if (startDelim.marker !== 0x5F/* _ */ && startDelim.marker !== 0x2A/* * */) {\n      continue;\n    }\n\n    // Process only opening markers\n    if (startDelim.end === -1) {\n      continue;\n    }\n\n    endDelim = delimiters[startDelim.end];\n\n    // If the previous delimiter has the same marker and is adjacent to this one,\n    // merge those into one strong delimiter.\n    //\n    // `<em><em>whatever</em></em>` -> `<strong>whatever</strong>`\n    //\n    isStrong = i > 0 &&\n               delimiters[i - 1].end === startDelim.end + 1 &&\n               delimiters[i - 1].token === startDelim.token - 1 &&\n               delimiters[startDelim.end + 1].token === endDelim.token + 1 &&\n               delimiters[i - 1].marker === startDelim.marker;\n\n    ch = String.fromCharCode(startDelim.marker);\n\n    token         = state.tokens[startDelim.token];\n    token.type    = isStrong ? 'strong_open' : 'em_open';\n    token.tag     = isStrong ? 'strong' : 'em';\n    token.nesting = 1;\n    token.markup  = isStrong ? ch + ch : ch;\n    token.content = '';\n\n    token         = state.tokens[endDelim.token];\n    token.type    = isStrong ? 'strong_close' : 'em_close';\n    token.tag     = isStrong ? 'strong' : 'em';\n    token.nesting = -1;\n    token.markup  = isStrong ? ch + ch : ch;\n    token.content = '';\n\n    if (isStrong) {\n      state.tokens[delimiters[i - 1].token].content = '';\n      state.tokens[delimiters[startDelim.end + 1].token].content = '';\n      i--;\n    }\n  }\n}\n\n\n// Walk through delimiter list and replace text tokens with tags\n//\nmodule.exports.postProcess = function emphasis(state) {\n  var curr,\n      tokens_meta = state.tokens_meta,\n      max = state.tokens_meta.length;\n\n  postProcess(state, state.delimiters);\n\n  for (curr = 0; curr < max; curr++) {\n    if (tokens_meta[curr] && tokens_meta[curr].delimiters) {\n      postProcess(state, tokens_meta[curr].delimiters);\n    }\n  }\n};\n","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.default = onHasCompletion;\n\nvar _graphql = require(\"graphql\");\n\nvar _markdownIt = _interopRequireDefault(require(\"markdown-it\"));\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\n/**\n *  Copyright (c) 2019 GraphQL Contributors.\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 */\nconst md = new _markdownIt.default();\n/**\n * Render a custom UI for CodeMirror's hint which includes additional info\n * about the type and description for the selected context.\n */\n\nfunction onHasCompletion(cm, data, onHintInformationRender) {\n  const CodeMirror = require('codemirror');\n\n  let information;\n  let deprecation; // When a hint result is selected, we augment the UI with information.\n\n  CodeMirror.on(data, 'select', (ctx, el) => {\n    // Only the first time (usually when the hint UI is first displayed)\n    // do we create the information nodes.\n    if (!information) {\n      const hintsUl = el.parentNode; // This \"information\" node will contain the additional info about the\n      // highlighted typeahead option.\n\n      information = document.createElement('div');\n      information.className = 'CodeMirror-hint-information';\n      hintsUl.appendChild(information); // This \"deprecation\" node will contain info about deprecated usage.\n\n      deprecation = document.createElement('div');\n      deprecation.className = 'CodeMirror-hint-deprecation';\n      hintsUl.appendChild(deprecation); // When CodeMirror attempts to remove the hint UI, we detect that it was\n      // removed and in turn remove the information nodes.\n\n      let onRemoveFn;\n      hintsUl.addEventListener('DOMNodeRemoved', onRemoveFn = event => {\n        if (event.target === hintsUl) {\n          hintsUl.removeEventListener('DOMNodeRemoved', onRemoveFn);\n          information = null;\n          deprecation = null;\n          onRemoveFn = null;\n        }\n      });\n    } // Now that the UI has been set up, add info to information.\n\n\n    const description = ctx.description ? md.render(ctx.description) : 'Self descriptive.';\n    const type = ctx.type ? '<span class=\"infoType\">' + renderType(ctx.type) + '</span>' : '';\n    information.innerHTML = '<div class=\"content\">' + (description.slice(0, 3) === '<p>' ? '<p>' + type + description.slice(3) : type + description) + '</div>';\n\n    if (ctx.isDeprecated) {\n      const reason = ctx.deprecationReason ? md.render(ctx.deprecationReason) : '';\n      deprecation.innerHTML = '<span class=\"deprecation-label\">Deprecated</span>' + reason;\n      deprecation.style.display = 'block';\n    } else {\n      deprecation.style.display = 'none';\n    } // Additional rendering?\n\n\n    if (onHintInformationRender) {\n      onHintInformationRender(information);\n    }\n  });\n}\n\nfunction renderType(type) {\n  if (type instanceof _graphql.GraphQLNonNull) {\n    return `${renderType(type.ofType)}!`;\n  }\n\n  if (type instanceof _graphql.GraphQLList) {\n    return `[${renderType(type.ofType)}]`;\n  }\n\n  return `<a class=\"typeName\">${type.name}</a>`;\n}","\"use strict\";\nfunction __export(m) {\n    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];\n}\nObject.defineProperty(exports, \"__esModule\", { value: true });\n__export(require(\"./autocompleteUtils\"));\n__export(require(\"./getAutocompleteSuggestions\"));\n__export(require(\"./getDefinition\"));\n__export(require(\"./getDiagnostics\"));\nvar getOutline_1 = require(\"./getOutline\");\nexports.getOutline = getOutline_1.getOutline;\nvar getHoverInformation_1 = require(\"./getHoverInformation\");\nexports.getHoverInformation = getHoverInformation_1.getHoverInformation;\n__export(require(\"./GraphQLLanguageService\"));\n//# sourceMappingURL=index.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar graphql_1 = require(\"graphql\");\nvar introspection_1 = require(\"graphql/type/introspection\");\nfunction getDefinitionState(tokenState) {\n    var definitionState;\n    forEachState(tokenState, function (state) {\n        switch (state.kind) {\n            case 'Query':\n            case 'ShortQuery':\n            case 'Mutation':\n            case 'Subscription':\n            case 'FragmentDefinition':\n                definitionState = state;\n                break;\n        }\n    });\n    return definitionState;\n}\nexports.getDefinitionState = getDefinitionState;\nfunction getFieldDef(schema, type, fieldName) {\n    if (fieldName === introspection_1.SchemaMetaFieldDef.name && schema.getQueryType() === type) {\n        return introspection_1.SchemaMetaFieldDef;\n    }\n    if (fieldName === introspection_1.TypeMetaFieldDef.name && schema.getQueryType() === type) {\n        return introspection_1.TypeMetaFieldDef;\n    }\n    if (fieldName === introspection_1.TypeNameMetaFieldDef.name && graphql_1.isCompositeType(type)) {\n        return introspection_1.TypeNameMetaFieldDef;\n    }\n    if ('getFields' in type) {\n        return type.getFields()[fieldName];\n    }\n    return null;\n}\nexports.getFieldDef = getFieldDef;\nfunction forEachState(stack, fn) {\n    var reverseStateStack = [];\n    var state = stack;\n    while (state && state.kind) {\n        reverseStateStack.push(state);\n        state = state.prevState;\n    }\n    for (var i = reverseStateStack.length - 1; i >= 0; i--) {\n        fn(reverseStateStack[i]);\n    }\n}\nexports.forEachState = forEachState;\nfunction objectValues(object) {\n    var keys = Object.keys(object);\n    var len = keys.length;\n    var values = new Array(len);\n    for (var i = 0; i < len; ++i) {\n        values[i] = object[keys[i]];\n    }\n    return values;\n}\nexports.objectValues = objectValues;\nfunction hintList(token, list) {\n    return filterAndSortList(list, normalizeText(token.string));\n}\nexports.hintList = hintList;\nfunction filterAndSortList(list, text) {\n    if (!text) {\n        return filterNonEmpty(list, function (entry) { return !entry.isDeprecated; });\n    }\n    var byProximity = list.map(function (entry) { return ({\n        proximity: getProximity(normalizeText(entry.label), text),\n        entry: entry,\n    }); });\n    var conciseMatches = filterNonEmpty(filterNonEmpty(byProximity, function (pair) { return pair.proximity <= 2; }), function (pair) { return !pair.entry.isDeprecated; });\n    var sortedMatches = conciseMatches.sort(function (a, b) {\n        return (a.entry.isDeprecated ? 1 : 0) - (b.entry.isDeprecated ? 1 : 0) ||\n            a.proximity - b.proximity ||\n            a.entry.label.length - b.entry.label.length;\n    });\n    return sortedMatches.map(function (pair) { return pair.entry; });\n}\nfunction filterNonEmpty(array, predicate) {\n    var filtered = array.filter(predicate);\n    return filtered.length === 0 ? array : filtered;\n}\nfunction normalizeText(text) {\n    return text.toLowerCase().replace(/\\W/g, '');\n}\nfunction getProximity(suggestion, text) {\n    var proximity = lexicalDistance(text, suggestion);\n    if (suggestion.length > text.length) {\n        proximity -= suggestion.length - text.length - 1;\n        proximity += suggestion.indexOf(text) === 0 ? 0 : 0.5;\n    }\n    return proximity;\n}\nfunction lexicalDistance(a, b) {\n    var i;\n    var j;\n    var d = [];\n    var aLength = a.length;\n    var bLength = b.length;\n    for (i = 0; i <= aLength; i++) {\n        d[i] = [i];\n    }\n    for (j = 1; j <= bLength; j++) {\n        d[0][j] = j;\n    }\n    for (i = 1; i <= aLength; i++) {\n        for (j = 1; j <= bLength; j++) {\n            var cost = a[i - 1] === b[j - 1] ? 0 : 1;\n            d[i][j] = Math.min(d[i - 1][j] + 1, d[i][j - 1] + 1, d[i - 1][j - 1] + cost);\n            if (i > 1 && j > 1 && a[i - 1] === b[j - 2] && a[i - 2] === b[j - 1]) {\n                d[i][j] = Math.min(d[i][j], d[i - 2][j - 2] + cost);\n            }\n        }\n    }\n    return d[aLength][bLength];\n}\n//# sourceMappingURL=autocompleteUtils.js.map","(function (factory) {\r\n    if (typeof module === \"object\" && typeof module.exports === \"object\") {\r\n        var v = factory(require, exports);\r\n        if (v !== undefined) module.exports = v;\r\n    }\r\n    else if (typeof define === \"function\" && define.amd) {\r\n        define([\"require\", \"exports\"], factory);\r\n    }\r\n})(function (require, exports) {\r\n    /* --------------------------------------------------------------------------------------------\r\n     * Copyright (c) Microsoft Corporation. All rights reserved.\r\n     * Licensed under the MIT License. See License.txt in the project root for license information.\r\n     * ------------------------------------------------------------------------------------------ */\r\n    'use strict';\r\n    Object.defineProperty(exports, \"__esModule\", { value: true });\r\n    /**\r\n     * The Position namespace provides helper functions to work with\r\n     * [Position](#Position) literals.\r\n     */\r\n    var Position;\r\n    (function (Position) {\r\n        /**\r\n         * Creates a new Position literal from the given line and character.\r\n         * @param line The position's line.\r\n         * @param character The position's character.\r\n         */\r\n        function create(line, character) {\r\n            return { line: line, character: character };\r\n        }\r\n        Position.create = create;\r\n        /**\r\n         * Checks whether the given liternal conforms to the [Position](#Position) interface.\r\n         */\r\n        function is(value) {\r\n            var candidate = value;\r\n            return Is.objectLiteral(candidate) && Is.number(candidate.line) && Is.number(candidate.character);\r\n        }\r\n        Position.is = is;\r\n    })(Position = exports.Position || (exports.Position = {}));\r\n    /**\r\n     * The Range namespace provides helper functions to work with\r\n     * [Range](#Range) literals.\r\n     */\r\n    var Range;\r\n    (function (Range) {\r\n        function create(one, two, three, four) {\r\n            if (Is.number(one) && Is.number(two) && Is.number(three) && Is.number(four)) {\r\n                return { start: Position.create(one, two), end: Position.create(three, four) };\r\n            }\r\n            else if (Position.is(one) && Position.is(two)) {\r\n                return { start: one, end: two };\r\n            }\r\n            else {\r\n                throw new Error(\"Range#create called with invalid arguments[\" + one + \", \" + two + \", \" + three + \", \" + four + \"]\");\r\n            }\r\n        }\r\n        Range.create = create;\r\n        /**\r\n         * Checks whether the given literal conforms to the [Range](#Range) interface.\r\n         */\r\n        function is(value) {\r\n            var candidate = value;\r\n            return Is.objectLiteral(candidate) && Position.is(candidate.start) && Position.is(candidate.end);\r\n        }\r\n        Range.is = is;\r\n    })(Range = exports.Range || (exports.Range = {}));\r\n    /**\r\n     * The Location namespace provides helper functions to work with\r\n     * [Location](#Location) literals.\r\n     */\r\n    var Location;\r\n    (function (Location) {\r\n        /**\r\n         * Creates a Location literal.\r\n         * @param uri The location's uri.\r\n         * @param range The location's range.\r\n         */\r\n        function create(uri, range) {\r\n            return { uri: uri, range: range };\r\n        }\r\n        Location.create = create;\r\n        /**\r\n         * Checks whether the given literal conforms to the [Location](#Location) interface.\r\n         */\r\n        function is(value) {\r\n            var candidate = value;\r\n            return Is.defined(candidate) && Range.is(candidate.range) && (Is.string(candidate.uri) || Is.undefined(candidate.uri));\r\n        }\r\n        Location.is = is;\r\n    })(Location = exports.Location || (exports.Location = {}));\r\n    /**\r\n     * The LocationLink namespace provides helper functions to work with\r\n     * [LocationLink](#LocationLink) literals.\r\n     */\r\n    var LocationLink;\r\n    (function (LocationLink) {\r\n        /**\r\n         * Creates a LocationLink literal.\r\n         * @param targetUri The definition's uri.\r\n         * @param targetRange The full range of the definition.\r\n         * @param targetSelectionRange The span of the symbol definition at the target.\r\n         * @param originSelectionRange The span of the symbol being defined in the originating source file.\r\n         */\r\n        function create(targetUri, targetRange, targetSelectionRange, originSelectionRange) {\r\n            return { targetUri: targetUri, targetRange: targetRange, targetSelectionRange: targetSelectionRange, originSelectionRange: originSelectionRange };\r\n        }\r\n        LocationLink.create = create;\r\n        /**\r\n         * Checks whether the given literal conforms to the [LocationLink](#LocationLink) interface.\r\n         */\r\n        function is(value) {\r\n            var candidate = value;\r\n            return Is.defined(candidate) && Range.is(candidate.targetRange) && Is.string(candidate.targetUri)\r\n                && (Range.is(candidate.targetSelectionRange) || Is.undefined(candidate.targetSelectionRange))\r\n                && (Range.is(candidate.originSelectionRange) || Is.undefined(candidate.originSelectionRange));\r\n        }\r\n        LocationLink.is = is;\r\n    })(LocationLink = exports.LocationLink || (exports.LocationLink = {}));\r\n    /**\r\n     * The Color namespace provides helper functions to work with\r\n     * [Color](#Color) literals.\r\n     */\r\n    var Color;\r\n    (function (Color) {\r\n        /**\r\n         * Creates a new Color literal.\r\n         */\r\n        function create(red, green, blue, alpha) {\r\n            return {\r\n                red: red,\r\n                green: green,\r\n                blue: blue,\r\n                alpha: alpha,\r\n            };\r\n        }\r\n        Color.create = create;\r\n        /**\r\n         * Checks whether the given literal conforms to the [Color](#Color) interface.\r\n         */\r\n        function is(value) {\r\n            var candidate = value;\r\n            return Is.number(candidate.red)\r\n                && Is.number(candidate.green)\r\n                && Is.number(candidate.blue)\r\n                && Is.number(candidate.alpha);\r\n        }\r\n        Color.is = is;\r\n    })(Color = exports.Color || (exports.Color = {}));\r\n    /**\r\n     * The ColorInformation namespace provides helper functions to work with\r\n     * [ColorInformation](#ColorInformation) literals.\r\n     */\r\n    var ColorInformation;\r\n    (function (ColorInformation) {\r\n        /**\r\n         * Creates a new ColorInformation literal.\r\n         */\r\n        function create(range, color) {\r\n            return {\r\n                range: range,\r\n                color: color,\r\n            };\r\n        }\r\n        ColorInformation.create = create;\r\n        /**\r\n         * Checks whether the given literal conforms to the [ColorInformation](#ColorInformation) interface.\r\n         */\r\n        function is(value) {\r\n            var candidate = value;\r\n            return Range.is(candidate.range) && Color.is(candidate.color);\r\n        }\r\n        ColorInformation.is = is;\r\n    })(ColorInformation = exports.ColorInformation || (exports.ColorInformation = {}));\r\n    /**\r\n     * The Color namespace provides helper functions to work with\r\n     * [ColorPresentation](#ColorPresentation) literals.\r\n     */\r\n    var ColorPresentation;\r\n    (function (ColorPresentation) {\r\n        /**\r\n         * Creates a new ColorInformation literal.\r\n         */\r\n        function create(label, textEdit, additionalTextEdits) {\r\n            return {\r\n                label: label,\r\n                textEdit: textEdit,\r\n                additionalTextEdits: additionalTextEdits,\r\n            };\r\n        }\r\n        ColorPresentation.create = create;\r\n        /**\r\n         * Checks whether the given literal conforms to the [ColorInformation](#ColorInformation) interface.\r\n         */\r\n        function is(value) {\r\n            var candidate = value;\r\n            return Is.string(candidate.label)\r\n                && (Is.undefined(candidate.textEdit) || TextEdit.is(candidate))\r\n                && (Is.undefined(candidate.additionalTextEdits) || Is.typedArray(candidate.additionalTextEdits, TextEdit.is));\r\n        }\r\n        ColorPresentation.is = is;\r\n    })(ColorPresentation = exports.ColorPresentation || (exports.ColorPresentation = {}));\r\n    /**\r\n     * Enum of known range kinds\r\n     */\r\n    var FoldingRangeKind;\r\n    (function (FoldingRangeKind) {\r\n        /**\r\n         * Folding range for a comment\r\n         */\r\n        FoldingRangeKind[\"Comment\"] = \"comment\";\r\n        /**\r\n         * Folding range for a imports or includes\r\n         */\r\n        FoldingRangeKind[\"Imports\"] = \"imports\";\r\n        /**\r\n         * Folding range for a region (e.g. `#region`)\r\n         */\r\n        FoldingRangeKind[\"Region\"] = \"region\";\r\n    })(FoldingRangeKind = exports.FoldingRangeKind || (exports.FoldingRangeKind = {}));\r\n    /**\r\n     * The folding range namespace provides helper functions to work with\r\n     * [FoldingRange](#FoldingRange) literals.\r\n     */\r\n    var FoldingRange;\r\n    (function (FoldingRange) {\r\n        /**\r\n         * Creates a new FoldingRange literal.\r\n         */\r\n        function create(startLine, endLine, startCharacter, endCharacter, kind) {\r\n            var result = {\r\n                startLine: startLine,\r\n                endLine: endLine\r\n            };\r\n            if (Is.defined(startCharacter)) {\r\n                result.startCharacter = startCharacter;\r\n            }\r\n            if (Is.defined(endCharacter)) {\r\n                result.endCharacter = endCharacter;\r\n            }\r\n            if (Is.defined(kind)) {\r\n                result.kind = kind;\r\n            }\r\n            return result;\r\n        }\r\n        FoldingRange.create = create;\r\n        /**\r\n         * Checks whether the given literal conforms to the [FoldingRange](#FoldingRange) interface.\r\n         */\r\n        function is(value) {\r\n            var candidate = value;\r\n            return Is.number(candidate.startLine) && Is.number(candidate.startLine)\r\n                && (Is.undefined(candidate.startCharacter) || Is.number(candidate.startCharacter))\r\n                && (Is.undefined(candidate.endCharacter) || Is.number(candidate.endCharacter))\r\n                && (Is.undefined(candidate.kind) || Is.string(candidate.kind));\r\n        }\r\n        FoldingRange.is = is;\r\n    })(FoldingRange = exports.FoldingRange || (exports.FoldingRange = {}));\r\n    /**\r\n     * The DiagnosticRelatedInformation namespace provides helper functions to work with\r\n     * [DiagnosticRelatedInformation](#DiagnosticRelatedInformation) literals.\r\n     */\r\n    var DiagnosticRelatedInformation;\r\n    (function (DiagnosticRelatedInformation) {\r\n        /**\r\n         * Creates a new DiagnosticRelatedInformation literal.\r\n         */\r\n        function create(location, message) {\r\n            return {\r\n                location: location,\r\n                message: message\r\n            };\r\n        }\r\n        DiagnosticRelatedInformation.create = create;\r\n        /**\r\n         * Checks whether the given literal conforms to the [DiagnosticRelatedInformation](#DiagnosticRelatedInformation) interface.\r\n         */\r\n        function is(value) {\r\n            var candidate = value;\r\n            return Is.defined(candidate) && Location.is(candidate.location) && Is.string(candidate.message);\r\n        }\r\n        DiagnosticRelatedInformation.is = is;\r\n    })(DiagnosticRelatedInformation = exports.DiagnosticRelatedInformation || (exports.DiagnosticRelatedInformation = {}));\r\n    /**\r\n     * The diagnostic's severity.\r\n     */\r\n    var DiagnosticSeverity;\r\n    (function (DiagnosticSeverity) {\r\n        /**\r\n         * Reports an error.\r\n         */\r\n        DiagnosticSeverity.Error = 1;\r\n        /**\r\n         * Reports a warning.\r\n         */\r\n        DiagnosticSeverity.Warning = 2;\r\n        /**\r\n         * Reports an information.\r\n         */\r\n        DiagnosticSeverity.Information = 3;\r\n        /**\r\n         * Reports a hint.\r\n         */\r\n        DiagnosticSeverity.Hint = 4;\r\n    })(DiagnosticSeverity = exports.DiagnosticSeverity || (exports.DiagnosticSeverity = {}));\r\n    /**\r\n     * The diagnostic tags.\r\n     *\r\n     * @since 3.15.0\r\n     */\r\n    var DiagnosticTag;\r\n    (function (DiagnosticTag) {\r\n        /**\r\n         * Unused or unnecessary code.\r\n         *\r\n         * Clients are allowed to render diagnostics with this tag faded out instead of having\r\n         * an error squiggle.\r\n         */\r\n        DiagnosticTag.Unnecessary = 1;\r\n        /**\r\n         * Deprecated or obsolete code.\r\n         *\r\n         * Clients are allowed to rendered diagnostics with this tag strike through.\r\n         */\r\n        DiagnosticTag.Deprecated = 2;\r\n    })(DiagnosticTag = exports.DiagnosticTag || (exports.DiagnosticTag = {}));\r\n    /**\r\n     * The Diagnostic namespace provides helper functions to work with\r\n     * [Diagnostic](#Diagnostic) literals.\r\n     */\r\n    var Diagnostic;\r\n    (function (Diagnostic) {\r\n        /**\r\n         * Creates a new Diagnostic literal.\r\n         */\r\n        function create(range, message, severity, code, source, relatedInformation) {\r\n            var result = { range: range, message: message };\r\n            if (Is.defined(severity)) {\r\n                result.severity = severity;\r\n            }\r\n            if (Is.defined(code)) {\r\n                result.code = code;\r\n            }\r\n            if (Is.defined(source)) {\r\n                result.source = source;\r\n            }\r\n            if (Is.defined(relatedInformation)) {\r\n                result.relatedInformation = relatedInformation;\r\n            }\r\n            return result;\r\n        }\r\n        Diagnostic.create = create;\r\n        /**\r\n         * Checks whether the given literal conforms to the [Diagnostic](#Diagnostic) interface.\r\n         */\r\n        function is(value) {\r\n            var candidate = value;\r\n            return Is.defined(candidate)\r\n                && Range.is(candidate.range)\r\n                && Is.string(candidate.message)\r\n                && (Is.number(candidate.severity) || Is.undefined(candidate.severity))\r\n                && (Is.number(candidate.code) || Is.string(candidate.code) || Is.undefined(candidate.code))\r\n                && (Is.string(candidate.source) || Is.undefined(candidate.source))\r\n                && (Is.undefined(candidate.relatedInformation) || Is.typedArray(candidate.relatedInformation, DiagnosticRelatedInformation.is));\r\n        }\r\n        Diagnostic.is = is;\r\n    })(Diagnostic = exports.Diagnostic || (exports.Diagnostic = {}));\r\n    /**\r\n     * The Command namespace provides helper functions to work with\r\n     * [Command](#Command) literals.\r\n     */\r\n    var Command;\r\n    (function (Command) {\r\n        /**\r\n         * Creates a new Command literal.\r\n         */\r\n        function create(title, command) {\r\n            var args = [];\r\n            for (var _i = 2; _i < arguments.length; _i++) {\r\n                args[_i - 2] = arguments[_i];\r\n            }\r\n            var result = { title: title, command: command };\r\n            if (Is.defined(args) && args.length > 0) {\r\n                result.arguments = args;\r\n            }\r\n            return result;\r\n        }\r\n        Command.create = create;\r\n        /**\r\n         * Checks whether the given literal conforms to the [Command](#Command) interface.\r\n         */\r\n        function is(value) {\r\n            var candidate = value;\r\n            return Is.defined(candidate) && Is.string(candidate.title) && Is.string(candidate.command);\r\n        }\r\n        Command.is = is;\r\n    })(Command = exports.Command || (exports.Command = {}));\r\n    /**\r\n     * The TextEdit namespace provides helper function to create replace,\r\n     * insert and delete edits more easily.\r\n     */\r\n    var TextEdit;\r\n    (function (TextEdit) {\r\n        /**\r\n         * Creates a replace text edit.\r\n         * @param range The range of text to be replaced.\r\n         * @param newText The new text.\r\n         */\r\n        function replace(range, newText) {\r\n            return { range: range, newText: newText };\r\n        }\r\n        TextEdit.replace = replace;\r\n        /**\r\n         * Creates a insert text edit.\r\n         * @param position The position to insert the text at.\r\n         * @param newText The text to be inserted.\r\n         */\r\n        function insert(position, newText) {\r\n            return { range: { start: position, end: position }, newText: newText };\r\n        }\r\n        TextEdit.insert = insert;\r\n        /**\r\n         * Creates a delete text edit.\r\n         * @param range The range of text to be deleted.\r\n         */\r\n        function del(range) {\r\n            return { range: range, newText: '' };\r\n        }\r\n        TextEdit.del = del;\r\n        function is(value) {\r\n            var candidate = value;\r\n            return Is.objectLiteral(candidate)\r\n                && Is.string(candidate.newText)\r\n                && Range.is(candidate.range);\r\n        }\r\n        TextEdit.is = is;\r\n    })(TextEdit = exports.TextEdit || (exports.TextEdit = {}));\r\n    /**\r\n     * The TextDocumentEdit namespace provides helper function to create\r\n     * an edit that manipulates a text document.\r\n     */\r\n    var TextDocumentEdit;\r\n    (function (TextDocumentEdit) {\r\n        /**\r\n         * Creates a new `TextDocumentEdit`\r\n         */\r\n        function create(textDocument, edits) {\r\n            return { textDocument: textDocument, edits: edits };\r\n        }\r\n        TextDocumentEdit.create = create;\r\n        function is(value) {\r\n            var candidate = value;\r\n            return Is.defined(candidate)\r\n                && VersionedTextDocumentIdentifier.is(candidate.textDocument)\r\n                && Array.isArray(candidate.edits);\r\n        }\r\n        TextDocumentEdit.is = is;\r\n    })(TextDocumentEdit = exports.TextDocumentEdit || (exports.TextDocumentEdit = {}));\r\n    var CreateFile;\r\n    (function (CreateFile) {\r\n        function create(uri, options) {\r\n            var result = {\r\n                kind: 'create',\r\n                uri: uri\r\n            };\r\n            if (options !== void 0 && (options.overwrite !== void 0 || options.ignoreIfExists !== void 0)) {\r\n                result.options = options;\r\n            }\r\n            return result;\r\n        }\r\n        CreateFile.create = create;\r\n        function is(value) {\r\n            var candidate = value;\r\n            return candidate && candidate.kind === 'create' && Is.string(candidate.uri) &&\r\n                (candidate.options === void 0 ||\r\n                    ((candidate.options.overwrite === void 0 || Is.boolean(candidate.options.overwrite)) && (candidate.options.ignoreIfExists === void 0 || Is.boolean(candidate.options.ignoreIfExists))));\r\n        }\r\n        CreateFile.is = is;\r\n    })(CreateFile = exports.CreateFile || (exports.CreateFile = {}));\r\n    var RenameFile;\r\n    (function (RenameFile) {\r\n        function create(oldUri, newUri, options) {\r\n            var result = {\r\n                kind: 'rename',\r\n                oldUri: oldUri,\r\n                newUri: newUri\r\n            };\r\n            if (options !== void 0 && (options.overwrite !== void 0 || options.ignoreIfExists !== void 0)) {\r\n                result.options = options;\r\n            }\r\n            return result;\r\n        }\r\n        RenameFile.create = create;\r\n        function is(value) {\r\n            var candidate = value;\r\n            return candidate && candidate.kind === 'rename' && Is.string(candidate.oldUri) && Is.string(candidate.newUri) &&\r\n                (candidate.options === void 0 ||\r\n                    ((candidate.options.overwrite === void 0 || Is.boolean(candidate.options.overwrite)) && (candidate.options.ignoreIfExists === void 0 || Is.boolean(candidate.options.ignoreIfExists))));\r\n        }\r\n        RenameFile.is = is;\r\n    })(RenameFile = exports.RenameFile || (exports.RenameFile = {}));\r\n    var DeleteFile;\r\n    (function (DeleteFile) {\r\n        function create(uri, options) {\r\n            var result = {\r\n                kind: 'delete',\r\n                uri: uri\r\n            };\r\n            if (options !== void 0 && (options.recursive !== void 0 || options.ignoreIfNotExists !== void 0)) {\r\n                result.options = options;\r\n            }\r\n            return result;\r\n        }\r\n        DeleteFile.create = create;\r\n        function is(value) {\r\n            var candidate = value;\r\n            return candidate && candidate.kind === 'delete' && Is.string(candidate.uri) &&\r\n                (candidate.options === void 0 ||\r\n                    ((candidate.options.recursive === void 0 || Is.boolean(candidate.options.recursive)) && (candidate.options.ignoreIfNotExists === void 0 || Is.boolean(candidate.options.ignoreIfNotExists))));\r\n        }\r\n        DeleteFile.is = is;\r\n    })(DeleteFile = exports.DeleteFile || (exports.DeleteFile = {}));\r\n    var WorkspaceEdit;\r\n    (function (WorkspaceEdit) {\r\n        function is(value) {\r\n            var candidate = value;\r\n            return candidate &&\r\n                (candidate.changes !== void 0 || candidate.documentChanges !== void 0) &&\r\n                (candidate.documentChanges === void 0 || candidate.documentChanges.every(function (change) {\r\n                    if (Is.string(change.kind)) {\r\n                        return CreateFile.is(change) || RenameFile.is(change) || DeleteFile.is(change);\r\n                    }\r\n                    else {\r\n                        return TextDocumentEdit.is(change);\r\n                    }\r\n                }));\r\n        }\r\n        WorkspaceEdit.is = is;\r\n    })(WorkspaceEdit = exports.WorkspaceEdit || (exports.WorkspaceEdit = {}));\r\n    var TextEditChangeImpl = /** @class */ (function () {\r\n        function TextEditChangeImpl(edits) {\r\n            this.edits = edits;\r\n        }\r\n        TextEditChangeImpl.prototype.insert = function (position, newText) {\r\n            this.edits.push(TextEdit.insert(position, newText));\r\n        };\r\n        TextEditChangeImpl.prototype.replace = function (range, newText) {\r\n            this.edits.push(TextEdit.replace(range, newText));\r\n        };\r\n        TextEditChangeImpl.prototype.delete = function (range) {\r\n            this.edits.push(TextEdit.del(range));\r\n        };\r\n        TextEditChangeImpl.prototype.add = function (edit) {\r\n            this.edits.push(edit);\r\n        };\r\n        TextEditChangeImpl.prototype.all = function () {\r\n            return this.edits;\r\n        };\r\n        TextEditChangeImpl.prototype.clear = function () {\r\n            this.edits.splice(0, this.edits.length);\r\n        };\r\n        return TextEditChangeImpl;\r\n    }());\r\n    /**\r\n     * A workspace change helps constructing changes to a workspace.\r\n     */\r\n    var WorkspaceChange = /** @class */ (function () {\r\n        function WorkspaceChange(workspaceEdit) {\r\n            var _this = this;\r\n            this._textEditChanges = Object.create(null);\r\n            if (workspaceEdit) {\r\n                this._workspaceEdit = workspaceEdit;\r\n                if (workspaceEdit.documentChanges) {\r\n                    workspaceEdit.documentChanges.forEach(function (change) {\r\n                        if (TextDocumentEdit.is(change)) {\r\n                            var textEditChange = new TextEditChangeImpl(change.edits);\r\n                            _this._textEditChanges[change.textDocument.uri] = textEditChange;\r\n                        }\r\n                    });\r\n                }\r\n                else if (workspaceEdit.changes) {\r\n                    Object.keys(workspaceEdit.changes).forEach(function (key) {\r\n                        var textEditChange = new TextEditChangeImpl(workspaceEdit.changes[key]);\r\n                        _this._textEditChanges[key] = textEditChange;\r\n                    });\r\n                }\r\n            }\r\n        }\r\n        Object.defineProperty(WorkspaceChange.prototype, \"edit\", {\r\n            /**\r\n             * Returns the underlying [WorkspaceEdit](#WorkspaceEdit) literal\r\n             * use to be returned from a workspace edit operation like rename.\r\n             */\r\n            get: function () {\r\n                return this._workspaceEdit;\r\n            },\r\n            enumerable: true,\r\n            configurable: true\r\n        });\r\n        WorkspaceChange.prototype.getTextEditChange = function (key) {\r\n            if (VersionedTextDocumentIdentifier.is(key)) {\r\n                if (!this._workspaceEdit) {\r\n                    this._workspaceEdit = {\r\n                        documentChanges: []\r\n                    };\r\n                }\r\n                if (!this._workspaceEdit.documentChanges) {\r\n                    throw new Error('Workspace edit is not configured for document changes.');\r\n                }\r\n                var textDocument = key;\r\n                var result = this._textEditChanges[textDocument.uri];\r\n                if (!result) {\r\n                    var edits = [];\r\n                    var textDocumentEdit = {\r\n                        textDocument: textDocument,\r\n                        edits: edits\r\n                    };\r\n                    this._workspaceEdit.documentChanges.push(textDocumentEdit);\r\n                    result = new TextEditChangeImpl(edits);\r\n                    this._textEditChanges[textDocument.uri] = result;\r\n                }\r\n                return result;\r\n            }\r\n            else {\r\n                if (!this._workspaceEdit) {\r\n                    this._workspaceEdit = {\r\n                        changes: Object.create(null)\r\n                    };\r\n                }\r\n                if (!this._workspaceEdit.changes) {\r\n                    throw new Error('Workspace edit is not configured for normal text edit changes.');\r\n                }\r\n                var result = this._textEditChanges[key];\r\n                if (!result) {\r\n                    var edits = [];\r\n                    this._workspaceEdit.changes[key] = edits;\r\n                    result = new TextEditChangeImpl(edits);\r\n                    this._textEditChanges[key] = result;\r\n                }\r\n                return result;\r\n            }\r\n        };\r\n        WorkspaceChange.prototype.createFile = function (uri, options) {\r\n            this.checkDocumentChanges();\r\n            this._workspaceEdit.documentChanges.push(CreateFile.create(uri, options));\r\n        };\r\n        WorkspaceChange.prototype.renameFile = function (oldUri, newUri, options) {\r\n            this.checkDocumentChanges();\r\n            this._workspaceEdit.documentChanges.push(RenameFile.create(oldUri, newUri, options));\r\n        };\r\n        WorkspaceChange.prototype.deleteFile = function (uri, options) {\r\n            this.checkDocumentChanges();\r\n            this._workspaceEdit.documentChanges.push(DeleteFile.create(uri, options));\r\n        };\r\n        WorkspaceChange.prototype.checkDocumentChanges = function () {\r\n            if (!this._workspaceEdit || !this._workspaceEdit.documentChanges) {\r\n                throw new Error('Workspace edit is not configured for document changes.');\r\n            }\r\n        };\r\n        return WorkspaceChange;\r\n    }());\r\n    exports.WorkspaceChange = WorkspaceChange;\r\n    /**\r\n     * The TextDocumentIdentifier namespace provides helper functions to work with\r\n     * [TextDocumentIdentifier](#TextDocumentIdentifier) literals.\r\n     */\r\n    var TextDocumentIdentifier;\r\n    (function (TextDocumentIdentifier) {\r\n        /**\r\n         * Creates a new TextDocumentIdentifier literal.\r\n         * @param uri The document's uri.\r\n         */\r\n        function create(uri) {\r\n            return { uri: uri };\r\n        }\r\n        TextDocumentIdentifier.create = create;\r\n        /**\r\n         * Checks whether the given literal conforms to the [TextDocumentIdentifier](#TextDocumentIdentifier) interface.\r\n         */\r\n        function is(value) {\r\n            var candidate = value;\r\n            return Is.defined(candidate) && Is.string(candidate.uri);\r\n        }\r\n        TextDocumentIdentifier.is = is;\r\n    })(TextDocumentIdentifier = exports.TextDocumentIdentifier || (exports.TextDocumentIdentifier = {}));\r\n    /**\r\n     * The VersionedTextDocumentIdentifier namespace provides helper functions to work with\r\n     * [VersionedTextDocumentIdentifier](#VersionedTextDocumentIdentifier) literals.\r\n     */\r\n    var VersionedTextDocumentIdentifier;\r\n    (function (VersionedTextDocumentIdentifier) {\r\n        /**\r\n         * Creates a new VersionedTextDocumentIdentifier literal.\r\n         * @param uri The document's uri.\r\n         * @param uri The document's text.\r\n         */\r\n        function create(uri, version) {\r\n            return { uri: uri, version: version };\r\n        }\r\n        VersionedTextDocumentIdentifier.create = create;\r\n        /**\r\n         * Checks whether the given literal conforms to the [VersionedTextDocumentIdentifier](#VersionedTextDocumentIdentifier) interface.\r\n         */\r\n        function is(value) {\r\n            var candidate = value;\r\n            return Is.defined(candidate) && Is.string(candidate.uri) && (candidate.version === null || Is.number(candidate.version));\r\n        }\r\n        VersionedTextDocumentIdentifier.is = is;\r\n    })(VersionedTextDocumentIdentifier = exports.VersionedTextDocumentIdentifier || (exports.VersionedTextDocumentIdentifier = {}));\r\n    /**\r\n     * The TextDocumentItem namespace provides helper functions to work with\r\n     * [TextDocumentItem](#TextDocumentItem) literals.\r\n     */\r\n    var TextDocumentItem;\r\n    (function (TextDocumentItem) {\r\n        /**\r\n         * Creates a new TextDocumentItem literal.\r\n         * @param uri The document's uri.\r\n         * @param languageId The document's language identifier.\r\n         * @param version The document's version number.\r\n         * @param text The document's text.\r\n         */\r\n        function create(uri, languageId, version, text) {\r\n            return { uri: uri, languageId: languageId, version: version, text: text };\r\n        }\r\n        TextDocumentItem.create = create;\r\n        /**\r\n         * Checks whether the given literal conforms to the [TextDocumentItem](#TextDocumentItem) interface.\r\n         */\r\n        function is(value) {\r\n            var candidate = value;\r\n            return Is.defined(candidate) && Is.string(candidate.uri) && Is.string(candidate.languageId) && Is.number(candidate.version) && Is.string(candidate.text);\r\n        }\r\n        TextDocumentItem.is = is;\r\n    })(TextDocumentItem = exports.TextDocumentItem || (exports.TextDocumentItem = {}));\r\n    /**\r\n     * Describes the content type that a client supports in various\r\n     * result literals like `Hover`, `ParameterInfo` or `CompletionItem`.\r\n     *\r\n     * Please note that `MarkupKinds` must not start with a `$`. This kinds\r\n     * are reserved for internal usage.\r\n     */\r\n    var MarkupKind;\r\n    (function (MarkupKind) {\r\n        /**\r\n         * Plain text is supported as a content format\r\n         */\r\n        MarkupKind.PlainText = 'plaintext';\r\n        /**\r\n         * Markdown is supported as a content format\r\n         */\r\n        MarkupKind.Markdown = 'markdown';\r\n    })(MarkupKind = exports.MarkupKind || (exports.MarkupKind = {}));\r\n    (function (MarkupKind) {\r\n        /**\r\n         * Checks whether the given value is a value of the [MarkupKind](#MarkupKind) type.\r\n         */\r\n        function is(value) {\r\n            var candidate = value;\r\n            return candidate === MarkupKind.PlainText || candidate === MarkupKind.Markdown;\r\n        }\r\n        MarkupKind.is = is;\r\n    })(MarkupKind = exports.MarkupKind || (exports.MarkupKind = {}));\r\n    var MarkupContent;\r\n    (function (MarkupContent) {\r\n        /**\r\n         * Checks whether the given value conforms to the [MarkupContent](#MarkupContent) interface.\r\n         */\r\n        function is(value) {\r\n            var candidate = value;\r\n            return Is.objectLiteral(value) && MarkupKind.is(candidate.kind) && Is.string(candidate.value);\r\n        }\r\n        MarkupContent.is = is;\r\n    })(MarkupContent = exports.MarkupContent || (exports.MarkupContent = {}));\r\n    /**\r\n     * The kind of a completion entry.\r\n     */\r\n    var CompletionItemKind;\r\n    (function (CompletionItemKind) {\r\n        CompletionItemKind.Text = 1;\r\n        CompletionItemKind.Method = 2;\r\n        CompletionItemKind.Function = 3;\r\n        CompletionItemKind.Constructor = 4;\r\n        CompletionItemKind.Field = 5;\r\n        CompletionItemKind.Variable = 6;\r\n        CompletionItemKind.Class = 7;\r\n        CompletionItemKind.Interface = 8;\r\n        CompletionItemKind.Module = 9;\r\n        CompletionItemKind.Property = 10;\r\n        CompletionItemKind.Unit = 11;\r\n        CompletionItemKind.Value = 12;\r\n        CompletionItemKind.Enum = 13;\r\n        CompletionItemKind.Keyword = 14;\r\n        CompletionItemKind.Snippet = 15;\r\n        CompletionItemKind.Color = 16;\r\n        CompletionItemKind.File = 17;\r\n        CompletionItemKind.Reference = 18;\r\n        CompletionItemKind.Folder = 19;\r\n        CompletionItemKind.EnumMember = 20;\r\n        CompletionItemKind.Constant = 21;\r\n        CompletionItemKind.Struct = 22;\r\n        CompletionItemKind.Event = 23;\r\n        CompletionItemKind.Operator = 24;\r\n        CompletionItemKind.TypeParameter = 25;\r\n    })(CompletionItemKind = exports.CompletionItemKind || (exports.CompletionItemKind = {}));\r\n    /**\r\n     * Defines whether the insert text in a completion item should be interpreted as\r\n     * plain text or a snippet.\r\n     */\r\n    var InsertTextFormat;\r\n    (function (InsertTextFormat) {\r\n        /**\r\n         * The primary text to be inserted is treated as a plain string.\r\n         */\r\n        InsertTextFormat.PlainText = 1;\r\n        /**\r\n         * The primary text to be inserted is treated as a snippet.\r\n         *\r\n         * A snippet can define tab stops and placeholders with `$1`, `$2`\r\n         * and `${3:foo}`. `$0` defines the final tab stop, it defaults to\r\n         * the end of the snippet. Placeholders with equal identifiers are linked,\r\n         * that is typing in one will update others too.\r\n         *\r\n         * See also: https://github.com/Microsoft/vscode/blob/master/src/vs/editor/contrib/snippet/common/snippet.md\r\n         */\r\n        InsertTextFormat.Snippet = 2;\r\n    })(InsertTextFormat = exports.InsertTextFormat || (exports.InsertTextFormat = {}));\r\n    /**\r\n     * Completion item tags are extra annotations that tweak the rendering of a completion\r\n     * item.\r\n     *\r\n     * @since 3.15.0\r\n     */\r\n    var CompletionItemTag;\r\n    (function (CompletionItemTag) {\r\n        /**\r\n         * Render a completion as obsolete, usually using a strike-out.\r\n         */\r\n        CompletionItemTag.Deprecated = 1;\r\n    })(CompletionItemTag = exports.CompletionItemTag || (exports.CompletionItemTag = {}));\r\n    /**\r\n     * The CompletionItem namespace provides functions to deal with\r\n     * completion items.\r\n     */\r\n    var CompletionItem;\r\n    (function (CompletionItem) {\r\n        /**\r\n         * Create a completion item and seed it with a label.\r\n         * @param label The completion item's label\r\n         */\r\n        function create(label) {\r\n            return { label: label };\r\n        }\r\n        CompletionItem.create = create;\r\n    })(CompletionItem = exports.CompletionItem || (exports.CompletionItem = {}));\r\n    /**\r\n     * The CompletionList namespace provides functions to deal with\r\n     * completion lists.\r\n     */\r\n    var CompletionList;\r\n    (function (CompletionList) {\r\n        /**\r\n         * Creates a new completion list.\r\n         *\r\n         * @param items The completion items.\r\n         * @param isIncomplete The list is not complete.\r\n         */\r\n        function create(items, isIncomplete) {\r\n            return { items: items ? items : [], isIncomplete: !!isIncomplete };\r\n        }\r\n        CompletionList.create = create;\r\n    })(CompletionList = exports.CompletionList || (exports.CompletionList = {}));\r\n    var MarkedString;\r\n    (function (MarkedString) {\r\n        /**\r\n         * Creates a marked string from plain text.\r\n         *\r\n         * @param plainText The plain text.\r\n         */\r\n        function fromPlainText(plainText) {\r\n            return plainText.replace(/[\\\\`*_{}[\\]()#+\\-.!]/g, '\\\\$&'); // escape markdown syntax tokens: http://daringfireball.net/projects/markdown/syntax#backslash\r\n        }\r\n        MarkedString.fromPlainText = fromPlainText;\r\n        /**\r\n         * Checks whether the given value conforms to the [MarkedString](#MarkedString) type.\r\n         */\r\n        function is(value) {\r\n            var candidate = value;\r\n            return Is.string(candidate) || (Is.objectLiteral(candidate) && Is.string(candidate.language) && Is.string(candidate.value));\r\n        }\r\n        MarkedString.is = is;\r\n    })(MarkedString = exports.MarkedString || (exports.MarkedString = {}));\r\n    var Hover;\r\n    (function (Hover) {\r\n        /**\r\n         * Checks whether the given value conforms to the [Hover](#Hover) interface.\r\n         */\r\n        function is(value) {\r\n            var candidate = value;\r\n            return !!candidate && Is.objectLiteral(candidate) && (MarkupContent.is(candidate.contents) ||\r\n                MarkedString.is(candidate.contents) ||\r\n                Is.typedArray(candidate.contents, MarkedString.is)) && (value.range === void 0 || Range.is(value.range));\r\n        }\r\n        Hover.is = is;\r\n    })(Hover = exports.Hover || (exports.Hover = {}));\r\n    /**\r\n     * The ParameterInformation namespace provides helper functions to work with\r\n     * [ParameterInformation](#ParameterInformation) literals.\r\n     */\r\n    var ParameterInformation;\r\n    (function (ParameterInformation) {\r\n        /**\r\n         * Creates a new parameter information literal.\r\n         *\r\n         * @param label A label string.\r\n         * @param documentation A doc string.\r\n         */\r\n        function create(label, documentation) {\r\n            return documentation ? { label: label, documentation: documentation } : { label: label };\r\n        }\r\n        ParameterInformation.create = create;\r\n    })(ParameterInformation = exports.ParameterInformation || (exports.ParameterInformation = {}));\r\n    /**\r\n     * The SignatureInformation namespace provides helper functions to work with\r\n     * [SignatureInformation](#SignatureInformation) literals.\r\n     */\r\n    var SignatureInformation;\r\n    (function (SignatureInformation) {\r\n        function create(label, documentation) {\r\n            var parameters = [];\r\n            for (var _i = 2; _i < arguments.length; _i++) {\r\n                parameters[_i - 2] = arguments[_i];\r\n            }\r\n            var result = { label: label };\r\n            if (Is.defined(documentation)) {\r\n                result.documentation = documentation;\r\n            }\r\n            if (Is.defined(parameters)) {\r\n                result.parameters = parameters;\r\n            }\r\n            else {\r\n                result.parameters = [];\r\n            }\r\n            return result;\r\n        }\r\n        SignatureInformation.create = create;\r\n    })(SignatureInformation = exports.SignatureInformation || (exports.SignatureInformation = {}));\r\n    /**\r\n     * A document highlight kind.\r\n     */\r\n    var DocumentHighlightKind;\r\n    (function (DocumentHighlightKind) {\r\n        /**\r\n         * A textual occurrence.\r\n         */\r\n        DocumentHighlightKind.Text = 1;\r\n        /**\r\n         * Read-access of a symbol, like reading a variable.\r\n         */\r\n        DocumentHighlightKind.Read = 2;\r\n        /**\r\n         * Write-access of a symbol, like writing to a variable.\r\n         */\r\n        DocumentHighlightKind.Write = 3;\r\n    })(DocumentHighlightKind = exports.DocumentHighlightKind || (exports.DocumentHighlightKind = {}));\r\n    /**\r\n     * DocumentHighlight namespace to provide helper functions to work with\r\n     * [DocumentHighlight](#DocumentHighlight) literals.\r\n     */\r\n    var DocumentHighlight;\r\n    (function (DocumentHighlight) {\r\n        /**\r\n         * Create a DocumentHighlight object.\r\n         * @param range The range the highlight applies to.\r\n         */\r\n        function create(range, kind) {\r\n            var result = { range: range };\r\n            if (Is.number(kind)) {\r\n                result.kind = kind;\r\n            }\r\n            return result;\r\n        }\r\n        DocumentHighlight.create = create;\r\n    })(DocumentHighlight = exports.DocumentHighlight || (exports.DocumentHighlight = {}));\r\n    /**\r\n     * A symbol kind.\r\n     */\r\n    var SymbolKind;\r\n    (function (SymbolKind) {\r\n        SymbolKind.File = 1;\r\n        SymbolKind.Module = 2;\r\n        SymbolKind.Namespace = 3;\r\n        SymbolKind.Package = 4;\r\n        SymbolKind.Class = 5;\r\n        SymbolKind.Method = 6;\r\n        SymbolKind.Property = 7;\r\n        SymbolKind.Field = 8;\r\n        SymbolKind.Constructor = 9;\r\n        SymbolKind.Enum = 10;\r\n        SymbolKind.Interface = 11;\r\n        SymbolKind.Function = 12;\r\n        SymbolKind.Variable = 13;\r\n        SymbolKind.Constant = 14;\r\n        SymbolKind.String = 15;\r\n        SymbolKind.Number = 16;\r\n        SymbolKind.Boolean = 17;\r\n        SymbolKind.Array = 18;\r\n        SymbolKind.Object = 19;\r\n        SymbolKind.Key = 20;\r\n        SymbolKind.Null = 21;\r\n        SymbolKind.EnumMember = 22;\r\n        SymbolKind.Struct = 23;\r\n        SymbolKind.Event = 24;\r\n        SymbolKind.Operator = 25;\r\n        SymbolKind.TypeParameter = 26;\r\n    })(SymbolKind = exports.SymbolKind || (exports.SymbolKind = {}));\r\n    /**\r\n     * Symbol tags are extra annotations that tweak the rendering of a symbol.\r\n     * @since 3.15\r\n     */\r\n    var SymbolTag;\r\n    (function (SymbolTag) {\r\n        /**\r\n         * Render a symbol as obsolete, usually using a strike-out.\r\n         */\r\n        SymbolTag.Deprecated = 1;\r\n    })(SymbolTag = exports.SymbolTag || (exports.SymbolTag = {}));\r\n    var SymbolInformation;\r\n    (function (SymbolInformation) {\r\n        /**\r\n         * Creates a new symbol information literal.\r\n         *\r\n         * @param name The name of the symbol.\r\n         * @param kind The kind of the symbol.\r\n         * @param range The range of the location of the symbol.\r\n         * @param uri The resource of the location of symbol, defaults to the current document.\r\n         * @param containerName The name of the symbol containing the symbol.\r\n         */\r\n        function create(name, kind, range, uri, containerName) {\r\n            var result = {\r\n                name: name,\r\n                kind: kind,\r\n                location: { uri: uri, range: range }\r\n            };\r\n            if (containerName) {\r\n                result.containerName = containerName;\r\n            }\r\n            return result;\r\n        }\r\n        SymbolInformation.create = create;\r\n    })(SymbolInformation = exports.SymbolInformation || (exports.SymbolInformation = {}));\r\n    var DocumentSymbol;\r\n    (function (DocumentSymbol) {\r\n        /**\r\n         * Creates a new symbol information literal.\r\n         *\r\n         * @param name The name of the symbol.\r\n         * @param detail The detail of the symbol.\r\n         * @param kind The kind of the symbol.\r\n         * @param range The range of the symbol.\r\n         * @param selectionRange The selectionRange of the symbol.\r\n         * @param children Children of the symbol.\r\n         */\r\n        function create(name, detail, kind, range, selectionRange, children) {\r\n            var result = {\r\n                name: name,\r\n                detail: detail,\r\n                kind: kind,\r\n                range: range,\r\n                selectionRange: selectionRange\r\n            };\r\n            if (children !== void 0) {\r\n                result.children = children;\r\n            }\r\n            return result;\r\n        }\r\n        DocumentSymbol.create = create;\r\n        /**\r\n         * Checks whether the given literal conforms to the [DocumentSymbol](#DocumentSymbol) interface.\r\n         */\r\n        function is(value) {\r\n            var candidate = value;\r\n            return candidate &&\r\n                Is.string(candidate.name) && Is.number(candidate.kind) &&\r\n                Range.is(candidate.range) && Range.is(candidate.selectionRange) &&\r\n                (candidate.detail === void 0 || Is.string(candidate.detail)) &&\r\n                (candidate.deprecated === void 0 || Is.boolean(candidate.deprecated)) &&\r\n                (candidate.children === void 0 || Array.isArray(candidate.children));\r\n        }\r\n        DocumentSymbol.is = is;\r\n    })(DocumentSymbol = exports.DocumentSymbol || (exports.DocumentSymbol = {}));\r\n    /**\r\n     * A set of predefined code action kinds\r\n     */\r\n    var CodeActionKind;\r\n    (function (CodeActionKind) {\r\n        /**\r\n         * Empty kind.\r\n         */\r\n        CodeActionKind.Empty = '';\r\n        /**\r\n         * Base kind for quickfix actions: 'quickfix'\r\n         */\r\n        CodeActionKind.QuickFix = 'quickfix';\r\n        /**\r\n         * Base kind for refactoring actions: 'refactor'\r\n         */\r\n        CodeActionKind.Refactor = 'refactor';\r\n        /**\r\n         * Base kind for refactoring extraction actions: 'refactor.extract'\r\n         *\r\n         * Example extract actions:\r\n         *\r\n         * - Extract method\r\n         * - Extract function\r\n         * - Extract variable\r\n         * - Extract interface from class\r\n         * - ...\r\n         */\r\n        CodeActionKind.RefactorExtract = 'refactor.extract';\r\n        /**\r\n         * Base kind for refactoring inline actions: 'refactor.inline'\r\n         *\r\n         * Example inline actions:\r\n         *\r\n         * - Inline function\r\n         * - Inline variable\r\n         * - Inline constant\r\n         * - ...\r\n         */\r\n        CodeActionKind.RefactorInline = 'refactor.inline';\r\n        /**\r\n         * Base kind for refactoring rewrite actions: 'refactor.rewrite'\r\n         *\r\n         * Example rewrite actions:\r\n         *\r\n         * - Convert JavaScript function to class\r\n         * - Add or remove parameter\r\n         * - Encapsulate field\r\n         * - Make method static\r\n         * - Move method to base class\r\n         * - ...\r\n         */\r\n        CodeActionKind.RefactorRewrite = 'refactor.rewrite';\r\n        /**\r\n         * Base kind for source actions: `source`\r\n         *\r\n         * Source code actions apply to the entire file.\r\n         */\r\n        CodeActionKind.Source = 'source';\r\n        /**\r\n         * Base kind for an organize imports source action: `source.organizeImports`\r\n         */\r\n        CodeActionKind.SourceOrganizeImports = 'source.organizeImports';\r\n        /**\r\n         * Base kind for auto-fix source actions: `source.fixAll`.\r\n         *\r\n         * Fix all actions automatically fix errors that have a clear fix that do not require user input.\r\n         * They should not suppress errors or perform unsafe fixes such as generating new types or classes.\r\n         *\r\n         * @since 3.15.0\r\n         */\r\n        CodeActionKind.SourceFixAll = 'source.fixAll';\r\n    })(CodeActionKind = exports.CodeActionKind || (exports.CodeActionKind = {}));\r\n    /**\r\n     * The CodeActionContext namespace provides helper functions to work with\r\n     * [CodeActionContext](#CodeActionContext) literals.\r\n     */\r\n    var CodeActionContext;\r\n    (function (CodeActionContext) {\r\n        /**\r\n         * Creates a new CodeActionContext literal.\r\n         */\r\n        function create(diagnostics, only) {\r\n            var result = { diagnostics: diagnostics };\r\n            if (only !== void 0 && only !== null) {\r\n                result.only = only;\r\n            }\r\n            return result;\r\n        }\r\n        CodeActionContext.create = create;\r\n        /**\r\n         * Checks whether the given literal conforms to the [CodeActionContext](#CodeActionContext) interface.\r\n         */\r\n        function is(value) {\r\n            var candidate = value;\r\n            return Is.defined(candidate) && Is.typedArray(candidate.diagnostics, Diagnostic.is) && (candidate.only === void 0 || Is.typedArray(candidate.only, Is.string));\r\n        }\r\n        CodeActionContext.is = is;\r\n    })(CodeActionContext = exports.CodeActionContext || (exports.CodeActionContext = {}));\r\n    var CodeAction;\r\n    (function (CodeAction) {\r\n        function create(title, commandOrEdit, kind) {\r\n            var result = { title: title };\r\n            if (Command.is(commandOrEdit)) {\r\n                result.command = commandOrEdit;\r\n            }\r\n            else {\r\n                result.edit = commandOrEdit;\r\n            }\r\n            if (kind !== void 0) {\r\n                result.kind = kind;\r\n            }\r\n            return result;\r\n        }\r\n        CodeAction.create = create;\r\n        function is(value) {\r\n            var candidate = value;\r\n            return candidate && Is.string(candidate.title) &&\r\n                (candidate.diagnostics === void 0 || Is.typedArray(candidate.diagnostics, Diagnostic.is)) &&\r\n                (candidate.kind === void 0 || Is.string(candidate.kind)) &&\r\n                (candidate.edit !== void 0 || candidate.command !== void 0) &&\r\n                (candidate.command === void 0 || Command.is(candidate.command)) &&\r\n                (candidate.isPreferred === void 0 || Is.boolean(candidate.isPreferred)) &&\r\n                (candidate.edit === void 0 || WorkspaceEdit.is(candidate.edit));\r\n        }\r\n        CodeAction.is = is;\r\n    })(CodeAction = exports.CodeAction || (exports.CodeAction = {}));\r\n    /**\r\n     * The CodeLens namespace provides helper functions to work with\r\n     * [CodeLens](#CodeLens) literals.\r\n     */\r\n    var CodeLens;\r\n    (function (CodeLens) {\r\n        /**\r\n         * Creates a new CodeLens literal.\r\n         */\r\n        function create(range, data) {\r\n            var result = { range: range };\r\n            if (Is.defined(data)) {\r\n                result.data = data;\r\n            }\r\n            return result;\r\n        }\r\n        CodeLens.create = create;\r\n        /**\r\n         * Checks whether the given literal conforms to the [CodeLens](#CodeLens) interface.\r\n         */\r\n        function is(value) {\r\n            var candidate = value;\r\n            return Is.defined(candidate) && Range.is(candidate.range) && (Is.undefined(candidate.command) || Command.is(candidate.command));\r\n        }\r\n        CodeLens.is = is;\r\n    })(CodeLens = exports.CodeLens || (exports.CodeLens = {}));\r\n    /**\r\n     * The FormattingOptions namespace provides helper functions to work with\r\n     * [FormattingOptions](#FormattingOptions) literals.\r\n     */\r\n    var FormattingOptions;\r\n    (function (FormattingOptions) {\r\n        /**\r\n         * Creates a new FormattingOptions literal.\r\n         */\r\n        function create(tabSize, insertSpaces) {\r\n            return { tabSize: tabSize, insertSpaces: insertSpaces };\r\n        }\r\n        FormattingOptions.create = create;\r\n        /**\r\n         * Checks whether the given literal conforms to the [FormattingOptions](#FormattingOptions) interface.\r\n         */\r\n        function is(value) {\r\n            var candidate = value;\r\n            return Is.defined(candidate) && Is.number(candidate.tabSize) && Is.boolean(candidate.insertSpaces);\r\n        }\r\n        FormattingOptions.is = is;\r\n    })(FormattingOptions = exports.FormattingOptions || (exports.FormattingOptions = {}));\r\n    /**\r\n     * The DocumentLink namespace provides helper functions to work with\r\n     * [DocumentLink](#DocumentLink) literals.\r\n     */\r\n    var DocumentLink;\r\n    (function (DocumentLink) {\r\n        /**\r\n         * Creates a new DocumentLink literal.\r\n         */\r\n        function create(range, target, data) {\r\n            return { range: range, target: target, data: data };\r\n        }\r\n        DocumentLink.create = create;\r\n        /**\r\n         * Checks whether the given literal conforms to the [DocumentLink](#DocumentLink) interface.\r\n         */\r\n        function is(value) {\r\n            var candidate = value;\r\n            return Is.defined(candidate) && Range.is(candidate.range) && (Is.undefined(candidate.target) || Is.string(candidate.target));\r\n        }\r\n        DocumentLink.is = is;\r\n    })(DocumentLink = exports.DocumentLink || (exports.DocumentLink = {}));\r\n    /**\r\n     * The SelectionRange namespace provides helper function to work with\r\n     * SelectionRange literals.\r\n     */\r\n    var SelectionRange;\r\n    (function (SelectionRange) {\r\n        /**\r\n         * Creates a new SelectionRange\r\n         * @param range the range.\r\n         * @param parent an optional parent.\r\n         */\r\n        function create(range, parent) {\r\n            return { range: range, parent: parent };\r\n        }\r\n        SelectionRange.create = create;\r\n        function is(value) {\r\n            var candidate = value;\r\n            return candidate !== undefined && Range.is(candidate.range) && (candidate.parent === undefined || SelectionRange.is(candidate.parent));\r\n        }\r\n        SelectionRange.is = is;\r\n    })(SelectionRange = exports.SelectionRange || (exports.SelectionRange = {}));\r\n    exports.EOL = ['\\n', '\\r\\n', '\\r'];\r\n    /**\r\n     * @deprecated Use the text document from the new vscode-languageserver-textdocument package.\r\n     */\r\n    var TextDocument;\r\n    (function (TextDocument) {\r\n        /**\r\n         * Creates a new ITextDocument literal from the given uri and content.\r\n         * @param uri The document's uri.\r\n         * @param languageId  The document's language Id.\r\n         * @param content The document's content.\r\n         */\r\n        function create(uri, languageId, version, content) {\r\n            return new FullTextDocument(uri, languageId, version, content);\r\n        }\r\n        TextDocument.create = create;\r\n        /**\r\n         * Checks whether the given literal conforms to the [ITextDocument](#ITextDocument) interface.\r\n         */\r\n        function is(value) {\r\n            var candidate = value;\r\n            return Is.defined(candidate) && Is.string(candidate.uri) && (Is.undefined(candidate.languageId) || Is.string(candidate.languageId)) && Is.number(candidate.lineCount)\r\n                && Is.func(candidate.getText) && Is.func(candidate.positionAt) && Is.func(candidate.offsetAt) ? true : false;\r\n        }\r\n        TextDocument.is = is;\r\n        function applyEdits(document, edits) {\r\n            var text = document.getText();\r\n            var sortedEdits = mergeSort(edits, function (a, b) {\r\n                var diff = a.range.start.line - b.range.start.line;\r\n                if (diff === 0) {\r\n                    return a.range.start.character - b.range.start.character;\r\n                }\r\n                return diff;\r\n            });\r\n            var lastModifiedOffset = text.length;\r\n            for (var i = sortedEdits.length - 1; i >= 0; i--) {\r\n                var e = sortedEdits[i];\r\n                var startOffset = document.offsetAt(e.range.start);\r\n                var endOffset = document.offsetAt(e.range.end);\r\n                if (endOffset <= lastModifiedOffset) {\r\n                    text = text.substring(0, startOffset) + e.newText + text.substring(endOffset, text.length);\r\n                }\r\n                else {\r\n                    throw new Error('Overlapping edit');\r\n                }\r\n                lastModifiedOffset = startOffset;\r\n            }\r\n            return text;\r\n        }\r\n        TextDocument.applyEdits = applyEdits;\r\n        function mergeSort(data, compare) {\r\n            if (data.length <= 1) {\r\n                // sorted\r\n                return data;\r\n            }\r\n            var p = (data.length / 2) | 0;\r\n            var left = data.slice(0, p);\r\n            var right = data.slice(p);\r\n            mergeSort(left, compare);\r\n            mergeSort(right, compare);\r\n            var leftIdx = 0;\r\n            var rightIdx = 0;\r\n            var i = 0;\r\n            while (leftIdx < left.length && rightIdx < right.length) {\r\n                var ret = compare(left[leftIdx], right[rightIdx]);\r\n                if (ret <= 0) {\r\n                    // smaller_equal -> take left to preserve order\r\n                    data[i++] = left[leftIdx++];\r\n                }\r\n                else {\r\n                    // greater -> take right\r\n                    data[i++] = right[rightIdx++];\r\n                }\r\n            }\r\n            while (leftIdx < left.length) {\r\n                data[i++] = left[leftIdx++];\r\n            }\r\n            while (rightIdx < right.length) {\r\n                data[i++] = right[rightIdx++];\r\n            }\r\n            return data;\r\n        }\r\n    })(TextDocument = exports.TextDocument || (exports.TextDocument = {}));\r\n    var FullTextDocument = /** @class */ (function () {\r\n        function FullTextDocument(uri, languageId, version, content) {\r\n            this._uri = uri;\r\n            this._languageId = languageId;\r\n            this._version = version;\r\n            this._content = content;\r\n            this._lineOffsets = undefined;\r\n        }\r\n        Object.defineProperty(FullTextDocument.prototype, \"uri\", {\r\n            get: function () {\r\n                return this._uri;\r\n            },\r\n            enumerable: true,\r\n            configurable: true\r\n        });\r\n        Object.defineProperty(FullTextDocument.prototype, \"languageId\", {\r\n            get: function () {\r\n                return this._languageId;\r\n            },\r\n            enumerable: true,\r\n            configurable: true\r\n        });\r\n        Object.defineProperty(FullTextDocument.prototype, \"version\", {\r\n            get: function () {\r\n                return this._version;\r\n            },\r\n            enumerable: true,\r\n            configurable: true\r\n        });\r\n        FullTextDocument.prototype.getText = function (range) {\r\n            if (range) {\r\n                var start = this.offsetAt(range.start);\r\n                var end = this.offsetAt(range.end);\r\n                return this._content.substring(start, end);\r\n            }\r\n            return this._content;\r\n        };\r\n        FullTextDocument.prototype.update = function (event, version) {\r\n            this._content = event.text;\r\n            this._version = version;\r\n            this._lineOffsets = undefined;\r\n        };\r\n        FullTextDocument.prototype.getLineOffsets = function () {\r\n            if (this._lineOffsets === undefined) {\r\n                var lineOffsets = [];\r\n                var text = this._content;\r\n                var isLineStart = true;\r\n                for (var i = 0; i < text.length; i++) {\r\n                    if (isLineStart) {\r\n                        lineOffsets.push(i);\r\n                        isLineStart = false;\r\n                    }\r\n                    var ch = text.charAt(i);\r\n                    isLineStart = (ch === '\\r' || ch === '\\n');\r\n                    if (ch === '\\r' && i + 1 < text.length && text.charAt(i + 1) === '\\n') {\r\n                        i++;\r\n                    }\r\n                }\r\n                if (isLineStart && text.length > 0) {\r\n                    lineOffsets.push(text.length);\r\n                }\r\n                this._lineOffsets = lineOffsets;\r\n            }\r\n            return this._lineOffsets;\r\n        };\r\n        FullTextDocument.prototype.positionAt = function (offset) {\r\n            offset = Math.max(Math.min(offset, this._content.length), 0);\r\n            var lineOffsets = this.getLineOffsets();\r\n            var low = 0, high = lineOffsets.length;\r\n            if (high === 0) {\r\n                return Position.create(0, offset);\r\n            }\r\n            while (low < high) {\r\n                var mid = Math.floor((low + high) / 2);\r\n                if (lineOffsets[mid] > offset) {\r\n                    high = mid;\r\n                }\r\n                else {\r\n                    low = mid + 1;\r\n                }\r\n            }\r\n            // low is the least x for which the line offset is larger than the current offset\r\n            // or array.length if no line offset is larger than the current offset\r\n            var line = low - 1;\r\n            return Position.create(line, offset - lineOffsets[line]);\r\n        };\r\n        FullTextDocument.prototype.offsetAt = function (position) {\r\n            var lineOffsets = this.getLineOffsets();\r\n            if (position.line >= lineOffsets.length) {\r\n                return this._content.length;\r\n            }\r\n            else if (position.line < 0) {\r\n                return 0;\r\n            }\r\n            var lineOffset = lineOffsets[position.line];\r\n            var nextLineOffset = (position.line + 1 < lineOffsets.length) ? lineOffsets[position.line + 1] : this._content.length;\r\n            return Math.max(Math.min(lineOffset + position.character, nextLineOffset), lineOffset);\r\n        };\r\n        Object.defineProperty(FullTextDocument.prototype, \"lineCount\", {\r\n            get: function () {\r\n                return this.getLineOffsets().length;\r\n            },\r\n            enumerable: true,\r\n            configurable: true\r\n        });\r\n        return FullTextDocument;\r\n    }());\r\n    var Is;\r\n    (function (Is) {\r\n        var toString = Object.prototype.toString;\r\n        function defined(value) {\r\n            return typeof value !== 'undefined';\r\n        }\r\n        Is.defined = defined;\r\n        function undefined(value) {\r\n            return typeof value === 'undefined';\r\n        }\r\n        Is.undefined = undefined;\r\n        function boolean(value) {\r\n            return value === true || value === false;\r\n        }\r\n        Is.boolean = boolean;\r\n        function string(value) {\r\n            return toString.call(value) === '[object String]';\r\n        }\r\n        Is.string = string;\r\n        function number(value) {\r\n            return toString.call(value) === '[object Number]';\r\n        }\r\n        Is.number = number;\r\n        function func(value) {\r\n            return toString.call(value) === '[object Function]';\r\n        }\r\n        Is.func = func;\r\n        function objectLiteral(value) {\r\n            // Strictly speaking class instances pass this check as well. Since the LSP\r\n            // doesn't use classes we ignore this for now. If we do we need to add something\r\n            // like this: `Object.getPrototypeOf(Object.getPrototypeOf(x)) === null`\r\n            return value !== null && typeof value === 'object';\r\n        }\r\n        Is.objectLiteral = objectLiteral;\r\n        function typedArray(value, check) {\r\n            return Array.isArray(value) && value.every(check);\r\n        }\r\n        Is.typedArray = typedArray;\r\n    })(Is || (Is = {}));\r\n});\r\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar RuleHelpers_1 = require(\"./RuleHelpers\");\nexports.isIgnored = function (ch) {\n    return ch === ' ' ||\n        ch === '\\t' ||\n        ch === ',' ||\n        ch === '\\n' ||\n        ch === '\\r' ||\n        ch === '\\uFEFF' ||\n        ch === '\\u00A0';\n};\nexports.LexRules = {\n    Name: /^[_A-Za-z][_0-9A-Za-z]*/,\n    Punctuation: /^(?:!|\\$|\\(|\\)|\\.\\.\\.|:|=|@|\\[|]|\\{|\\||\\})/,\n    Number: /^-?(?:0|(?:[1-9][0-9]*))(?:\\.[0-9]*)?(?:[eE][+-]?[0-9]+)?/,\n    String: /^(?:\"\"\"(?:\\\\\"\"\"|[^\"]|\"[^\"]|\"\"[^\"])*(?:\"\"\")?|\"(?:[^\"\\\\]|\\\\(?:\"|\\/|\\\\|b|f|n|r|t|u[0-9a-fA-F]{4}))*\"?)/,\n    Comment: /^#.*/,\n};\nexports.ParseRules = {\n    Document: [RuleHelpers_1.list('Definition')],\n    Definition: function (token) {\n        switch (token.value) {\n            case '{':\n                return 'ShortQuery';\n            case 'query':\n                return 'Query';\n            case 'mutation':\n                return 'Mutation';\n            case 'subscription':\n                return 'Subscription';\n            case 'fragment':\n                return 'FragmentDefinition';\n            case 'schema':\n                return 'SchemaDef';\n            case 'scalar':\n                return 'ScalarDef';\n            case 'type':\n                return 'ObjectTypeDef';\n            case 'interface':\n                return 'InterfaceDef';\n            case 'union':\n                return 'UnionDef';\n            case 'enum':\n                return 'EnumDef';\n            case 'input':\n                return 'InputDef';\n            case 'extend':\n                return 'ExtendDef';\n            case 'directive':\n                return 'DirectiveDef';\n        }\n    },\n    ShortQuery: ['SelectionSet'],\n    Query: [\n        word('query'),\n        RuleHelpers_1.opt(name('def')),\n        RuleHelpers_1.opt('VariableDefinitions'),\n        RuleHelpers_1.list('Directive'),\n        'SelectionSet',\n    ],\n    Mutation: [\n        word('mutation'),\n        RuleHelpers_1.opt(name('def')),\n        RuleHelpers_1.opt('VariableDefinitions'),\n        RuleHelpers_1.list('Directive'),\n        'SelectionSet',\n    ],\n    Subscription: [\n        word('subscription'),\n        RuleHelpers_1.opt(name('def')),\n        RuleHelpers_1.opt('VariableDefinitions'),\n        RuleHelpers_1.list('Directive'),\n        'SelectionSet',\n    ],\n    VariableDefinitions: [RuleHelpers_1.p('('), RuleHelpers_1.list('VariableDefinition'), RuleHelpers_1.p(')')],\n    VariableDefinition: ['Variable', RuleHelpers_1.p(':'), 'Type', RuleHelpers_1.opt('DefaultValue')],\n    Variable: [RuleHelpers_1.p('$', 'variable'), name('variable')],\n    DefaultValue: [RuleHelpers_1.p('='), 'Value'],\n    SelectionSet: [RuleHelpers_1.p('{'), RuleHelpers_1.list('Selection'), RuleHelpers_1.p('}')],\n    Selection: function (token, stream) {\n        return token.value === '...'\n            ? stream.match(/[\\s\\u00a0,]*(on\\b|@|{)/, false)\n                ? 'InlineFragment'\n                : 'FragmentSpread'\n            : stream.match(/[\\s\\u00a0,]*:/, false)\n                ? 'AliasedField'\n                : 'Field';\n    },\n    AliasedField: [\n        name('property'),\n        RuleHelpers_1.p(':'),\n        name('qualifier'),\n        RuleHelpers_1.opt('Arguments'),\n        RuleHelpers_1.list('Directive'),\n        RuleHelpers_1.opt('SelectionSet'),\n    ],\n    Field: [\n        name('property'),\n        RuleHelpers_1.opt('Arguments'),\n        RuleHelpers_1.list('Directive'),\n        RuleHelpers_1.opt('SelectionSet'),\n    ],\n    Arguments: [RuleHelpers_1.p('('), RuleHelpers_1.list('Argument'), RuleHelpers_1.p(')')],\n    Argument: [name('attribute'), RuleHelpers_1.p(':'), 'Value'],\n    FragmentSpread: [RuleHelpers_1.p('...'), name('def'), RuleHelpers_1.list('Directive')],\n    InlineFragment: [\n        RuleHelpers_1.p('...'),\n        RuleHelpers_1.opt('TypeCondition'),\n        RuleHelpers_1.list('Directive'),\n        'SelectionSet',\n    ],\n    FragmentDefinition: [\n        word('fragment'),\n        RuleHelpers_1.opt(RuleHelpers_1.butNot(name('def'), [word('on')])),\n        'TypeCondition',\n        RuleHelpers_1.list('Directive'),\n        'SelectionSet',\n    ],\n    TypeCondition: [word('on'), 'NamedType'],\n    Value: function (token) {\n        switch (token.kind) {\n            case 'Number':\n                return 'NumberValue';\n            case 'String':\n                return 'StringValue';\n            case 'Punctuation':\n                switch (token.value) {\n                    case '[':\n                        return 'ListValue';\n                    case '{':\n                        return 'ObjectValue';\n                    case '$':\n                        return 'Variable';\n                }\n                return null;\n            case 'Name':\n                switch (token.value) {\n                    case 'true':\n                    case 'false':\n                        return 'BooleanValue';\n                }\n                if (token.value === 'null') {\n                    return 'NullValue';\n                }\n                return 'EnumValue';\n        }\n    },\n    NumberValue: [RuleHelpers_1.t('Number', 'number')],\n    StringValue: [RuleHelpers_1.t('String', 'string')],\n    BooleanValue: [RuleHelpers_1.t('Name', 'builtin')],\n    NullValue: [RuleHelpers_1.t('Name', 'keyword')],\n    EnumValue: [name('string-2')],\n    ListValue: [RuleHelpers_1.p('['), RuleHelpers_1.list('Value'), RuleHelpers_1.p(']')],\n    ObjectValue: [RuleHelpers_1.p('{'), RuleHelpers_1.list('ObjectField'), RuleHelpers_1.p('}')],\n    ObjectField: [name('attribute'), RuleHelpers_1.p(':'), 'Value'],\n    Type: function (token) {\n        return token.value === '[' ? 'ListType' : 'NonNullType';\n    },\n    ListType: [RuleHelpers_1.p('['), 'Type', RuleHelpers_1.p(']'), RuleHelpers_1.opt(RuleHelpers_1.p('!'))],\n    NonNullType: ['NamedType', RuleHelpers_1.opt(RuleHelpers_1.p('!'))],\n    NamedType: [type('atom')],\n    Directive: [RuleHelpers_1.p('@', 'meta'), name('meta'), RuleHelpers_1.opt('Arguments')],\n    SchemaDef: [\n        word('schema'),\n        RuleHelpers_1.list('Directive'),\n        RuleHelpers_1.p('{'),\n        RuleHelpers_1.list('OperationTypeDef'),\n        RuleHelpers_1.p('}'),\n    ],\n    OperationTypeDef: [name('keyword'), RuleHelpers_1.p(':'), name('atom')],\n    ScalarDef: [word('scalar'), name('atom'), RuleHelpers_1.list('Directive')],\n    ObjectTypeDef: [\n        word('type'),\n        name('atom'),\n        RuleHelpers_1.opt('Implements'),\n        RuleHelpers_1.list('Directive'),\n        RuleHelpers_1.p('{'),\n        RuleHelpers_1.list('FieldDef'),\n        RuleHelpers_1.p('}'),\n    ],\n    Implements: [word('implements'), RuleHelpers_1.list('NamedType')],\n    FieldDef: [\n        name('property'),\n        RuleHelpers_1.opt('ArgumentsDef'),\n        RuleHelpers_1.p(':'),\n        'Type',\n        RuleHelpers_1.list('Directive'),\n    ],\n    ArgumentsDef: [RuleHelpers_1.p('('), RuleHelpers_1.list('InputValueDef'), RuleHelpers_1.p(')')],\n    InputValueDef: [\n        name('attribute'),\n        RuleHelpers_1.p(':'),\n        'Type',\n        RuleHelpers_1.opt('DefaultValue'),\n        RuleHelpers_1.list('Directive'),\n    ],\n    InterfaceDef: [\n        word('interface'),\n        name('atom'),\n        RuleHelpers_1.list('Directive'),\n        RuleHelpers_1.p('{'),\n        RuleHelpers_1.list('FieldDef'),\n        RuleHelpers_1.p('}'),\n    ],\n    UnionDef: [\n        word('union'),\n        name('atom'),\n        RuleHelpers_1.list('Directive'),\n        RuleHelpers_1.p('='),\n        RuleHelpers_1.list('UnionMember', RuleHelpers_1.p('|')),\n    ],\n    UnionMember: ['NamedType'],\n    EnumDef: [\n        word('enum'),\n        name('atom'),\n        RuleHelpers_1.list('Directive'),\n        RuleHelpers_1.p('{'),\n        RuleHelpers_1.list('EnumValueDef'),\n        RuleHelpers_1.p('}'),\n    ],\n    EnumValueDef: [name('string-2'), RuleHelpers_1.list('Directive')],\n    InputDef: [\n        word('input'),\n        name('atom'),\n        RuleHelpers_1.list('Directive'),\n        RuleHelpers_1.p('{'),\n        RuleHelpers_1.list('InputValueDef'),\n        RuleHelpers_1.p('}'),\n    ],\n    ExtendDef: [word('extend'), 'ObjectTypeDef'],\n    DirectiveDef: [\n        word('directive'),\n        RuleHelpers_1.p('@', 'meta'),\n        name('meta'),\n        RuleHelpers_1.opt('ArgumentsDef'),\n        word('on'),\n        RuleHelpers_1.list('DirectiveLocation', RuleHelpers_1.p('|')),\n    ],\n    DirectiveLocation: [name('string-2')],\n};\nfunction word(value) {\n    return {\n        style: 'keyword',\n        match: function (token) { return token.kind === 'Name' && token.value === value; },\n    };\n}\nfunction name(style) {\n    return {\n        style: style,\n        match: function (token) { return token.kind === 'Name'; },\n        update: function (state, token) {\n            state.name = token.value;\n        },\n    };\n}\nfunction type(style) {\n    return {\n        style: style,\n        match: function (token) { return token.kind === 'Name'; },\n        update: function (state, token) {\n            if (state.prevState && state.prevState.prevState) {\n                state.name = token.value;\n                state.prevState.prevState.type = token.value;\n            }\n        },\n    };\n}\n//# sourceMappingURL=Rules.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nfunction opt(ofRule) {\n    return { ofRule: ofRule };\n}\nexports.opt = opt;\nfunction list(ofRule, separator) {\n    return { ofRule: ofRule, isList: true, separator: separator };\n}\nexports.list = list;\nfunction butNot(rule, exclusions) {\n    var ruleMatch = rule.match;\n    rule.match = function (token) {\n        var check = false;\n        if (ruleMatch) {\n            check = ruleMatch(token);\n        }\n        return (check &&\n            exclusions.every(function (exclusion) { return exclusion.match && !exclusion.match(token); }));\n    };\n    return rule;\n}\nexports.butNot = butNot;\nfunction t(kind, style) {\n    return { style: style, match: function (token) { return token.kind === kind; } };\n}\nexports.t = t;\nfunction p(value, style) {\n    return {\n        style: style || 'punctuation',\n        match: function (token) {\n            return token.kind === 'Punctuation' && token.value === value;\n        },\n    };\n}\nexports.p = p;\n//# sourceMappingURL=RuleHelpers.js.map","\"use strict\";\nvar __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n    return new (P || (P = Promise))(function (resolve, reject) {\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\n    });\n};\nvar __generator = (this && this.__generator) || function (thisArg, body) {\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\n    function verb(n) { return function (v) { return step([n, v]); }; }\n    function step(op) {\n        if (f) throw new TypeError(\"Generator is already executing.\");\n        while (_) try {\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\n            if (y = 0, t) op = [op[0] & 2, t.value];\n            switch (op[0]) {\n                case 0: case 1: t = op; break;\n                case 4: _.label++; return { value: op[1], done: false };\n                case 5: _.label++; y = op[1]; op = [0]; continue;\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\n                default:\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\n                    if (t[2]) _.ops.pop();\n                    _.trys.pop(); continue;\n            }\n            op = body.call(thisArg, _);\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\n    }\n};\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar graphql_language_service_utils_1 = require(\"graphql-language-service-utils\");\nvar assert_1 = __importDefault(require(\"assert\"));\nexports.LANGUAGE = 'GraphQL';\nfunction getRange(text, node) {\n    var location = node.loc;\n    assert_1.default(location, 'Expected ASTNode to have a location.');\n    return graphql_language_service_utils_1.locToRange(text, location);\n}\nfunction getPosition(text, node) {\n    var location = node.loc;\n    assert_1.default(location, 'Expected ASTNode to have a location.');\n    return graphql_language_service_utils_1.offsetToPosition(text, location.start);\n}\nfunction getDefinitionQueryResultForNamedType(text, node, dependencies) {\n    return __awaiter(this, void 0, void 0, function () {\n        var name, defNodes, definitions;\n        return __generator(this, function (_a) {\n            name = node.name.value;\n            defNodes = dependencies.filter(function (_a) {\n                var definition = _a.definition;\n                return definition.name && definition.name.value === name;\n            });\n            if (defNodes.length === 0) {\n                throw Error(\"Definition not found for GraphQL type \" + name);\n            }\n            definitions = defNodes.map(function (_a) {\n                var filePath = _a.filePath, content = _a.content, definition = _a.definition;\n                return getDefinitionForNodeDefinition(filePath || '', content, definition);\n            });\n            return [2, {\n                    definitions: definitions,\n                    queryRange: definitions.map(function (_) { return getRange(text, node); }),\n                }];\n        });\n    });\n}\nexports.getDefinitionQueryResultForNamedType = getDefinitionQueryResultForNamedType;\nfunction getDefinitionQueryResultForFragmentSpread(text, fragment, dependencies) {\n    return __awaiter(this, void 0, void 0, function () {\n        var name, defNodes, definitions;\n        return __generator(this, function (_a) {\n            name = fragment.name.value;\n            defNodes = dependencies.filter(function (_a) {\n                var definition = _a.definition;\n                return definition.name.value === name;\n            });\n            if (defNodes.length === 0) {\n                throw Error(\"Definition not found for GraphQL fragment \" + name);\n            }\n            definitions = defNodes.map(function (_a) {\n                var filePath = _a.filePath, content = _a.content, definition = _a.definition;\n                return getDefinitionForFragmentDefinition(filePath || '', content, definition);\n            });\n            return [2, {\n                    definitions: definitions,\n                    queryRange: definitions.map(function (_) { return getRange(text, fragment); }),\n                }];\n        });\n    });\n}\nexports.getDefinitionQueryResultForFragmentSpread = getDefinitionQueryResultForFragmentSpread;\nfunction getDefinitionQueryResultForDefinitionNode(path, text, definition) {\n    return {\n        definitions: [getDefinitionForFragmentDefinition(path, text, definition)],\n        queryRange: definition.name ? [getRange(text, definition.name)] : [],\n    };\n}\nexports.getDefinitionQueryResultForDefinitionNode = getDefinitionQueryResultForDefinitionNode;\nfunction getDefinitionForFragmentDefinition(path, text, definition) {\n    var name = definition.name;\n    if (!name) {\n        throw Error('Expected ASTNode to have a Name.');\n    }\n    return {\n        path: path,\n        position: getPosition(text, definition),\n        range: getRange(text, definition),\n        name: name.value || '',\n        language: exports.LANGUAGE,\n        projectRoot: path,\n    };\n}\nfunction getDefinitionForNodeDefinition(path, text, definition) {\n    var name = definition.name;\n    assert_1.default(name, 'Expected ASTNode to have a Name.');\n    return {\n        path: path,\n        position: getPosition(text, definition),\n        range: getRange(text, definition),\n        name: name.value || '',\n        language: exports.LANGUAGE,\n        projectRoot: path,\n    };\n}\n//# sourceMappingURL=getDefinition.js.map","\"use strict\";\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nvar _a;\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar assert_1 = __importDefault(require(\"assert\"));\nvar graphql_1 = require(\"graphql\");\nvar graphql_language_service_parser_1 = require(\"graphql-language-service-parser\");\nvar graphql_language_service_utils_1 = require(\"graphql-language-service-utils\");\nexports.SEVERITY = {\n    Error: 'Error',\n    Warning: 'Warning',\n    Information: 'Information',\n    Hint: 'Hint',\n};\nexports.DIAGNOSTIC_SEVERITY = (_a = {},\n    _a[exports.SEVERITY.Error] = 1,\n    _a[exports.SEVERITY.Warning] = 2,\n    _a[exports.SEVERITY.Information] = 3,\n    _a[exports.SEVERITY.Hint] = 4,\n    _a);\nfunction getDiagnostics(query, schema, customRules, isRelayCompatMode) {\n    if (schema === void 0) { schema = null; }\n    var ast = null;\n    try {\n        ast = graphql_1.parse(query);\n    }\n    catch (error) {\n        var range = getRange(error.locations[0], query);\n        return [\n            {\n                severity: exports.DIAGNOSTIC_SEVERITY.Error,\n                message: error.message,\n                source: 'GraphQL: Syntax',\n                range: range,\n            },\n        ];\n    }\n    return validateQuery(ast, schema, customRules, isRelayCompatMode);\n}\nexports.getDiagnostics = getDiagnostics;\nfunction validateQuery(ast, schema, customRules, isRelayCompatMode) {\n    if (schema === void 0) { schema = null; }\n    if (!schema) {\n        return [];\n    }\n    var validationErrorAnnotations = mapCat(graphql_language_service_utils_1.validateWithCustomRules(schema, ast, customRules, isRelayCompatMode), function (error) { return annotations(error, exports.DIAGNOSTIC_SEVERITY.Error, 'Validation'); });\n    var deprecationWarningAnnotations = !graphql_1.findDeprecatedUsages\n        ? []\n        : mapCat(graphql_1.findDeprecatedUsages(schema, ast), function (error) {\n            return annotations(error, exports.DIAGNOSTIC_SEVERITY.Warning, 'Deprecation');\n        });\n    return validationErrorAnnotations.concat(deprecationWarningAnnotations);\n}\nexports.validateQuery = validateQuery;\nfunction mapCat(array, mapper) {\n    return Array.prototype.concat.apply([], array.map(mapper));\n}\nfunction annotations(error, severity, type) {\n    if (!error.nodes) {\n        return [];\n    }\n    var highlightedNodes = [];\n    error.nodes.forEach(function (node) {\n        var highlightNode = node.kind !== 'Variable' && 'name' in node && node.name !== undefined\n            ? node.name\n            : 'variable' in node && node.variable !== undefined\n                ? node.variable\n                : node;\n        if (highlightNode) {\n            assert_1.default(error.locations, 'GraphQL validation error requires locations.');\n            var loc = error.locations[0];\n            var highlightLoc = getLocation(highlightNode);\n            var end = loc.column + (highlightLoc.end - highlightLoc.start);\n            highlightedNodes.push({\n                source: \"GraphQL: \" + type,\n                message: error.message,\n                severity: severity,\n                range: new graphql_language_service_utils_1.Range(new graphql_language_service_utils_1.Position(loc.line - 1, loc.column - 1), new graphql_language_service_utils_1.Position(loc.line - 1, end)),\n            });\n        }\n    });\n    return highlightedNodes;\n}\nfunction getRange(location, queryText) {\n    var parser = graphql_language_service_parser_1.onlineParser();\n    var state = parser.startState();\n    var lines = queryText.split('\\n');\n    assert_1.default(lines.length >= location.line, 'Query text must have more lines than where the error happened');\n    var stream = null;\n    for (var i = 0; i < location.line; i++) {\n        stream = new graphql_language_service_parser_1.CharacterStream(lines[i]);\n        while (!stream.eol()) {\n            var style = parser.token(stream, state);\n            if (style === 'invalidchar') {\n                break;\n            }\n        }\n    }\n    assert_1.default(stream, 'Expected Parser stream to be available.');\n    var line = location.line - 1;\n    var start = stream.getStartOfToken();\n    var end = stream.getCurrentPosition();\n    return new graphql_language_service_utils_1.Range(new graphql_language_service_utils_1.Position(line, start), new graphql_language_service_utils_1.Position(line, end));\n}\nexports.getRange = getRange;\nfunction getLocation(node) {\n    var typeCastedNode = node;\n    var location = typeCastedNode.loc;\n    assert_1.default(location, 'Expected ASTNode to have a location.');\n    return location;\n}\n//# sourceMappingURL=getDiagnostics.js.map","\"use strict\";\nvar __assign = (this && this.__assign) || function () {\n    __assign = Object.assign || function(t) {\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\n            s = arguments[i];\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))\n                t[p] = s[p];\n        }\n        return t;\n    };\n    return __assign.apply(this, arguments);\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar graphql_1 = require(\"graphql\");\nvar graphql_language_service_utils_1 = require(\"graphql-language-service-utils\");\nvar INLINE_FRAGMENT = graphql_1.Kind.INLINE_FRAGMENT;\nvar OUTLINEABLE_KINDS = {\n    Field: true,\n    OperationDefinition: true,\n    Document: true,\n    SelectionSet: true,\n    Name: true,\n    FragmentDefinition: true,\n    FragmentSpread: true,\n    InlineFragment: true,\n    ObjectTypeDefinition: true,\n    InputObjectTypeDefinition: true,\n    InterfaceTypeDefinition: true,\n    EnumTypeDefinition: true,\n    EnumValueDefinition: true,\n    InputValueDefinition: true,\n    FieldDefinition: true,\n};\nfunction getOutline(documentText) {\n    var ast;\n    try {\n        ast = graphql_1.parse(documentText);\n    }\n    catch (error) {\n        return null;\n    }\n    var visitorFns = outlineTreeConverter(documentText);\n    var outlineTrees = graphql_1.visit(ast, {\n        leave: function (node) {\n            if (visitorFns !== undefined && node.kind in visitorFns) {\n                return visitorFns[node.kind](node);\n            }\n            return null;\n        },\n    });\n    return { outlineTrees: outlineTrees };\n}\nexports.getOutline = getOutline;\nfunction outlineTreeConverter(docText) {\n    var meta = function (node) {\n        return {\n            representativeName: node.name,\n            startPosition: graphql_language_service_utils_1.offsetToPosition(docText, node.loc.start),\n            endPosition: graphql_language_service_utils_1.offsetToPosition(docText, node.loc.end),\n            kind: node.kind,\n            children: node.selectionSet || node.fields || node.values || node.arguments || [],\n        };\n    };\n    return {\n        Field: function (node) {\n            var tokenizedText = node.alias\n                ? [buildToken('plain', node.alias), buildToken('plain', ': ')]\n                : [];\n            tokenizedText.push(buildToken('plain', node.name));\n            return __assign({ tokenizedText: tokenizedText }, meta(node));\n        },\n        OperationDefinition: function (node) { return (__assign({ tokenizedText: [\n                buildToken('keyword', node.operation),\n                buildToken('whitespace', ' '),\n                buildToken('class-name', node.name),\n            ] }, meta(node))); },\n        Document: function (node) { return node.definitions; },\n        SelectionSet: function (node) {\n            return concatMap(node.selections, function (child) {\n                return child.kind === INLINE_FRAGMENT ? child.selectionSet : child;\n            });\n        },\n        Name: function (node) { return node.value; },\n        FragmentDefinition: function (node) { return (__assign({ tokenizedText: [\n                buildToken('keyword', 'fragment'),\n                buildToken('whitespace', ' '),\n                buildToken('class-name', node.name),\n            ] }, meta(node))); },\n        InterfaceTypeDefinition: function (node) { return (__assign({ tokenizedText: [\n                buildToken('keyword', 'interface'),\n                buildToken('whitespace', ' '),\n                buildToken('class-name', node.name),\n            ] }, meta(node))); },\n        EnumTypeDefinition: function (node) { return (__assign({ tokenizedText: [\n                buildToken('keyword', 'enum'),\n                buildToken('whitespace', ' '),\n                buildToken('class-name', node.name),\n            ] }, meta(node))); },\n        EnumValueDefinition: function (node) { return (__assign({ tokenizedText: [buildToken('plain', node.name)] }, meta(node))); },\n        ObjectTypeDefinition: function (node) { return (__assign({ tokenizedText: [\n                buildToken('keyword', 'type'),\n                buildToken('whitespace', ' '),\n                buildToken('class-name', node.name),\n            ] }, meta(node))); },\n        InputObjectTypeDefinition: function (node) { return (__assign({ tokenizedText: [\n                buildToken('keyword', 'input'),\n                buildToken('whitespace', ' '),\n                buildToken('class-name', node.name),\n            ] }, meta(node))); },\n        FragmentSpread: function (node) { return (__assign({ tokenizedText: [\n                buildToken('plain', '...'),\n                buildToken('class-name', node.name),\n            ] }, meta(node))); },\n        InputValueDefinition: function (node) {\n            return __assign({ tokenizedText: [buildToken('plain', node.name)] }, meta(node));\n        },\n        FieldDefinition: function (node) {\n            return __assign({ tokenizedText: [buildToken('plain', node.name)] }, meta(node));\n        },\n        InlineFragment: function (node) { return node.selectionSet; },\n    };\n}\nfunction buildToken(kind, value) {\n    return { kind: kind, value: value };\n}\nfunction concatMap(arr, fn) {\n    var res = [];\n    for (var i = 0; i < arr.length; i++) {\n        var x = fn(arr[i], i);\n        if (Array.isArray(x)) {\n            res.push.apply(res, x);\n        }\n        else {\n            res.push(x);\n        }\n    }\n    return res;\n}\n//# sourceMappingURL=getOutline.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar graphql_1 = require(\"graphql\");\nvar getAutocompleteSuggestions_1 = require(\"./getAutocompleteSuggestions\");\nfunction getHoverInformation(schema, queryText, cursor, contextToken) {\n    var token = contextToken || getAutocompleteSuggestions_1.getTokenAtPosition(queryText, cursor);\n    if (!schema || !token || !token.state) {\n        return '';\n    }\n    var state = token.state;\n    var kind = state.kind;\n    var step = state.step;\n    var typeInfo = getAutocompleteSuggestions_1.getTypeInfo(schema, token.state);\n    var options = { schema: schema };\n    if ((kind === 'Field' && step === 0 && typeInfo.fieldDef) ||\n        (kind === 'AliasedField' && step === 2 && typeInfo.fieldDef)) {\n        var into = [];\n        renderField(into, typeInfo, options);\n        renderDescription(into, options, typeInfo.fieldDef);\n        return into.join('').trim();\n    }\n    else if (kind === 'Directive' && step === 1 && typeInfo.directiveDef) {\n        var into = [];\n        renderDirective(into, typeInfo, options);\n        renderDescription(into, options, typeInfo.directiveDef);\n        return into.join('').trim();\n    }\n    else if (kind === 'Argument' && step === 0 && typeInfo.argDef) {\n        var into = [];\n        renderArg(into, typeInfo, options);\n        renderDescription(into, options, typeInfo.argDef);\n        return into.join('').trim();\n    }\n    else if (kind === 'EnumValue' &&\n        typeInfo.enumValue &&\n        'description' in typeInfo.enumValue) {\n        var into = [];\n        renderEnumValue(into, typeInfo, options);\n        renderDescription(into, options, typeInfo.enumValue);\n        return into.join('').trim();\n    }\n    else if (kind === 'NamedType' &&\n        typeInfo.type &&\n        'description' in typeInfo.type) {\n        var into = [];\n        renderType(into, typeInfo, options, typeInfo.type);\n        renderDescription(into, options, typeInfo.type);\n        return into.join('').trim();\n    }\n    return '';\n}\nexports.getHoverInformation = getHoverInformation;\nfunction renderField(into, typeInfo, options) {\n    renderQualifiedField(into, typeInfo, options);\n    renderTypeAnnotation(into, typeInfo, options, typeInfo.type);\n}\nfunction renderQualifiedField(into, typeInfo, options) {\n    if (!typeInfo.fieldDef) {\n        return;\n    }\n    var fieldName = typeInfo.fieldDef.name;\n    if (fieldName.slice(0, 2) !== '__') {\n        renderType(into, typeInfo, options, typeInfo.parentType);\n        text(into, '.');\n    }\n    text(into, fieldName);\n}\nfunction renderDirective(into, typeInfo, _options) {\n    if (!typeInfo.directiveDef) {\n        return;\n    }\n    var name = '@' + typeInfo.directiveDef.name;\n    text(into, name);\n}\nfunction renderArg(into, typeInfo, options) {\n    if (typeInfo.directiveDef) {\n        renderDirective(into, typeInfo, options);\n    }\n    else if (typeInfo.fieldDef) {\n        renderQualifiedField(into, typeInfo, options);\n    }\n    if (!typeInfo.argDef) {\n        return;\n    }\n    var name = typeInfo.argDef.name;\n    text(into, '(');\n    text(into, name);\n    renderTypeAnnotation(into, typeInfo, options, typeInfo.inputType);\n    text(into, ')');\n}\nfunction renderTypeAnnotation(into, typeInfo, options, t) {\n    text(into, ': ');\n    renderType(into, typeInfo, options, t);\n}\nfunction renderEnumValue(into, typeInfo, options) {\n    if (!typeInfo.enumValue) {\n        return;\n    }\n    var name = typeInfo.enumValue.name;\n    renderType(into, typeInfo, options, typeInfo.inputType);\n    text(into, '.');\n    text(into, name);\n}\nfunction renderType(into, typeInfo, options, t) {\n    if (!t) {\n        return;\n    }\n    if (t instanceof graphql_1.GraphQLNonNull) {\n        renderType(into, typeInfo, options, t.ofType);\n        text(into, '!');\n    }\n    else if (t instanceof graphql_1.GraphQLList) {\n        text(into, '[');\n        renderType(into, typeInfo, options, t.ofType);\n        text(into, ']');\n    }\n    else {\n        text(into, t.name);\n    }\n}\nfunction renderDescription(into, options, def) {\n    if (!def) {\n        return;\n    }\n    var description = typeof def.description === 'string' ? def.description : null;\n    if (description) {\n        text(into, '\\n\\n');\n        text(into, description);\n    }\n    renderDeprecation(into, options, def);\n}\nfunction renderDeprecation(into, _options, def) {\n    if (!def) {\n        return;\n    }\n    var reason = def.deprecationReason ? def.deprecationReason : null;\n    if (!reason) {\n        return;\n    }\n    text(into, '\\n\\n');\n    text(into, 'Deprecated: ');\n    text(into, reason);\n}\nfunction text(into, content) {\n    into.push(content);\n}\n//# sourceMappingURL=getHoverInformation.js.map","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.default = getTypeInfo;\n\nvar _graphql = require(\"graphql\");\n\nvar _introspection = require(\"graphql/type/introspection\");\n\nvar _forEachState = _interopRequireDefault(require(\"./forEachState\"));\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\n/**\n *  Copyright (c) 2019 GraphQL Contributors\n *  All rights reserved.\n *\n *  This source code is licensed under the BSD-style license found in the\n *  LICENSE file in the root directory of this source tree. An additional grant\n *  of patent rights can be found in the PATENTS file in the same directory.\n */\n\n/**\n * Utility for collecting rich type information given any token's state\n * from the graphql-mode parser.\n */\nfunction getTypeInfo(schema, tokenState) {\n  const info = {\n    schema,\n    type: null,\n    parentType: null,\n    inputType: null,\n    directiveDef: null,\n    fieldDef: null,\n    argDef: null,\n    argDefs: null,\n    objectFieldDefs: null\n  };\n  (0, _forEachState.default)(tokenState, state => {\n    switch (state.kind) {\n      case 'Query':\n      case 'ShortQuery':\n        info.type = schema.getQueryType();\n        break;\n\n      case 'Mutation':\n        info.type = schema.getMutationType();\n        break;\n\n      case 'Subscription':\n        info.type = schema.getSubscriptionType();\n        break;\n\n      case 'InlineFragment':\n      case 'FragmentDefinition':\n        if (state.type) {\n          info.type = schema.getType(state.type);\n        }\n\n        break;\n\n      case 'Field':\n      case 'AliasedField':\n        info.fieldDef = info.type && state.name ? getFieldDef(schema, info.parentType, state.name) : null;\n        info.type = info.fieldDef && info.fieldDef.type;\n        break;\n\n      case 'SelectionSet':\n        info.parentType = (0, _graphql.getNamedType)(info.type);\n        break;\n\n      case 'Directive':\n        info.directiveDef = state.name && schema.getDirective(state.name);\n        break;\n\n      case 'Arguments':\n        const parentDef = state.prevState.kind === 'Field' ? info.fieldDef : state.prevState.kind === 'Directive' ? info.directiveDef : state.prevState.kind === 'AliasedField' ? state.prevState.name && getFieldDef(schema, info.parentType, state.prevState.name) : null;\n        info.argDefs = parentDef && parentDef.args;\n        break;\n\n      case 'Argument':\n        info.argDef = null;\n\n        if (info.argDefs) {\n          for (let i = 0; i < info.argDefs.length; i++) {\n            if (info.argDefs[i].name === state.name) {\n              info.argDef = info.argDefs[i];\n              break;\n            }\n          }\n        }\n\n        info.inputType = info.argDef && info.argDef.type;\n        break;\n\n      case 'EnumValue':\n        const enumType = (0, _graphql.getNamedType)(info.inputType);\n        info.enumValue = enumType instanceof _graphql.GraphQLEnumType ? find(enumType.getValues(), val => val.value === state.name) : null;\n        break;\n\n      case 'ListValue':\n        const nullableType = (0, _graphql.getNullableType)(info.inputType);\n        info.inputType = nullableType instanceof _graphql.GraphQLList ? nullableType.ofType : null;\n        break;\n\n      case 'ObjectValue':\n        const objectType = (0, _graphql.getNamedType)(info.inputType);\n        info.objectFieldDefs = objectType instanceof _graphql.GraphQLInputObjectType ? objectType.getFields() : null;\n        break;\n\n      case 'ObjectField':\n        const objectField = state.name && info.objectFieldDefs ? info.objectFieldDefs[state.name] : null;\n        info.inputType = objectField && objectField.type;\n        break;\n\n      case 'NamedType':\n        info.type = schema.getType(state.name);\n        break;\n    }\n  });\n  return info;\n} // Gets the field definition given a type and field name\n\n\nfunction getFieldDef(schema, type, fieldName) {\n  if (fieldName === _introspection.SchemaMetaFieldDef.name && schema.getQueryType() === type) {\n    return _introspection.SchemaMetaFieldDef;\n  }\n\n  if (fieldName === _introspection.TypeMetaFieldDef.name && schema.getQueryType() === type) {\n    return _introspection.TypeMetaFieldDef;\n  }\n\n  if (fieldName === _introspection.TypeNameMetaFieldDef.name && (0, _graphql.isCompositeType)(type)) {\n    return _introspection.TypeNameMetaFieldDef;\n  }\n\n  if (type.getFields) {\n    return type.getFields()[fieldName];\n  }\n} // Returns the first item in the array which causes predicate to return truthy.\n\n\nfunction find(array, predicate) {\n  for (let i = 0; i < array.length; i++) {\n    if (predicate(array[i])) {\n      return array[i];\n    }\n  }\n}","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.default = forEachState;\n\n/**\n *  Copyright (c) 2019 GraphQL Contributors\n *  All rights reserved.\n *\n *  This source code is licensed under the BSD-style license found in the\n *  LICENSE file in the root directory of this source tree. An additional grant\n *  of patent rights can be found in the PATENTS file in the same directory.\n */\n// Utility for iterating through a CodeMirror parse state stack bottom-up.\nfunction forEachState(stack, fn) {\n  const reverseStateStack = [];\n  let state = stack;\n\n  while (state && state.kind) {\n    reverseStateStack.push(state);\n    state = state.prevState;\n  }\n\n  for (let i = reverseStateStack.length - 1; i >= 0; i--) {\n    fn(reverseStateStack[i]);\n  }\n}","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.getFieldReference = getFieldReference;\nexports.getDirectiveReference = getDirectiveReference;\nexports.getArgumentReference = getArgumentReference;\nexports.getEnumValueReference = getEnumValueReference;\nexports.getTypeReference = getTypeReference;\n\nvar _graphql = require(\"graphql\");\n\n/**\n *  Copyright (c) 2019 GraphQL Contributors\n *  All rights reserved.\n *\n *  This source code is licensed under the BSD-style license found in the\n *  LICENSE file in the root directory of this source tree. An additional grant\n *  of patent rights can be found in the PATENTS file in the same directory.\n */\nfunction getFieldReference(typeInfo) {\n  return {\n    kind: 'Field',\n    schema: typeInfo.schema,\n    field: typeInfo.fieldDef,\n    type: isMetaField(typeInfo.fieldDef) ? null : typeInfo.parentType\n  };\n}\n\nfunction getDirectiveReference(typeInfo) {\n  return {\n    kind: 'Directive',\n    schema: typeInfo.schema,\n    directive: typeInfo.directiveDef\n  };\n}\n\nfunction getArgumentReference(typeInfo) {\n  return typeInfo.directiveDef ? {\n    kind: 'Argument',\n    schema: typeInfo.schema,\n    argument: typeInfo.argDef,\n    directive: typeInfo.directiveDef\n  } : {\n    kind: 'Argument',\n    schema: typeInfo.schema,\n    argument: typeInfo.argDef,\n    field: typeInfo.fieldDef,\n    type: isMetaField(typeInfo.fieldDef) ? null : typeInfo.parentType\n  };\n}\n\nfunction getEnumValueReference(typeInfo) {\n  return {\n    kind: 'EnumValue',\n    value: typeInfo.enumValue,\n    // $FlowFixMe\n    type: (0, _graphql.getNamedType)(typeInfo.inputType)\n  };\n} // Note: for reusability, getTypeReference can produce a reference to any type,\n// though it defaults to the current type.\n\n\nfunction getTypeReference(typeInfo, type) {\n  return {\n    kind: 'Type',\n    schema: typeInfo.schema,\n    type: type || typeInfo.type\n  };\n}\n\nfunction isMetaField(fieldDef) {\n  return fieldDef.name.slice(0, 2) === '__';\n}","\"use strict\";\n\nvar _codemirror = _interopRequireDefault(require(\"codemirror\"));\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\n/**\n *  Copyright (c) 2019 GraphQL Contributors\n *  All rights reserved.\n *\n *  This source code is licensed under the BSD-style license found in the\n *  LICENSE file in the root directory of this source tree. An additional grant\n *  of patent rights can be found in the PATENTS file in the same directory.\n */\n_codemirror.default.defineOption('info', false, (cm, options, old) => {\n  if (old && old !== _codemirror.default.Init) {\n    const oldOnMouseOver = cm.state.info.onMouseOver;\n\n    _codemirror.default.off(cm.getWrapperElement(), 'mouseover', oldOnMouseOver);\n\n    clearTimeout(cm.state.info.hoverTimeout);\n    delete cm.state.info;\n  }\n\n  if (options) {\n    const state = cm.state.info = createState(options);\n    state.onMouseOver = onMouseOver.bind(null, cm);\n\n    _codemirror.default.on(cm.getWrapperElement(), 'mouseover', state.onMouseOver);\n  }\n});\n\nfunction createState(options) {\n  return {\n    options: options instanceof Function ? {\n      render: options\n    } : options === true ? {} : options\n  };\n}\n\nfunction getHoverTime(cm) {\n  const options = cm.state.info.options;\n  return options && options.hoverTime || 500;\n}\n\nfunction onMouseOver(cm, e) {\n  const state = cm.state.info;\n  const target = e.target || e.srcElement;\n\n  if (target.nodeName !== 'SPAN' || state.hoverTimeout !== undefined) {\n    return;\n  }\n\n  const box = target.getBoundingClientRect();\n\n  const onMouseMove = function () {\n    clearTimeout(state.hoverTimeout);\n    state.hoverTimeout = setTimeout(onHover, hoverTime);\n  };\n\n  const onMouseOut = function () {\n    _codemirror.default.off(document, 'mousemove', onMouseMove);\n\n    _codemirror.default.off(cm.getWrapperElement(), 'mouseout', onMouseOut);\n\n    clearTimeout(state.hoverTimeout);\n    state.hoverTimeout = undefined;\n  };\n\n  const onHover = function () {\n    _codemirror.default.off(document, 'mousemove', onMouseMove);\n\n    _codemirror.default.off(cm.getWrapperElement(), 'mouseout', onMouseOut);\n\n    state.hoverTimeout = undefined;\n    onMouseHover(cm, box);\n  };\n\n  const hoverTime = getHoverTime(cm);\n  state.hoverTimeout = setTimeout(onHover, hoverTime);\n\n  _codemirror.default.on(document, 'mousemove', onMouseMove);\n\n  _codemirror.default.on(cm.getWrapperElement(), 'mouseout', onMouseOut);\n}\n\nfunction onMouseHover(cm, box) {\n  const pos = cm.coordsChar({\n    left: (box.left + box.right) / 2,\n    top: (box.top + box.bottom) / 2\n  });\n  const state = cm.state.info;\n  const options = state.options;\n  const render = options.render || cm.getHelper(pos, 'info');\n\n  if (render) {\n    const token = cm.getTokenAt(pos, true);\n\n    if (token) {\n      const info = render(token, options, cm, pos);\n\n      if (info) {\n        showPopup(cm, box, info);\n      }\n    }\n  }\n}\n\nfunction showPopup(cm, box, info) {\n  const popup = document.createElement('div');\n  popup.className = 'CodeMirror-info';\n  popup.appendChild(info);\n  document.body.appendChild(popup);\n  const popupBox = popup.getBoundingClientRect();\n  const popupStyle = popup.currentStyle || window.getComputedStyle(popup);\n  const popupWidth = popupBox.right - popupBox.left + parseFloat(popupStyle.marginLeft) + parseFloat(popupStyle.marginRight);\n  const popupHeight = popupBox.bottom - popupBox.top + parseFloat(popupStyle.marginTop) + parseFloat(popupStyle.marginBottom);\n  let topPos = box.bottom;\n\n  if (popupHeight > window.innerHeight - box.bottom - 15 && box.top > window.innerHeight - box.bottom) {\n    topPos = box.top - popupHeight;\n  }\n\n  if (topPos < 0) {\n    topPos = box.bottom;\n  }\n\n  let leftPos = Math.max(0, window.innerWidth - popupWidth - 15);\n\n  if (leftPos > box.left) {\n    leftPos = box.left;\n  }\n\n  popup.style.opacity = 1;\n  popup.style.top = topPos + 'px';\n  popup.style.left = leftPos + 'px';\n  let popupTimeout;\n\n  const onMouseOverPopup = function () {\n    clearTimeout(popupTimeout);\n  };\n\n  const onMouseOut = function () {\n    clearTimeout(popupTimeout);\n    popupTimeout = setTimeout(hidePopup, 200);\n  };\n\n  const hidePopup = function () {\n    _codemirror.default.off(popup, 'mouseover', onMouseOverPopup);\n\n    _codemirror.default.off(popup, 'mouseout', onMouseOut);\n\n    _codemirror.default.off(cm.getWrapperElement(), 'mouseout', onMouseOut);\n\n    if (popup.style.opacity) {\n      popup.style.opacity = 0;\n      setTimeout(() => {\n        if (popup.parentNode) {\n          popup.parentNode.removeChild(popup);\n        }\n      }, 600);\n    } else if (popup.parentNode) {\n      popup.parentNode.removeChild(popup);\n    }\n  };\n\n  _codemirror.default.on(popup, 'mouseover', onMouseOverPopup);\n\n  _codemirror.default.on(popup, 'mouseout', onMouseOut);\n\n  _codemirror.default.on(cm.getWrapperElement(), 'mouseout', onMouseOut);\n}","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.default = DefaultValue;\n\nvar _react = _interopRequireDefault(require(\"react\"));\n\nvar _propTypes = _interopRequireDefault(require(\"prop-types\"));\n\nvar _graphql = require(\"graphql\");\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\n/**\n *  Copyright (c) 2019 GraphQL Contributors.\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 */\nfunction DefaultValue({\n  field\n}) {\n  const {\n    type,\n    defaultValue\n  } = field;\n\n  if (defaultValue !== undefined) {\n    return _react.default.createElement(\"span\", null, ' = ', _react.default.createElement(\"span\", {\n      className: \"arg-default-value\"\n    }, (0, _graphql.print)((0, _graphql.astFromValue)(defaultValue, type))));\n  }\n\n  return null;\n}\n\nDefaultValue.propTypes = {\n  field: _propTypes.default.object.isRequired\n};","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.default = debounce;\n\n/**\n *  Copyright (c) 2019 GraphQL Contributors.\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/**\n * Provided a duration and a function, returns a new function which is called\n * `duration` milliseconds after the last call.\n */\nfunction debounce(duration, fn) {\n  let timeout;\n  return function () {\n    clearTimeout(timeout);\n    timeout = setTimeout(() => {\n      timeout = null;\n      fn.apply(this, arguments);\n    }, duration);\n  };\n}","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.default = void 0;\n\nrequire(\"regenerator-runtime/runtime\");\n\nvar _GraphiQL = require(\"./components/GraphiQL\");\n\n/**\n *  Copyright (c) 2019 GraphQL Contributors.\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 */\nvar _default = _GraphiQL.GraphiQL;\nexports.default = _default;","/**\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 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  GeneratorFunctionPrototype[toStringTagSymbol] =\n    GeneratorFunction.displayName = \"GeneratorFunction\";\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      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      if (!(toStringTagSymbol in genFun)) {\n        genFun[toStringTagSymbol] = \"GeneratorFunction\";\n      }\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) {\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 Promise.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 Promise.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 Promise(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) {\n    var iter = new AsyncIterator(\n      wrap(innerFn, outerFn, self, tryLocsList)\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  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","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.GraphiQL = void 0;\n\nvar _react = _interopRequireDefault(require(\"react\"));\n\nvar _propTypes = _interopRequireDefault(require(\"prop-types\"));\n\nvar _reactDom = _interopRequireDefault(require(\"react-dom\"));\n\nvar _graphql = require(\"graphql\");\n\nvar _copyToClipboard = _interopRequireDefault(require(\"copy-to-clipboard\"));\n\nvar _ExecuteButton = require(\"./ExecuteButton\");\n\nvar _ImagePreview = require(\"./ImagePreview\");\n\nvar _ToolbarButton = require(\"./ToolbarButton\");\n\nvar _ToolbarGroup = require(\"./ToolbarGroup\");\n\nvar _ToolbarMenu = require(\"./ToolbarMenu\");\n\nvar _ToolbarSelect = require(\"./ToolbarSelect\");\n\nvar _QueryEditor = require(\"./QueryEditor\");\n\nvar _VariableEditor = require(\"./VariableEditor\");\n\nvar _ResultViewer = require(\"./ResultViewer\");\n\nvar _DocExplorer = require(\"./DocExplorer\");\n\nvar _QueryHistory = require(\"./QueryHistory\");\n\nvar _CodeMirrorSizer = _interopRequireDefault(require(\"../utility/CodeMirrorSizer\"));\n\nvar _StorageAPI = _interopRequireDefault(require(\"../utility/StorageAPI\"));\n\nvar _getQueryFacts = _interopRequireDefault(require(\"../utility/getQueryFacts\"));\n\nvar _getSelectedOperationName = _interopRequireDefault(require(\"../utility/getSelectedOperationName\"));\n\nvar _debounce = _interopRequireDefault(require(\"../utility/debounce\"));\n\nvar _find = _interopRequireDefault(require(\"../utility/find\"));\n\nvar _fillLeafs = require(\"../utility/fillLeafs\");\n\nvar _elementPosition = require(\"../utility/elementPosition\");\n\nvar _mergeAst = require(\"../utility/mergeAst\");\n\nvar _introspectionQueries = require(\"../utility/introspectionQueries\");\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\nconst DEFAULT_DOC_EXPLORER_WIDTH = 350;\n/**\n * The top-level React component for GraphiQL, intended to encompass the entire\n * browser viewport.\n *\n * @see https://github.com/graphql/graphiql#usage\n */\n\nclass GraphiQL extends _react.default.Component {\n  constructor(props) {\n    super(props); // Ensure props are correct\n\n    _defineProperty(this, \"handleClickReference\", reference => {\n      this.setState({\n        docExplorerOpen: true\n      }, () => {\n        this.docExplorerComponent.showDocForReference(reference);\n      });\n    });\n\n    _defineProperty(this, \"handleRunQuery\", selectedOperationName => {\n      this._editorQueryID++;\n      const queryID = this._editorQueryID; // Use the edited query after autoCompleteLeafs() runs or,\n      // in case autoCompletion fails (the function returns undefined),\n      // the current query from the editor.\n\n      const editedQuery = this.autoCompleteLeafs() || this.state.query;\n      const variables = this.state.variables;\n      let operationName = this.state.operationName; // If an operation was explicitly provided, different from the current\n      // operation name, then report that it changed.\n\n      if (selectedOperationName && selectedOperationName !== operationName) {\n        operationName = selectedOperationName;\n        this.handleEditOperationName(operationName);\n      }\n\n      try {\n        this.setState({\n          isWaitingForResponse: true,\n          response: null,\n          operationName\n        }); // _fetchQuery may return a subscription.\n\n        const subscription = this._fetchQuery(editedQuery, variables, operationName, result => {\n          if (queryID === this._editorQueryID) {\n            this.setState({\n              isWaitingForResponse: false,\n              response: GraphiQL.formatResult(result)\n            });\n          }\n        });\n\n        this.setState({\n          subscription\n        });\n      } catch (error) {\n        this.setState({\n          isWaitingForResponse: false,\n          response: error.message\n        });\n      }\n    });\n\n    _defineProperty(this, \"handleStopQuery\", () => {\n      const subscription = this.state.subscription;\n      this.setState({\n        isWaitingForResponse: false,\n        subscription: null\n      });\n\n      if (subscription) {\n        subscription.unsubscribe();\n      }\n    });\n\n    _defineProperty(this, \"handlePrettifyQuery\", () => {\n      const editor = this.getQueryEditor();\n      const editorContent = editor.getValue();\n      const prettifiedEditorContent = (0, _graphql.print)((0, _graphql.parse)(editorContent));\n\n      if (prettifiedEditorContent !== editorContent) {\n        editor.setValue(prettifiedEditorContent);\n      }\n\n      const variableEditor = this.getVariableEditor();\n      const variableEditorContent = variableEditor.getValue();\n\n      try {\n        const prettifiedVariableEditorContent = JSON.stringify(JSON.parse(variableEditorContent), null, 2);\n\n        if (prettifiedVariableEditorContent !== variableEditorContent) {\n          variableEditor.setValue(prettifiedVariableEditorContent);\n        }\n      } catch {\n        /* Parsing JSON failed, skip prettification */\n      }\n    });\n\n    _defineProperty(this, \"handleMergeQuery\", () => {\n      const editor = this.getQueryEditor();\n      const query = editor.getValue();\n\n      if (!query) {\n        return;\n      }\n\n      const ast = (0, _graphql.parse)(query);\n      editor.setValue((0, _graphql.print)((0, _mergeAst.mergeAst)(ast)));\n    });\n\n    _defineProperty(this, \"handleEditQuery\", (0, _debounce.default)(100, value => {\n      const queryFacts = this._updateQueryFacts(value, this.state.operationName, this.state.operations, this.state.schema);\n\n      this.setState({\n        query: value,\n        ...queryFacts\n      });\n\n      if (this.props.onEditQuery) {\n        return this.props.onEditQuery(value);\n      }\n    }));\n\n    _defineProperty(this, \"handleCopyQuery\", () => {\n      const editor = this.getQueryEditor();\n      const query = editor.getValue();\n\n      if (!query) {\n        return;\n      }\n\n      (0, _copyToClipboard.default)(query);\n\n      if (this.props.onCopyQuery) {\n        return this.props.onCopyQuery(query);\n      }\n    });\n\n    _defineProperty(this, \"_updateQueryFacts\", (query, operationName, prevOperations, schema) => {\n      const queryFacts = (0, _getQueryFacts.default)(schema, query);\n\n      if (queryFacts) {\n        // Update operation name should any query names change.\n        const updatedOperationName = (0, _getSelectedOperationName.default)(prevOperations, operationName, queryFacts.operations); // Report changing of operationName if it changed.\n\n        const onEditOperationName = this.props.onEditOperationName;\n\n        if (onEditOperationName && operationName !== updatedOperationName) {\n          onEditOperationName(updatedOperationName);\n        }\n\n        return {\n          operationName: updatedOperationName,\n          ...queryFacts\n        };\n      }\n    });\n\n    _defineProperty(this, \"handleEditVariables\", value => {\n      this.setState({\n        variables: value\n      });\n\n      if (this.props.onEditVariables) {\n        this.props.onEditVariables(value);\n      }\n    });\n\n    _defineProperty(this, \"handleEditOperationName\", operationName => {\n      const onEditOperationName = this.props.onEditOperationName;\n\n      if (onEditOperationName) {\n        onEditOperationName(operationName);\n      }\n    });\n\n    _defineProperty(this, \"handleHintInformationRender\", elem => {\n      elem.addEventListener('click', this._onClickHintInformation);\n      let onRemoveFn;\n      elem.addEventListener('DOMNodeRemoved', onRemoveFn = () => {\n        elem.removeEventListener('DOMNodeRemoved', onRemoveFn);\n        elem.removeEventListener('click', this._onClickHintInformation);\n      });\n    });\n\n    _defineProperty(this, \"handleEditorRunQuery\", () => {\n      this._runQueryAtCursor();\n    });\n\n    _defineProperty(this, \"_onClickHintInformation\", event => {\n      if (event.target.className === 'typeName') {\n        const typeName = event.target.innerHTML;\n        const schema = this.state.schema;\n\n        if (schema) {\n          const type = schema.getType(typeName);\n\n          if (type) {\n            this.setState({\n              docExplorerOpen: true\n            }, () => {\n              this.docExplorerComponent.showDoc(type);\n            });\n          }\n        }\n      }\n    });\n\n    _defineProperty(this, \"handleToggleDocs\", () => {\n      if (typeof this.props.onToggleDocs === 'function') {\n        this.props.onToggleDocs(!this.state.docExplorerOpen);\n      }\n\n      this.setState({\n        docExplorerOpen: !this.state.docExplorerOpen\n      });\n    });\n\n    _defineProperty(this, \"handleToggleHistory\", () => {\n      if (typeof this.props.onToggleHistory === 'function') {\n        this.props.onToggleHistory(!this.state.historyPaneOpen);\n      }\n\n      this.setState({\n        historyPaneOpen: !this.state.historyPaneOpen\n      });\n    });\n\n    _defineProperty(this, \"handleSelectHistoryQuery\", (query, variables, operationName) => {\n      this.handleEditQuery(query);\n      this.handleEditVariables(variables);\n      this.handleEditOperationName(operationName);\n    });\n\n    _defineProperty(this, \"handleResizeStart\", downEvent => {\n      if (!this._didClickDragBar(downEvent)) {\n        return;\n      }\n\n      downEvent.preventDefault();\n      const offset = downEvent.clientX - (0, _elementPosition.getLeft)(downEvent.target);\n\n      let onMouseMove = moveEvent => {\n        if (moveEvent.buttons === 0) {\n          return onMouseUp();\n        }\n\n        const editorBar = _reactDom.default.findDOMNode(this.editorBarComponent);\n\n        const leftSize = moveEvent.clientX - (0, _elementPosition.getLeft)(editorBar) - offset;\n        const rightSize = editorBar.clientWidth - leftSize;\n        this.setState({\n          editorFlex: leftSize / rightSize\n        });\n      };\n\n      let onMouseUp = () => {\n        document.removeEventListener('mousemove', onMouseMove);\n        document.removeEventListener('mouseup', onMouseUp);\n        onMouseMove = null;\n        onMouseUp = null;\n      };\n\n      document.addEventListener('mousemove', onMouseMove);\n      document.addEventListener('mouseup', onMouseUp);\n    });\n\n    _defineProperty(this, \"handleResetResize\", () => {\n      this.setState({\n        editorFlex: 1\n      });\n    });\n\n    _defineProperty(this, \"handleDocsResizeStart\", downEvent => {\n      downEvent.preventDefault();\n      const hadWidth = this.state.docExplorerWidth;\n      const offset = downEvent.clientX - (0, _elementPosition.getLeft)(downEvent.target);\n\n      let onMouseMove = moveEvent => {\n        if (moveEvent.buttons === 0) {\n          return onMouseUp();\n        }\n\n        const app = _reactDom.default.findDOMNode(this);\n\n        const cursorPos = moveEvent.clientX - (0, _elementPosition.getLeft)(app) - offset;\n        const docsSize = app.clientWidth - cursorPos;\n\n        if (docsSize < 100) {\n          this.setState({\n            docExplorerOpen: false\n          });\n        } else {\n          this.setState({\n            docExplorerOpen: true,\n            docExplorerWidth: Math.min(docsSize, 650)\n          });\n        }\n      };\n\n      let onMouseUp = () => {\n        if (!this.state.docExplorerOpen) {\n          this.setState({\n            docExplorerWidth: hadWidth\n          });\n        }\n\n        document.removeEventListener('mousemove', onMouseMove);\n        document.removeEventListener('mouseup', onMouseUp);\n        onMouseMove = null;\n        onMouseUp = null;\n      };\n\n      document.addEventListener('mousemove', onMouseMove);\n      document.addEventListener('mouseup', onMouseUp);\n    });\n\n    _defineProperty(this, \"handleDocsResetResize\", () => {\n      this.setState({\n        docExplorerWidth: DEFAULT_DOC_EXPLORER_WIDTH\n      });\n    });\n\n    _defineProperty(this, \"handleVariableResizeStart\", downEvent => {\n      downEvent.preventDefault();\n      let didMove = false;\n      const wasOpen = this.state.variableEditorOpen;\n      const hadHeight = this.state.variableEditorHeight;\n      const offset = downEvent.clientY - (0, _elementPosition.getTop)(downEvent.target);\n\n      let onMouseMove = moveEvent => {\n        if (moveEvent.buttons === 0) {\n          return onMouseUp();\n        }\n\n        didMove = true;\n\n        const editorBar = _reactDom.default.findDOMNode(this.editorBarComponent);\n\n        const topSize = moveEvent.clientY - (0, _elementPosition.getTop)(editorBar) - offset;\n        const bottomSize = editorBar.clientHeight - topSize;\n\n        if (bottomSize < 60) {\n          this.setState({\n            variableEditorOpen: false,\n            variableEditorHeight: hadHeight\n          });\n        } else {\n          this.setState({\n            variableEditorOpen: true,\n            variableEditorHeight: bottomSize\n          });\n        }\n      };\n\n      let onMouseUp = () => {\n        if (!didMove) {\n          this.setState({\n            variableEditorOpen: !wasOpen\n          });\n        }\n\n        document.removeEventListener('mousemove', onMouseMove);\n        document.removeEventListener('mouseup', onMouseUp);\n        onMouseMove = null;\n        onMouseUp = null;\n      };\n\n      document.addEventListener('mousemove', onMouseMove);\n      document.addEventListener('mouseup', onMouseUp);\n    });\n\n    if (typeof props.fetcher !== 'function') {\n      throw new TypeError('GraphiQL requires a fetcher function.');\n    } // Cache the storage instance\n\n\n    this._storage = new _StorageAPI.default(props.storage); // Determine the initial query to display.\n\n    const _query = props.query !== undefined ? props.query : this._storage.get('query') !== null ? this._storage.get('query') : props.defaultQuery !== undefined ? props.defaultQuery : defaultQuery; // Get the initial query facts.\n\n\n    const _queryFacts = (0, _getQueryFacts.default)(props.schema, _query); // Determine the initial variables to display.\n\n\n    const _variables = props.variables !== undefined ? props.variables : this._storage.get('variables'); // Determine the initial operationName to use.\n\n\n    const _operationName = props.operationName !== undefined ? props.operationName : (0, _getSelectedOperationName.default)(null, this._storage.get('operationName'), _queryFacts && _queryFacts.operations); // prop can be supplied to open docExplorer initially\n\n\n    let docExplorerOpen = props.docExplorerOpen || false; // but then local storage state overrides it\n\n    if (this._storage.get('docExplorerOpen')) {\n      docExplorerOpen = this._storage.get('docExplorerOpen') === 'true';\n    } // initial variable editor pane open\n\n\n    const variableEditorOpen = props.defaultVariableEditorOpen !== undefined ? props.defaultVariableEditorOpen : Boolean(_variables); // Initialize state\n\n    this.state = {\n      schema: props.schema,\n      query: _query,\n      variables: _variables,\n      operationName: _operationName,\n      docExplorerOpen,\n      response: props.response,\n      editorFlex: Number(this._storage.get('editorFlex')) || 1,\n      variableEditorOpen,\n      variableEditorHeight: Number(this._storage.get('variableEditorHeight')) || 200,\n      historyPaneOpen: this._storage.get('historyPaneOpen') === 'true' || false,\n      docExplorerWidth: Number(this._storage.get('docExplorerWidth')) || DEFAULT_DOC_EXPLORER_WIDTH,\n      isWaitingForResponse: false,\n      subscription: null,\n      ..._queryFacts\n    }; // Ensure only the last executed editor query is rendered.\n\n    this._editorQueryID = 0; // Subscribe to the browser window closing, treating it as an unmount.\n\n    if (typeof window === 'object') {\n      window.addEventListener('beforeunload', () => this.componentWillUnmount());\n    }\n  }\n\n  componentDidMount() {\n    // Only fetch schema via introspection if a schema has not been\n    // provided, including if `null` was provided.\n    if (this.state.schema === undefined) {\n      this._fetchSchema();\n    } // Utility for keeping CodeMirror correctly sized.\n\n\n    this.codeMirrorSizer = new _CodeMirrorSizer.default();\n    global.g = this;\n  }\n\n  componentWillReceiveProps(nextProps) {\n    let nextSchema = this.state.schema;\n    let nextQuery = this.state.query;\n    let nextVariables = this.state.variables;\n    let nextOperationName = this.state.operationName;\n    let nextResponse = this.state.response;\n\n    if (nextProps.schema !== undefined) {\n      nextSchema = nextProps.schema;\n    }\n\n    if (nextProps.query !== undefined) {\n      nextQuery = nextProps.query;\n    }\n\n    if (nextProps.variables !== undefined) {\n      nextVariables = nextProps.variables;\n    }\n\n    if (nextProps.operationName !== undefined) {\n      nextOperationName = nextProps.operationName;\n    }\n\n    if (nextProps.response !== undefined) {\n      nextResponse = nextProps.response;\n    }\n\n    if (nextSchema !== this.state.schema || nextQuery !== this.state.query || nextOperationName !== this.state.operationName) {\n      const updatedQueryAttributes = this._updateQueryFacts(nextQuery, nextOperationName, this.state.operations, nextSchema);\n\n      if (updatedQueryAttributes !== undefined) {\n        nextOperationName = updatedQueryAttributes.operationName;\n        this.setState(updatedQueryAttributes);\n      }\n    } // If schema is not supplied via props and the fetcher changed, then\n    // remove the schema so fetchSchema() will be called with the new fetcher.\n\n\n    if (nextProps.schema === undefined && nextProps.fetcher !== this.props.fetcher) {\n      nextSchema = undefined;\n    }\n\n    this.setState({\n      schema: nextSchema,\n      query: nextQuery,\n      variables: nextVariables,\n      operationName: nextOperationName,\n      response: nextResponse\n    }, () => {\n      if (this.state.schema === undefined) {\n        if (this.docExplorerComponent) {\n          this.docExplorerComponent.reset();\n        }\n\n        this._fetchSchema();\n      }\n    });\n  }\n\n  componentDidUpdate() {\n    // If this update caused DOM nodes to have changed sizes, update the\n    // corresponding CodeMirror instance sizes to match.\n    this.codeMirrorSizer.updateSizes([this.queryEditorComponent, this.variableEditorComponent, this.resultComponent]);\n  } // When the component is about to unmount, store any persistable state, such\n  // that when the component is remounted, it will use the last used values.\n\n\n  componentWillUnmount() {\n    this._storage.set('query', this.state.query);\n\n    this._storage.set('variables', this.state.variables);\n\n    this._storage.set('operationName', this.state.operationName);\n\n    this._storage.set('editorFlex', this.state.editorFlex);\n\n    this._storage.set('variableEditorHeight', this.state.variableEditorHeight);\n\n    this._storage.set('docExplorerWidth', this.state.docExplorerWidth);\n\n    this._storage.set('docExplorerOpen', this.state.docExplorerOpen);\n\n    this._storage.set('historyPaneOpen', this.state.historyPaneOpen);\n  }\n\n  render() {\n    const children = _react.default.Children.toArray(this.props.children);\n\n    const logo = (0, _find.default)(children, child => child.type === GraphiQL.Logo) || _react.default.createElement(GraphiQL.Logo, null);\n\n    const toolbar = (0, _find.default)(children, child => child.type === GraphiQL.Toolbar) || _react.default.createElement(GraphiQL.Toolbar, null, _react.default.createElement(_ToolbarButton.ToolbarButton, {\n      onClick: this.handlePrettifyQuery,\n      title: \"Prettify Query (Shift-Ctrl-P)\",\n      label: \"Prettify\"\n    }), _react.default.createElement(_ToolbarButton.ToolbarButton, {\n      onClick: this.handleMergeQuery,\n      title: \"Merge Query (Shift-Ctrl-M)\",\n      label: \"Merge\"\n    }), _react.default.createElement(_ToolbarButton.ToolbarButton, {\n      onClick: this.handleCopyQuery,\n      title: \"Copy Query (Shift-Ctrl-C)\",\n      label: \"Copy\"\n    }), _react.default.createElement(_ToolbarButton.ToolbarButton, {\n      onClick: this.handleToggleHistory,\n      title: \"Show History\",\n      label: \"History\"\n    }));\n\n    const footer = (0, _find.default)(children, child => child.type === GraphiQL.Footer);\n    const queryWrapStyle = {\n      WebkitFlex: this.state.editorFlex,\n      flex: this.state.editorFlex\n    };\n    const docWrapStyle = {\n      display: 'block',\n      width: this.state.docExplorerWidth\n    };\n    const docExplorerWrapClasses = 'docExplorerWrap' + (this.state.docExplorerWidth < 200 ? ' doc-explorer-narrow' : '');\n    const historyPaneStyle = {\n      display: this.state.historyPaneOpen ? 'block' : 'none',\n      width: '230px',\n      zIndex: '7'\n    };\n    const variableOpen = this.state.variableEditorOpen;\n    const variableStyle = {\n      height: variableOpen ? this.state.variableEditorHeight : null\n    };\n    return _react.default.createElement(\"div\", {\n      className: \"graphiql-container\"\n    }, _react.default.createElement(\"div\", {\n      className: \"historyPaneWrap\",\n      style: historyPaneStyle\n    }, _react.default.createElement(_QueryHistory.QueryHistory, {\n      operationName: this.state.operationName,\n      query: this.state.query,\n      variables: this.state.variables,\n      onSelectQuery: this.handleSelectHistoryQuery,\n      storage: this._storage,\n      queryID: this._editorQueryID\n    }, _react.default.createElement(\"button\", {\n      className: \"docExplorerHide\",\n      onClick: this.handleToggleHistory,\n      \"aria-label\": \"Close History\"\n    }, '\\u2715'))), _react.default.createElement(\"div\", {\n      className: \"editorWrap\"\n    }, _react.default.createElement(\"div\", {\n      className: \"topBarWrap\"\n    }, _react.default.createElement(\"div\", {\n      className: \"topBar\"\n    }, logo, _react.default.createElement(_ExecuteButton.ExecuteButton, {\n      isRunning: Boolean(this.state.subscription),\n      onRun: this.handleRunQuery,\n      onStop: this.handleStopQuery,\n      operations: this.state.operations\n    }), toolbar), !this.state.docExplorerOpen && _react.default.createElement(\"button\", {\n      className: \"docExplorerShow\",\n      onClick: this.handleToggleDocs,\n      \"aria-label\": \"Open Documentation Explorer\"\n    }, 'Docs')), _react.default.createElement(\"div\", {\n      ref: n => {\n        this.editorBarComponent = n;\n      },\n      className: \"editorBar\",\n      onDoubleClick: this.handleResetResize,\n      onMouseDown: this.handleResizeStart\n    }, _react.default.createElement(\"div\", {\n      className: \"queryWrap\",\n      style: queryWrapStyle\n    }, _react.default.createElement(_QueryEditor.QueryEditor, {\n      ref: n => {\n        this.queryEditorComponent = n;\n      },\n      schema: this.state.schema,\n      value: this.state.query,\n      onEdit: this.handleEditQuery,\n      onHintInformationRender: this.handleHintInformationRender,\n      onClickReference: this.handleClickReference,\n      onCopyQuery: this.handleCopyQuery,\n      onPrettifyQuery: this.handlePrettifyQuery,\n      onMergeQuery: this.handleMergeQuery,\n      onRunQuery: this.handleEditorRunQuery,\n      editorTheme: this.props.editorTheme,\n      readOnly: this.props.readOnly\n    }), _react.default.createElement(\"section\", {\n      className: \"variable-editor\",\n      style: variableStyle,\n      \"aria-label\": \"Query Variables\"\n    }, _react.default.createElement(\"div\", {\n      className: \"variable-editor-title\",\n      id: \"variable-editor-title\",\n      style: {\n        cursor: variableOpen ? 'row-resize' : 'n-resize'\n      },\n      onMouseDown: this.handleVariableResizeStart\n    }, 'Query Variables'), _react.default.createElement(_VariableEditor.VariableEditor, {\n      ref: n => {\n        this.variableEditorComponent = n;\n      },\n      value: this.state.variables,\n      variableToType: this.state.variableToType,\n      onEdit: this.handleEditVariables,\n      onHintInformationRender: this.handleHintInformationRender,\n      onPrettifyQuery: this.handlePrettifyQuery,\n      onMergeQuery: this.handleMergeQuery,\n      onRunQuery: this.handleEditorRunQuery,\n      editorTheme: this.props.editorTheme,\n      readOnly: this.props.readOnly\n    }))), _react.default.createElement(\"div\", {\n      className: \"resultWrap\"\n    }, this.state.isWaitingForResponse && _react.default.createElement(\"div\", {\n      className: \"spinner-container\"\n    }, _react.default.createElement(\"div\", {\n      className: \"spinner\"\n    })), _react.default.createElement(_ResultViewer.ResultViewer, {\n      ref: c => {\n        this.resultComponent = c;\n      },\n      value: this.state.response,\n      editorTheme: this.props.editorTheme,\n      ResultsTooltip: this.props.ResultsTooltip,\n      ImagePreview: _ImagePreview.ImagePreview\n    }), footer))), this.state.docExplorerOpen && _react.default.createElement(\"div\", {\n      className: docExplorerWrapClasses,\n      style: docWrapStyle\n    }, _react.default.createElement(\"div\", {\n      className: \"docExplorerResizer\",\n      onDoubleClick: this.handleDocsResetResize,\n      onMouseDown: this.handleDocsResizeStart\n    }), _react.default.createElement(_DocExplorer.DocExplorer, {\n      ref: c => {\n        this.docExplorerComponent = c;\n      },\n      schema: this.state.schema\n    }, _react.default.createElement(\"button\", {\n      className: \"docExplorerHide\",\n      onClick: this.handleToggleDocs,\n      \"aria-label\": \"Close Documentation Explorer\"\n    }, '\\u2715'))));\n  }\n  /**\n   * Get the query editor CodeMirror instance.\n   *\n   * @public\n   */\n\n\n  getQueryEditor() {\n    return this.queryEditorComponent.getCodeMirror();\n  }\n  /**\n   * Get the variable editor CodeMirror instance.\n   *\n   * @public\n   */\n\n\n  getVariableEditor() {\n    return this.variableEditorComponent.getCodeMirror();\n  }\n  /**\n   * Refresh all CodeMirror instances.\n   *\n   * @public\n   */\n\n\n  refresh() {\n    this.queryEditorComponent.getCodeMirror().refresh();\n    this.variableEditorComponent.getCodeMirror().refresh();\n    this.resultComponent.getCodeMirror().refresh();\n  }\n  /**\n   * Inspect the query, automatically filling in selection sets for non-leaf\n   * fields which do not yet have them.\n   *\n   * @public\n   */\n\n\n  autoCompleteLeafs() {\n    const {\n      insertions,\n      result\n    } = (0, _fillLeafs.fillLeafs)(this.state.schema, this.state.query, this.props.getDefaultFieldNames);\n\n    if (insertions && insertions.length > 0) {\n      const editor = this.getQueryEditor();\n      editor.operation(() => {\n        const cursor = editor.getCursor();\n        const cursorIndex = editor.indexFromPos(cursor);\n        editor.setValue(result);\n        let added = 0;\n        const markers = insertions.map(({\n          index,\n          string\n        }) => editor.markText(editor.posFromIndex(index + added), editor.posFromIndex(index + (added += string.length)), {\n          className: 'autoInsertedLeaf',\n          clearOnEnter: true,\n          title: 'Automatically added leaf fields'\n        }));\n        setTimeout(() => markers.forEach(marker => marker.clear()), 7000);\n        let newCursorIndex = cursorIndex;\n        insertions.forEach(({\n          index,\n          string\n        }) => {\n          if (index < cursorIndex) {\n            newCursorIndex += string.length;\n          }\n        });\n        editor.setCursor(editor.posFromIndex(newCursorIndex));\n      });\n    }\n\n    return result;\n  } // Private methods\n\n\n  _fetchSchema() {\n    const fetcher = this.props.fetcher;\n    const fetch = observableToPromise(fetcher({\n      query: _introspectionQueries.introspectionQuery,\n      operationName: _introspectionQueries.introspectionQueryName\n    }));\n\n    if (!isPromise(fetch)) {\n      this.setState({\n        response: 'Fetcher did not return a Promise for introspection.'\n      });\n      return;\n    }\n\n    fetch.then(result => {\n      if (result.data) {\n        return result;\n      } // Try the stock introspection query first, falling back on the\n      // sans-subscriptions query for services which do not yet support it.\n\n\n      const fetch2 = observableToPromise(fetcher({\n        query: _introspectionQueries.introspectionQuerySansSubscriptions,\n        operationName: _introspectionQueries.introspectionQueryName\n      }));\n\n      if (!isPromise(fetch)) {\n        throw new Error('Fetcher did not return a Promise for introspection.');\n      }\n\n      return fetch2;\n    }).then(result => {\n      // If a schema was provided while this fetch was underway, then\n      // satisfy the race condition by respecting the already\n      // provided schema.\n      if (this.state.schema !== undefined) {\n        return;\n      }\n\n      if (result && result.data) {\n        const schema = (0, _graphql.buildClientSchema)(result.data);\n        const queryFacts = (0, _getQueryFacts.default)(schema, this.state.query);\n        this.setState({\n          schema,\n          ...queryFacts\n        });\n      } else {\n        const responseString = typeof result === 'string' ? result : GraphiQL.formatResult(result);\n        this.setState({\n          // Set schema to `null` to explicitly indicate that no schema exists.\n          schema: null,\n          response: responseString\n        });\n      }\n    }).catch(error => {\n      this.setState({\n        schema: null,\n        response: error ? GraphiQL.formatError(error) : null\n      });\n    });\n  }\n\n  _fetchQuery(query, variables, operationName, cb) {\n    const fetcher = this.props.fetcher;\n    let jsonVariables = null;\n\n    try {\n      jsonVariables = variables && variables.trim() !== '' ? JSON.parse(variables) : null;\n    } catch (error) {\n      throw new Error(`Variables are invalid JSON: ${error.message}.`);\n    }\n\n    if (typeof jsonVariables !== 'object') {\n      throw new Error('Variables are not a JSON object.');\n    }\n\n    const fetch = fetcher({\n      query,\n      variables: jsonVariables,\n      operationName\n    });\n\n    if (isPromise(fetch)) {\n      // If fetcher returned a Promise, then call the callback when the promise\n      // resolves, otherwise handle the error.\n      fetch.then(cb).catch(error => {\n        this.setState({\n          isWaitingForResponse: false,\n          response: error ? GraphiQL.formatError(error) : null\n        });\n      });\n    } else if (isObservable(fetch)) {\n      // If the fetcher returned an Observable, then subscribe to it, calling\n      // the callback on each next value, and handling both errors and the\n      // completion of the Observable. Returns a Subscription object.\n      const subscription = fetch.subscribe({\n        next: cb,\n        error: error => {\n          this.setState({\n            isWaitingForResponse: false,\n            response: error ? GraphiQL.formatError(error) : null,\n            subscription: null\n          });\n        },\n        complete: () => {\n          this.setState({\n            isWaitingForResponse: false,\n            subscription: null\n          });\n        }\n      });\n      return subscription;\n    } else {\n      throw new Error('Fetcher did not return Promise or Observable.');\n    }\n  }\n\n  _runQueryAtCursor() {\n    if (this.state.subscription) {\n      this.handleStopQuery();\n      return;\n    }\n\n    let operationName;\n    const operations = this.state.operations;\n\n    if (operations) {\n      const editor = this.getQueryEditor();\n\n      if (editor.hasFocus()) {\n        const cursor = editor.getCursor();\n        const cursorIndex = editor.indexFromPos(cursor); // Loop through all operations to see if one contains the cursor.\n\n        for (let i = 0; i < operations.length; i++) {\n          const operation = operations[i];\n\n          if (operation.loc.start <= cursorIndex && operation.loc.end >= cursorIndex) {\n            operationName = operation.name && operation.name.value;\n            break;\n          }\n        }\n      }\n    }\n\n    this.handleRunQuery(operationName);\n  }\n\n  _didClickDragBar(event) {\n    // Only for primary unmodified clicks\n    if (event.button !== 0 || event.ctrlKey) {\n      return false;\n    }\n\n    let target = event.target; // We use codemirror's gutter as the drag bar.\n\n    if (target.className.indexOf('CodeMirror-gutter') !== 0) {\n      return false;\n    } // Specifically the result window's drag bar.\n\n\n    const resultWindow = _reactDom.default.findDOMNode(this.resultComponent);\n\n    while (target) {\n      if (target === resultWindow) {\n        return true;\n      }\n\n      target = target.parentNode;\n    }\n\n    return false;\n  }\n\n} // Configure the UI by providing this Component as a child of GraphiQL.\n\n\nexports.GraphiQL = GraphiQL;\n\n_defineProperty(GraphiQL, \"propTypes\", {\n  fetcher: _propTypes.default.func.isRequired,\n  schema: _propTypes.default.instanceOf(_graphql.GraphQLSchema),\n  query: _propTypes.default.string,\n  variables: _propTypes.default.string,\n  operationName: _propTypes.default.string,\n  response: _propTypes.default.string,\n  storage: _propTypes.default.shape({\n    getItem: _propTypes.default.func,\n    setItem: _propTypes.default.func,\n    removeItem: _propTypes.default.func\n  }),\n  defaultQuery: _propTypes.default.string,\n  defaultVariableEditorOpen: _propTypes.default.bool,\n  onCopyQuery: _propTypes.default.func,\n  onEditQuery: _propTypes.default.func,\n  onEditVariables: _propTypes.default.func,\n  onEditOperationName: _propTypes.default.func,\n  onToggleDocs: _propTypes.default.func,\n  getDefaultFieldNames: _propTypes.default.func,\n  editorTheme: _propTypes.default.string,\n  onToggleHistory: _propTypes.default.func,\n  ResultsTooltip: _propTypes.default.any,\n  readOnly: _propTypes.default.bool,\n  docExplorerOpen: _propTypes.default.bool\n});\n\nGraphiQL.Logo = function GraphiQLLogo(props) {\n  return _react.default.createElement(\"div\", {\n    className: \"title\"\n  }, props.children || _react.default.createElement(\"span\", null, 'Graph', _react.default.createElement(\"em\", null, 'i'), 'QL'));\n}; // Configure the UI by providing this Component as a child of GraphiQL.\n\n\nGraphiQL.Toolbar = function GraphiQLToolbar(props) {\n  return _react.default.createElement(\"div\", {\n    className: \"toolbar\",\n    role: \"toolbar\",\n    \"aria-label\": \"Editor Commands\"\n  }, props.children);\n}; // Export main windows/panes to be used separately if desired.\n\n\nGraphiQL.QueryEditor = _QueryEditor.QueryEditor;\nGraphiQL.VariableEditor = _VariableEditor.VariableEditor;\nGraphiQL.ResultViewer = _ResultViewer.ResultViewer; // Add a button to the Toolbar.\n\nGraphiQL.Button = _ToolbarButton.ToolbarButton;\nGraphiQL.ToolbarButton = _ToolbarButton.ToolbarButton; // Don't break existing API.\n// Add a group of buttons to the Toolbar\n\nGraphiQL.Group = _ToolbarGroup.ToolbarGroup; // Add a menu of items to the Toolbar.\n\nGraphiQL.Menu = _ToolbarMenu.ToolbarMenu;\nGraphiQL.MenuItem = _ToolbarMenu.ToolbarMenuItem; // Add a select-option input to the Toolbar.\n\nGraphiQL.Select = _ToolbarSelect.ToolbarSelect;\nGraphiQL.SelectOption = _ToolbarSelect.ToolbarSelectOption; // Configure the UI by providing this Component as a child of GraphiQL.\n\nGraphiQL.Footer = function GraphiQLFooter(props) {\n  return _react.default.createElement(\"div\", {\n    className: \"footer\"\n  }, props.children);\n};\n\nGraphiQL.formatResult = function (result) {\n  return JSON.stringify(result, null, 2);\n};\n\nconst formatSingleError = error => ({ ...error,\n  // Raise these details even if they're non-enumerable\n  message: error.message,\n  stack: error.stack\n});\n\nGraphiQL.formatError = function (rawError) {\n  const result = Array.isArray(rawError) ? rawError.map(formatSingleError) : formatSingleError(rawError);\n  return JSON.stringify(result, null, 2);\n};\n\nconst defaultQuery = `# Welcome to GraphiQL\n#\n# GraphiQL is an in-browser tool for writing, validating, and\n# testing GraphQL queries.\n#\n# Type queries into this side of the screen, and you will see intelligent\n# typeaheads aware of the current GraphQL type schema and live syntax and\n# validation errors highlighted within the text.\n#\n# GraphQL queries typically start with a \"{\" character. Lines that starts\n# with a # are ignored.\n#\n# An example GraphQL query might look like:\n#\n#     {\n#       field(arg: \"value\") {\n#         subField\n#       }\n#     }\n#\n# Keyboard shortcuts:\n#\n#  Prettify Query:  Shift-Ctrl-P (or press the prettify button above)\n#\n#     Merge Query:  Shift-Ctrl-M (or press the merge button above)\n#\n#       Run Query:  Ctrl-Enter (or press the play button above)\n#\n#   Auto Complete:  Ctrl-Space (or just start typing)\n#\n\n`; // Duck-type promise detection.\n\nfunction isPromise(value) {\n  return typeof value === 'object' && typeof value.then === 'function';\n} // Duck-type Observable.take(1).toPromise()\n\n\nfunction observableToPromise(observable) {\n  if (!isObservable(observable)) {\n    return observable;\n  }\n\n  return new Promise((resolve, reject) => {\n    const subscription = observable.subscribe(v => {\n      resolve(v);\n      subscription.unsubscribe();\n    }, reject, () => {\n      reject(new Error('no value resolved'));\n    });\n  });\n} // Duck-type observable detection.\n\n\nfunction isObservable(value) {\n  return typeof value === 'object' && typeof value.subscribe === 'function';\n}","\"use strict\";\n\nvar deselectCurrent = require(\"toggle-selection\");\n\nvar defaultMessage = \"Copy to clipboard: #{key}, Enter\";\n\nfunction format(message) {\n  var copyKey = (/mac os x/i.test(navigator.userAgent) ? \"⌘\" : \"Ctrl\") + \"+C\";\n  return message.replace(/#{\\s*key\\s*}/g, copyKey);\n}\n\nfunction copy(text, options) {\n  var debug,\n    message,\n    reselectPrevious,\n    range,\n    selection,\n    mark,\n    success = false;\n  if (!options) {\n    options = {};\n  }\n  debug = options.debug || false;\n  try {\n    reselectPrevious = deselectCurrent();\n\n    range = document.createRange();\n    selection = document.getSelection();\n\n    mark = document.createElement(\"span\");\n    mark.textContent = text;\n    // reset user styles for span element\n    mark.style.all = \"unset\";\n    // prevents scrolling to the end of the page\n    mark.style.position = \"fixed\";\n    mark.style.top = 0;\n    mark.style.clip = \"rect(0, 0, 0, 0)\";\n    // used to preserve spaces and line breaks\n    mark.style.whiteSpace = \"pre\";\n    // do not inherit user-select (it may be `none`)\n    mark.style.webkitUserSelect = \"text\";\n    mark.style.MozUserSelect = \"text\";\n    mark.style.msUserSelect = \"text\";\n    mark.style.userSelect = \"text\";\n    mark.addEventListener(\"copy\", function(e) {\n      e.stopPropagation();\n      if (options.format) {\n        e.preventDefault();\n        e.clipboardData.clearData();\n        e.clipboardData.setData(options.format, text);\n      }\n    });\n\n    document.body.appendChild(mark);\n\n    range.selectNodeContents(mark);\n    selection.addRange(range);\n\n    var successful = document.execCommand(\"copy\");\n    if (!successful) {\n      throw new Error(\"copy command was unsuccessful\");\n    }\n    success = true;\n  } catch (err) {\n    debug && console.error(\"unable to copy using execCommand: \", err);\n    debug && console.warn(\"trying IE specific stuff\");\n    try {\n      window.clipboardData.setData(options.format || \"text\", text);\n      success = true;\n    } catch (err) {\n      debug && console.error(\"unable to copy using clipboardData: \", err);\n      debug && console.error(\"falling back to prompt\");\n      message = format(\"message\" in options ? options.message : defaultMessage);\n      window.prompt(message, text);\n    }\n  } finally {\n    if (selection) {\n      if (typeof selection.removeRange == \"function\") {\n        selection.removeRange(range);\n      } else {\n        selection.removeAllRanges();\n      }\n    }\n\n    if (mark) {\n      document.body.removeChild(mark);\n    }\n    reselectPrevious();\n  }\n\n  return success;\n}\n\nmodule.exports = copy;\n","\nmodule.exports = function () {\n  var selection = document.getSelection();\n  if (!selection.rangeCount) {\n    return function () {};\n  }\n  var active = document.activeElement;\n\n  var ranges = [];\n  for (var i = 0; i < selection.rangeCount; i++) {\n    ranges.push(selection.getRangeAt(i));\n  }\n\n  switch (active.tagName.toUpperCase()) { // .toUpperCase handles XHTML\n    case 'INPUT':\n    case 'TEXTAREA':\n      active.blur();\n      break;\n\n    default:\n      active = null;\n      break;\n  }\n\n  selection.removeAllRanges();\n  return function () {\n    selection.type === 'Caret' &&\n    selection.removeAllRanges();\n\n    if (!selection.rangeCount) {\n      ranges.forEach(function(range) {\n        selection.addRange(range);\n      });\n    }\n\n    active &&\n    active.focus();\n  };\n};\n","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.ExecuteButton = void 0;\n\nvar _react = _interopRequireDefault(require(\"react\"));\n\nvar _propTypes = _interopRequireDefault(require(\"prop-types\"));\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\n/**\n * ExecuteButton\n *\n * What a nice round shiny button. Shows a drop-down when there are multiple\n * queries to run.\n */\nclass ExecuteButton extends _react.default.Component {\n  constructor(props) {\n    super(props);\n\n    _defineProperty(this, \"_onClick\", () => {\n      if (this.props.isRunning) {\n        this.props.onStop();\n      } else {\n        this.props.onRun();\n      }\n    });\n\n    _defineProperty(this, \"_onOptionSelected\", operation => {\n      this.setState({\n        optionsOpen: false\n      });\n      this.props.onRun(operation.name && operation.name.value);\n    });\n\n    _defineProperty(this, \"_onOptionsOpen\", downEvent => {\n      let initialPress = true;\n      const downTarget = downEvent.target;\n      this.setState({\n        highlight: null,\n        optionsOpen: true\n      });\n\n      let onMouseUp = upEvent => {\n        if (initialPress && upEvent.target === downTarget) {\n          initialPress = false;\n        } else {\n          document.removeEventListener('mouseup', onMouseUp);\n          onMouseUp = null;\n          const isOptionsMenuClicked = downTarget.parentNode.compareDocumentPosition(upEvent.target) & Node.DOCUMENT_POSITION_CONTAINED_BY;\n\n          if (!isOptionsMenuClicked) {\n            // menu calls setState if it was clicked\n            this.setState({\n              optionsOpen: false\n            });\n          }\n        }\n      };\n\n      document.addEventListener('mouseup', onMouseUp);\n    });\n\n    this.state = {\n      optionsOpen: false,\n      highlight: null\n    };\n  }\n\n  render() {\n    const operations = this.props.operations;\n    const optionsOpen = this.state.optionsOpen;\n    const hasOptions = operations && operations.length > 1;\n    let options = null;\n\n    if (hasOptions && optionsOpen) {\n      const highlight = this.state.highlight;\n      options = _react.default.createElement(\"ul\", {\n        className: \"execute-options\"\n      }, operations.map(operation => _react.default.createElement(\"li\", {\n        key: operation.name ? operation.name.value : '*',\n        className: operation === highlight ? 'selected' : undefined,\n        onMouseOver: () => this.setState({\n          highlight: operation\n        }),\n        onMouseOut: () => this.setState({\n          highlight: null\n        }),\n        onMouseUp: () => this._onOptionSelected(operation)\n      }, operation.name ? operation.name.value : '<Unnamed>')));\n    } // Allow click event if there is a running query or if there are not options\n    // for which operation to run.\n\n\n    let onClick;\n\n    if (this.props.isRunning || !hasOptions) {\n      onClick = this._onClick;\n    } // Allow mouse down if there is no running query, there are options for\n    // which operation to run, and the dropdown is currently closed.\n\n\n    let onMouseDown;\n\n    if (!this.props.isRunning && hasOptions && !optionsOpen) {\n      onMouseDown = this._onOptionsOpen;\n    }\n\n    const pathJSX = this.props.isRunning ? _react.default.createElement(\"path\", {\n      d: \"M 10 10 L 23 10 L 23 23 L 10 23 z\"\n    }) : _react.default.createElement(\"path\", {\n      d: \"M 11 9 L 24 16 L 11 23 z\"\n    });\n    return _react.default.createElement(\"div\", {\n      className: \"execute-button-wrap\"\n    }, _react.default.createElement(\"button\", {\n      type: \"button\",\n      className: \"execute-button\",\n      onMouseDown: onMouseDown,\n      onClick: onClick,\n      title: \"Execute Query (Ctrl-Enter)\"\n    }, _react.default.createElement(\"svg\", {\n      width: \"34\",\n      height: \"34\"\n    }, pathJSX)), options);\n  }\n\n}\n\nexports.ExecuteButton = ExecuteButton;\n\n_defineProperty(ExecuteButton, \"propTypes\", {\n  onRun: _propTypes.default.func,\n  onStop: _propTypes.default.func,\n  isRunning: _propTypes.default.bool,\n  operations: _propTypes.default.array\n});","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.ImagePreview = void 0;\n\nvar _react = _interopRequireDefault(require(\"react\"));\n\nvar _propTypes = _interopRequireDefault(require(\"prop-types\"));\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\nfunction tokenToURL(token) {\n  if (token.type !== 'string') {\n    return null;\n  }\n\n  const value = token.string.slice(1).slice(0, -1).trim();\n\n  try {\n    const location = window.location;\n    return new URL(value, location.protocol + '//' + location.host);\n  } catch (err) {\n    return null;\n  }\n}\n\nfunction isImageURL(url) {\n  return /(bmp|gif|jpeg|jpg|png|svg)$/.test(url.pathname);\n}\n\nclass ImagePreview extends _react.default.Component {\n  static shouldRender(token) {\n    const url = tokenToURL(token);\n    return url ? isImageURL(url) : false;\n  }\n\n  constructor(props) {\n    super(props);\n\n    _defineProperty(this, \"state\", {\n      width: null,\n      height: null,\n      src: null,\n      mime: null\n    });\n  }\n\n  componentDidMount() {\n    this._updateMetadata();\n  }\n\n  componentDidUpdate() {\n    this._updateMetadata();\n  }\n\n  render() {\n    let dims = null;\n\n    if (this.state.width !== null && this.state.height !== null) {\n      let dimensions = this.state.width + 'x' + this.state.height;\n\n      if (this.state.mime !== null) {\n        dimensions += ' ' + this.state.mime;\n      }\n\n      dims = _react.default.createElement(\"div\", null, dimensions);\n    }\n\n    return _react.default.createElement(\"div\", null, _react.default.createElement(\"img\", {\n      onLoad: () => this._updateMetadata(),\n      ref: node => {\n        this._node = node;\n      },\n      src: tokenToURL(this.props.token)\n    }), dims);\n  }\n\n  _updateMetadata() {\n    if (!this._node) {\n      return;\n    }\n\n    const width = this._node.naturalWidth;\n    const height = this._node.naturalHeight;\n    const src = this._node.src;\n\n    if (src !== this.state.src) {\n      this.setState({\n        src\n      });\n      fetch(src, {\n        method: 'HEAD'\n      }).then(response => {\n        this.setState({\n          mime: response.headers.get('Content-Type')\n        });\n      });\n    }\n\n    if (width !== this.state.width || height !== this.state.height) {\n      this.setState({\n        height,\n        width\n      });\n    }\n  }\n\n}\n\nexports.ImagePreview = ImagePreview;\n\n_defineProperty(ImagePreview, \"propTypes\", {\n  token: _propTypes.default.any\n});","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.ToolbarButton = void 0;\n\nvar _react = _interopRequireDefault(require(\"react\"));\n\nvar _propTypes = _interopRequireDefault(require(\"prop-types\"));\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\n/**\n * ToolbarButton\n *\n * A button to use within the Toolbar.\n */\nclass ToolbarButton extends _react.default.Component {\n  constructor(props) {\n    super(props);\n\n    _defineProperty(this, \"handleClick\", () => {\n      try {\n        this.props.onClick();\n        this.setState({\n          error: null\n        });\n      } catch (error) {\n        this.setState({\n          error\n        });\n      }\n    });\n\n    this.state = {\n      error: null\n    };\n  }\n\n  render() {\n    const {\n      error\n    } = this.state;\n    return _react.default.createElement(\"button\", {\n      className: 'toolbar-button' + (error ? ' error' : ''),\n      onClick: this.handleClick,\n      title: error ? error.message : this.props.title,\n      \"aria-invalid\": error ? 'true' : 'false'\n    }, this.props.label);\n  }\n\n}\n\nexports.ToolbarButton = ToolbarButton;\n\n_defineProperty(ToolbarButton, \"propTypes\", {\n  onClick: _propTypes.default.func,\n  title: _propTypes.default.string,\n  label: _propTypes.default.string\n});","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.ToolbarGroup = ToolbarGroup;\n\nvar _react = _interopRequireDefault(require(\"react\"));\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\n/**\n *  Copyright (c) 2019 GraphQL Contributors.\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/**\n * ToolbarGroup\n *\n * A group of associated controls.\n */\nfunction ToolbarGroup({\n  children\n}) {\n  return _react.default.createElement(\"div\", {\n    className: \"toolbar-button-group\"\n  }, children);\n}","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.ToolbarMenuItem = ToolbarMenuItem;\nexports.ToolbarMenu = void 0;\n\nvar _react = _interopRequireDefault(require(\"react\"));\n\nvar _propTypes = _interopRequireDefault(require(\"prop-types\"));\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\n/**\n * ToolbarMenu\n *\n * A menu style button to use within the Toolbar.\n */\nclass ToolbarMenu extends _react.default.Component {\n  constructor(props) {\n    super(props);\n\n    _defineProperty(this, \"handleOpen\", e => {\n      preventDefault(e);\n      this.setState({\n        visible: true\n      });\n\n      this._subscribe();\n    });\n\n    this.state = {\n      visible: false\n    };\n  }\n\n  componentWillUnmount() {\n    this._release();\n  }\n\n  render() {\n    const visible = this.state.visible;\n    return _react.default.createElement(\"a\", {\n      className: \"toolbar-menu toolbar-button\",\n      onClick: this.handleOpen.bind(this),\n      onMouseDown: preventDefault,\n      ref: node => {\n        this._node = node;\n      },\n      title: this.props.title\n    }, this.props.label, _react.default.createElement(\"svg\", {\n      width: \"14\",\n      height: \"8\"\n    }, _react.default.createElement(\"path\", {\n      fill: \"#666\",\n      d: \"M 5 1.5 L 14 1.5 L 9.5 7 z\"\n    })), _react.default.createElement(\"ul\", {\n      className: 'toolbar-menu-items' + (visible ? ' open' : '')\n    }, this.props.children));\n  }\n\n  _subscribe() {\n    if (!this._listener) {\n      this._listener = this.handleClick.bind(this);\n      document.addEventListener('click', this._listener);\n    }\n  }\n\n  _release() {\n    if (this._listener) {\n      document.removeEventListener('click', this._listener);\n      this._listener = null;\n    }\n  }\n\n  handleClick(e) {\n    if (this._node !== e.target) {\n      preventDefault(e);\n      this.setState({\n        visible: false\n      });\n\n      this._release();\n    }\n  }\n\n}\n\nexports.ToolbarMenu = ToolbarMenu;\n\n_defineProperty(ToolbarMenu, \"propTypes\", {\n  title: _propTypes.default.string,\n  label: _propTypes.default.string\n});\n\nfunction ToolbarMenuItem({\n  onSelect,\n  title,\n  label\n}) {\n  return _react.default.createElement(\"li\", {\n    onMouseOver: e => {\n      e.target.className = 'hover';\n    },\n    onMouseOut: e => {\n      e.target.className = null;\n    },\n    onMouseDown: preventDefault,\n    onMouseUp: onSelect,\n    title: title\n  }, label);\n}\n\nToolbarMenuItem.propTypes = {\n  onSelect: _propTypes.default.func,\n  title: _propTypes.default.string,\n  label: _propTypes.default.string\n};\n\nfunction preventDefault(e) {\n  e.preventDefault();\n}","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.ToolbarSelectOption = ToolbarSelectOption;\nexports.ToolbarSelect = void 0;\n\nvar _react = _interopRequireDefault(require(\"react\"));\n\nvar _propTypes = _interopRequireDefault(require(\"prop-types\"));\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\n/**\n * ToolbarSelect\n *\n * A select-option style button to use within the Toolbar.\n *\n */\nclass ToolbarSelect extends _react.default.Component {\n  constructor(props) {\n    super(props);\n\n    _defineProperty(this, \"handleOpen\", e => {\n      preventDefault(e);\n      this.setState({\n        visible: true\n      });\n\n      this._subscribe();\n    });\n\n    this.state = {\n      visible: false\n    };\n  }\n\n  componentWillUnmount() {\n    this._release();\n  }\n\n  render() {\n    let selectedChild;\n    const visible = this.state.visible;\n\n    const optionChildren = _react.default.Children.map(this.props.children, (child, i) => {\n      if (!selectedChild || child.props.selected) {\n        selectedChild = child;\n      }\n\n      const onChildSelect = child.props.onSelect || this.props.onSelect && this.props.onSelect.bind(null, child.props.value, i);\n      return _react.default.createElement(ToolbarSelectOption, _extends({}, child.props, {\n        onSelect: onChildSelect\n      }));\n    });\n\n    return _react.default.createElement(\"a\", {\n      className: \"toolbar-select toolbar-button\",\n      onClick: this.handleOpen.bind(this),\n      onMouseDown: preventDefault,\n      ref: node => {\n        this._node = node;\n      },\n      title: this.props.title\n    }, selectedChild.props.label, _react.default.createElement(\"svg\", {\n      width: \"13\",\n      height: \"10\"\n    }, _react.default.createElement(\"path\", {\n      fill: \"#666\",\n      d: \"M 5 5 L 13 5 L 9 1 z\"\n    }), _react.default.createElement(\"path\", {\n      fill: \"#666\",\n      d: \"M 5 6 L 13 6 L 9 10 z\"\n    })), _react.default.createElement(\"ul\", {\n      className: 'toolbar-select-options' + (visible ? ' open' : '')\n    }, optionChildren));\n  }\n\n  _subscribe() {\n    if (!this._listener) {\n      this._listener = this.handleClick.bind(this);\n      document.addEventListener('click', this._listener);\n    }\n  }\n\n  _release() {\n    if (this._listener) {\n      document.removeEventListener('click', this._listener);\n      this._listener = null;\n    }\n  }\n\n  handleClick(e) {\n    if (this._node !== e.target) {\n      preventDefault(e);\n      this.setState({\n        visible: false\n      });\n\n      this._release();\n    }\n  }\n\n}\n\nexports.ToolbarSelect = ToolbarSelect;\n\n_defineProperty(ToolbarSelect, \"propTypes\", {\n  title: _propTypes.default.string,\n  label: _propTypes.default.string,\n  onSelect: _propTypes.default.func\n});\n\nfunction ToolbarSelectOption({\n  onSelect,\n  label,\n  selected\n}) {\n  return _react.default.createElement(\"li\", {\n    onMouseOver: e => {\n      e.target.className = 'hover';\n    },\n    onMouseOut: e => {\n      e.target.className = null;\n    },\n    onMouseDown: preventDefault,\n    onMouseUp: onSelect\n  }, label, selected && _react.default.createElement(\"svg\", {\n    width: \"13\",\n    height: \"13\"\n  }, _react.default.createElement(\"polygon\", {\n    points: \"4.851,10.462 0,5.611 2.314,3.297 4.851,5.835 10.686,0 13,2.314 4.851,10.462\"\n  })));\n}\n\nToolbarSelectOption.propTypes = {\n  onSelect: _propTypes.default.func,\n  selected: _propTypes.default.bool,\n  label: _propTypes.default.string,\n  value: _propTypes.default.any\n};\n\nfunction preventDefault(e) {\n  e.preventDefault();\n}","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.QueryEditor = void 0;\n\nvar _react = _interopRequireDefault(require(\"react\"));\n\nvar _propTypes = _interopRequireDefault(require(\"prop-types\"));\n\nvar _graphql = require(\"graphql\");\n\nvar _markdownIt = _interopRequireDefault(require(\"markdown-it\"));\n\nvar _normalizeWhitespace = require(\"../utility/normalizeWhitespace\");\n\nvar _onHasCompletion = _interopRequireDefault(require(\"../utility/onHasCompletion\"));\n\nvar _commonKeys = _interopRequireDefault(require(\"../utility/commonKeys\"));\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\nconst md = new _markdownIt.default();\nconst AUTO_COMPLETE_AFTER_KEY = /^[a-zA-Z0-9_@(]$/;\n/**\n * QueryEditor\n *\n * Maintains an instance of CodeMirror responsible for editing a GraphQL query.\n *\n * Props:\n *\n *   - schema: A GraphQLSchema instance enabling editor linting and hinting.\n *   - value: The text of the editor.\n *   - onEdit: A function called when the editor changes, given the edited text.\n *   - readOnly: Turns the editor to read-only mode.\n *\n */\n\nclass QueryEditor extends _react.default.Component {\n  constructor(props) {\n    super(); // Keep a cached version of the value, this cache will be updated when the\n    // editor is updated, which can later be used to protect the editor from\n    // unnecessary updates during the update lifecycle.\n\n    _defineProperty(this, \"_onKeyUp\", (cm, event) => {\n      if (AUTO_COMPLETE_AFTER_KEY.test(event.key)) {\n        this.editor.execCommand('autocomplete');\n      }\n    });\n\n    _defineProperty(this, \"_onEdit\", () => {\n      if (!this.ignoreChangeEvent) {\n        this.cachedValue = this.editor.getValue();\n\n        if (this.props.onEdit) {\n          this.props.onEdit(this.cachedValue);\n        }\n      }\n    });\n\n    _defineProperty(this, \"_onHasCompletion\", (cm, data) => {\n      (0, _onHasCompletion.default)(cm, data, this.props.onHintInformationRender);\n    });\n\n    this.cachedValue = props.value || '';\n  }\n\n  componentDidMount() {\n    // Lazily require to ensure requiring GraphiQL outside of a Browser context\n    // does not produce an error.\n    const CodeMirror = require('codemirror');\n\n    require('codemirror/addon/hint/show-hint');\n\n    require('codemirror/addon/comment/comment');\n\n    require('codemirror/addon/edit/matchbrackets');\n\n    require('codemirror/addon/edit/closebrackets');\n\n    require('codemirror/addon/fold/foldgutter');\n\n    require('codemirror/addon/fold/brace-fold');\n\n    require('codemirror/addon/search/search');\n\n    require('codemirror/addon/search/searchcursor');\n\n    require('codemirror/addon/search/jump-to-line');\n\n    require('codemirror/addon/dialog/dialog');\n\n    require('codemirror/addon/lint/lint');\n\n    require('codemirror/keymap/sublime');\n\n    require('codemirror-graphql/hint');\n\n    require('codemirror-graphql/lint');\n\n    require('codemirror-graphql/info');\n\n    require('codemirror-graphql/jump');\n\n    require('codemirror-graphql/mode');\n\n    this.editor = CodeMirror(this._node, {\n      value: this.props.value || '',\n      lineNumbers: true,\n      tabSize: 2,\n      mode: 'graphql',\n      theme: this.props.editorTheme || 'graphiql',\n      keyMap: 'sublime',\n      autoCloseBrackets: true,\n      matchBrackets: true,\n      showCursorWhenSelecting: true,\n      readOnly: this.props.readOnly ? 'nocursor' : false,\n      foldGutter: {\n        minFoldSize: 4\n      },\n      lint: {\n        schema: this.props.schema\n      },\n      hintOptions: {\n        schema: this.props.schema,\n        closeOnUnfocus: false,\n        completeSingle: false,\n        container: this._node\n      },\n      info: {\n        schema: this.props.schema,\n        renderDescription: text => md.render(text),\n        onClick: reference => this.props.onClickReference(reference)\n      },\n      jump: {\n        schema: this.props.schema,\n        onClick: reference => this.props.onClickReference(reference)\n      },\n      gutters: ['CodeMirror-linenumbers', 'CodeMirror-foldgutter'],\n      extraKeys: {\n        'Cmd-Space': () => this.editor.showHint({\n          completeSingle: true,\n          container: this._node\n        }),\n        'Ctrl-Space': () => this.editor.showHint({\n          completeSingle: true,\n          container: this._node\n        }),\n        'Alt-Space': () => this.editor.showHint({\n          completeSingle: true,\n          container: this._node\n        }),\n        'Shift-Space': () => this.editor.showHint({\n          completeSingle: true,\n          container: this._node\n        }),\n        'Shift-Alt-Space': () => this.editor.showHint({\n          completeSingle: true,\n          container: this._node\n        }),\n        'Cmd-Enter': () => {\n          if (this.props.onRunQuery) {\n            this.props.onRunQuery();\n          }\n        },\n        'Ctrl-Enter': () => {\n          if (this.props.onRunQuery) {\n            this.props.onRunQuery();\n          }\n        },\n        'Shift-Ctrl-C': () => {\n          if (this.props.onCopyQuery) {\n            this.props.onCopyQuery();\n          }\n        },\n        'Shift-Ctrl-P': () => {\n          if (this.props.onPrettifyQuery) {\n            this.props.onPrettifyQuery();\n          }\n        },\n\n        /* Shift-Ctrl-P is hard coded in Firefox for private browsing so adding an alternative to Pretiffy */\n        'Shift-Ctrl-F': () => {\n          if (this.props.onPrettifyQuery) {\n            this.props.onPrettifyQuery();\n          }\n        },\n        'Shift-Ctrl-M': () => {\n          if (this.props.onMergeQuery) {\n            this.props.onMergeQuery();\n          }\n        },\n        ..._commonKeys.default,\n        'Cmd-S': () => {\n          if (this.props.onRunQuery) {// empty\n          }\n        },\n        'Ctrl-S': () => {\n          if (this.props.onRunQuery) {// empty\n          }\n        }\n      }\n    });\n    this.editor.on('change', this._onEdit);\n    this.editor.on('keyup', this._onKeyUp);\n    this.editor.on('hasCompletion', this._onHasCompletion);\n    this.editor.on('beforeChange', this._onBeforeChange);\n  }\n\n  componentDidUpdate(prevProps) {\n    const CodeMirror = require('codemirror'); // Ensure the changes caused by this update are not interpretted as\n    // user-input changes which could otherwise result in an infinite\n    // event loop.\n\n\n    this.ignoreChangeEvent = true;\n\n    if (this.props.schema !== prevProps.schema) {\n      this.editor.options.lint.schema = this.props.schema;\n      this.editor.options.hintOptions.schema = this.props.schema;\n      this.editor.options.info.schema = this.props.schema;\n      this.editor.options.jump.schema = this.props.schema;\n      CodeMirror.signal(this.editor, 'change', this.editor);\n    }\n\n    if (this.props.value !== prevProps.value && this.props.value !== this.cachedValue) {\n      this.cachedValue = this.props.value;\n      this.editor.setValue(this.props.value);\n    }\n\n    this.ignoreChangeEvent = false;\n  }\n\n  componentWillUnmount() {\n    if (this.editor) {\n      this.editor.off('change', this._onEdit);\n      this.editor.off('keyup', this._onKeyUp);\n      this.editor.off('hasCompletion', this._onHasCompletion);\n      this.editor = null;\n    }\n  }\n\n  render() {\n    return _react.default.createElement(\"section\", {\n      className: \"query-editor\",\n      \"aria-label\": \"Query Editor\",\n      ref: node => {\n        this._node = node;\n      }\n    });\n  }\n  /**\n   * Public API for retrieving the CodeMirror instance from this\n   * React component.\n   */\n\n\n  getCodeMirror() {\n    return this.editor;\n  }\n  /**\n   * Public API for retrieving the DOM client height for this component.\n   */\n\n\n  getClientHeight() {\n    return this._node && this._node.clientHeight;\n  }\n\n  _onBeforeChange(instance, change) {\n    // The update function is only present on non-redo, non-undo events.\n    if (change.origin === 'paste') {\n      const text = change.text.map(_normalizeWhitespace.normalizeWhitespace);\n      change.update(change.from, change.to, text);\n    }\n  }\n\n}\n\nexports.QueryEditor = QueryEditor;\n\n_defineProperty(QueryEditor, \"propTypes\", {\n  schema: _propTypes.default.instanceOf(_graphql.GraphQLSchema),\n  value: _propTypes.default.string,\n  onEdit: _propTypes.default.func,\n  readOnly: _propTypes.default.bool,\n  onHintInformationRender: _propTypes.default.func,\n  onClickReference: _propTypes.default.func,\n  onCopyQuery: _propTypes.default.func,\n  onPrettifyQuery: _propTypes.default.func,\n  onMergeQuery: _propTypes.default.func,\n  onRunQuery: _propTypes.default.func,\n  editorTheme: _propTypes.default.string\n});","// Main parser class\n\n'use strict';\n\n\nvar utils        = require('./common/utils');\nvar helpers      = require('./helpers');\nvar Renderer     = require('./renderer');\nvar ParserCore   = require('./parser_core');\nvar ParserBlock  = require('./parser_block');\nvar ParserInline = require('./parser_inline');\nvar LinkifyIt    = require('linkify-it');\nvar mdurl        = require('mdurl');\nvar punycode     = require('punycode');\n\n\nvar config = {\n  'default': require('./presets/default'),\n  zero: require('./presets/zero'),\n  commonmark: require('./presets/commonmark')\n};\n\n////////////////////////////////////////////////////////////////////////////////\n//\n// This validator can prohibit more than really needed to prevent XSS. It's a\n// tradeoff to keep code simple and to be secure by default.\n//\n// If you need different setup - override validator method as you wish. Or\n// replace it with dummy function and use external sanitizer.\n//\n\nvar BAD_PROTO_RE = /^(vbscript|javascript|file|data):/;\nvar GOOD_DATA_RE = /^data:image\\/(gif|png|jpeg|webp);/;\n\nfunction validateLink(url) {\n  // url should be normalized at this point, and existing entities are decoded\n  var str = url.trim().toLowerCase();\n\n  return BAD_PROTO_RE.test(str) ? (GOOD_DATA_RE.test(str) ? true : false) : true;\n}\n\n////////////////////////////////////////////////////////////////////////////////\n\n\nvar RECODE_HOSTNAME_FOR = [ 'http:', 'https:', 'mailto:' ];\n\nfunction normalizeLink(url) {\n  var parsed = mdurl.parse(url, true);\n\n  if (parsed.hostname) {\n    // Encode hostnames in urls like:\n    // `http://host/`, `https://host/`, `mailto:user@host`, `//host/`\n    //\n    // We don't encode unknown schemas, because it's likely that we encode\n    // something we shouldn't (e.g. `skype:name` treated as `skype:host`)\n    //\n    if (!parsed.protocol || RECODE_HOSTNAME_FOR.indexOf(parsed.protocol) >= 0) {\n      try {\n        parsed.hostname = punycode.toASCII(parsed.hostname);\n      } catch (er) { /**/ }\n    }\n  }\n\n  return mdurl.encode(mdurl.format(parsed));\n}\n\nfunction normalizeLinkText(url) {\n  var parsed = mdurl.parse(url, true);\n\n  if (parsed.hostname) {\n    // Encode hostnames in urls like:\n    // `http://host/`, `https://host/`, `mailto:user@host`, `//host/`\n    //\n    // We don't encode unknown schemas, because it's likely that we encode\n    // something we shouldn't (e.g. `skype:name` treated as `skype:host`)\n    //\n    if (!parsed.protocol || RECODE_HOSTNAME_FOR.indexOf(parsed.protocol) >= 0) {\n      try {\n        parsed.hostname = punycode.toUnicode(parsed.hostname);\n      } catch (er) { /**/ }\n    }\n  }\n\n  return mdurl.decode(mdurl.format(parsed));\n}\n\n\n/**\n * class MarkdownIt\n *\n * Main parser/renderer class.\n *\n * ##### Usage\n *\n * ```javascript\n * // node.js, \"classic\" way:\n * var MarkdownIt = require('markdown-it'),\n *     md = new MarkdownIt();\n * var result = md.render('# markdown-it rulezz!');\n *\n * // node.js, the same, but with sugar:\n * var md = require('markdown-it')();\n * var result = md.render('# markdown-it rulezz!');\n *\n * // browser without AMD, added to \"window\" on script load\n * // Note, there are no dash.\n * var md = window.markdownit();\n * var result = md.render('# markdown-it rulezz!');\n * ```\n *\n * Single line rendering, without paragraph wrap:\n *\n * ```javascript\n * var md = require('markdown-it')();\n * var result = md.renderInline('__markdown-it__ rulezz!');\n * ```\n **/\n\n/**\n * new MarkdownIt([presetName, options])\n * - presetName (String): optional, `commonmark` / `zero`\n * - options (Object)\n *\n * Creates parser instanse with given config. Can be called without `new`.\n *\n * ##### presetName\n *\n * MarkdownIt provides named presets as a convenience to quickly\n * enable/disable active syntax rules and options for common use cases.\n *\n * - [\"commonmark\"](https://github.com/markdown-it/markdown-it/blob/master/lib/presets/commonmark.js) -\n *   configures parser to strict [CommonMark](http://commonmark.org/) mode.\n * - [default](https://github.com/markdown-it/markdown-it/blob/master/lib/presets/default.js) -\n *   similar to GFM, used when no preset name given. Enables all available rules,\n *   but still without html, typographer & autolinker.\n * - [\"zero\"](https://github.com/markdown-it/markdown-it/blob/master/lib/presets/zero.js) -\n *   all rules disabled. Useful to quickly setup your config via `.enable()`.\n *   For example, when you need only `bold` and `italic` markup and nothing else.\n *\n * ##### options:\n *\n * - __html__ - `false`. Set `true` to enable HTML tags in source. Be careful!\n *   That's not safe! You may need external sanitizer to protect output from XSS.\n *   It's better to extend features via plugins, instead of enabling HTML.\n * - __xhtmlOut__ - `false`. Set `true` to add '/' when closing single tags\n *   (`<br />`). This is needed only for full CommonMark compatibility. In real\n *   world you will need HTML output.\n * - __breaks__ - `false`. Set `true` to convert `\\n` in paragraphs into `<br>`.\n * - __langPrefix__ - `language-`. CSS language class prefix for fenced blocks.\n *   Can be useful for external highlighters.\n * - __linkify__ - `false`. Set `true` to autoconvert URL-like text to links.\n * - __typographer__  - `false`. Set `true` to enable [some language-neutral\n *   replacement](https://github.com/markdown-it/markdown-it/blob/master/lib/rules_core/replacements.js) +\n *   quotes beautification (smartquotes).\n * - __quotes__ - `“”‘’`, String or Array. Double + single quotes replacement\n *   pairs, when typographer enabled and smartquotes on. For example, you can\n *   use `'«»„“'` for Russian, `'„“‚‘'` for German, and\n *   `['«\\xA0', '\\xA0»', '‹\\xA0', '\\xA0›']` for French (including nbsp).\n * - __highlight__ - `null`. Highlighter function for fenced code blocks.\n *   Highlighter `function (str, lang)` should return escaped HTML. It can also\n *   return empty string if the source was not changed and should be escaped\n *   externaly. If result starts with <pre... internal wrapper is skipped.\n *\n * ##### Example\n *\n * ```javascript\n * // commonmark mode\n * var md = require('markdown-it')('commonmark');\n *\n * // default mode\n * var md = require('markdown-it')();\n *\n * // enable everything\n * var md = require('markdown-it')({\n *   html: true,\n *   linkify: true,\n *   typographer: true\n * });\n * ```\n *\n * ##### Syntax highlighting\n *\n * ```js\n * var hljs = require('highlight.js') // https://highlightjs.org/\n *\n * var md = require('markdown-it')({\n *   highlight: function (str, lang) {\n *     if (lang && hljs.getLanguage(lang)) {\n *       try {\n *         return hljs.highlight(lang, str, true).value;\n *       } catch (__) {}\n *     }\n *\n *     return ''; // use external default escaping\n *   }\n * });\n * ```\n *\n * Or with full wrapper override (if you need assign class to `<pre>`):\n *\n * ```javascript\n * var hljs = require('highlight.js') // https://highlightjs.org/\n *\n * // Actual default values\n * var md = require('markdown-it')({\n *   highlight: function (str, lang) {\n *     if (lang && hljs.getLanguage(lang)) {\n *       try {\n *         return '<pre class=\"hljs\"><code>' +\n *                hljs.highlight(lang, str, true).value +\n *                '</code></pre>';\n *       } catch (__) {}\n *     }\n *\n *     return '<pre class=\"hljs\"><code>' + md.utils.escapeHtml(str) + '</code></pre>';\n *   }\n * });\n * ```\n *\n **/\nfunction MarkdownIt(presetName, options) {\n  if (!(this instanceof MarkdownIt)) {\n    return new MarkdownIt(presetName, options);\n  }\n\n  if (!options) {\n    if (!utils.isString(presetName)) {\n      options = presetName || {};\n      presetName = 'default';\n    }\n  }\n\n  /**\n   * MarkdownIt#inline -> ParserInline\n   *\n   * Instance of [[ParserInline]]. You may need it to add new rules when\n   * writing plugins. For simple rules control use [[MarkdownIt.disable]] and\n   * [[MarkdownIt.enable]].\n   **/\n  this.inline = new ParserInline();\n\n  /**\n   * MarkdownIt#block -> ParserBlock\n   *\n   * Instance of [[ParserBlock]]. You may need it to add new rules when\n   * writing plugins. For simple rules control use [[MarkdownIt.disable]] and\n   * [[MarkdownIt.enable]].\n   **/\n  this.block = new ParserBlock();\n\n  /**\n   * MarkdownIt#core -> Core\n   *\n   * Instance of [[Core]] chain executor. You may need it to add new rules when\n   * writing plugins. For simple rules control use [[MarkdownIt.disable]] and\n   * [[MarkdownIt.enable]].\n   **/\n  this.core = new ParserCore();\n\n  /**\n   * MarkdownIt#renderer -> Renderer\n   *\n   * Instance of [[Renderer]]. Use it to modify output look. Or to add rendering\n   * rules for new token types, generated by plugins.\n   *\n   * ##### Example\n   *\n   * ```javascript\n   * var md = require('markdown-it')();\n   *\n   * function myToken(tokens, idx, options, env, self) {\n   *   //...\n   *   return result;\n   * };\n   *\n   * md.renderer.rules['my_token'] = myToken\n   * ```\n   *\n   * See [[Renderer]] docs and [source code](https://github.com/markdown-it/markdown-it/blob/master/lib/renderer.js).\n   **/\n  this.renderer = new Renderer();\n\n  /**\n   * MarkdownIt#linkify -> LinkifyIt\n   *\n   * [linkify-it](https://github.com/markdown-it/linkify-it) instance.\n   * Used by [linkify](https://github.com/markdown-it/markdown-it/blob/master/lib/rules_core/linkify.js)\n   * rule.\n   **/\n  this.linkify = new LinkifyIt();\n\n  /**\n   * MarkdownIt#validateLink(url) -> Boolean\n   *\n   * Link validation function. CommonMark allows too much in links. By default\n   * we disable `javascript:`, `vbscript:`, `file:` schemas, and almost all `data:...` schemas\n   * except some embedded image types.\n   *\n   * You can change this behaviour:\n   *\n   * ```javascript\n   * var md = require('markdown-it')();\n   * // enable everything\n   * md.validateLink = function () { return true; }\n   * ```\n   **/\n  this.validateLink = validateLink;\n\n  /**\n   * MarkdownIt#normalizeLink(url) -> String\n   *\n   * Function used to encode link url to a machine-readable format,\n   * which includes url-encoding, punycode, etc.\n   **/\n  this.normalizeLink = normalizeLink;\n\n  /**\n   * MarkdownIt#normalizeLinkText(url) -> String\n   *\n   * Function used to decode link url to a human-readable format`\n   **/\n  this.normalizeLinkText = normalizeLinkText;\n\n\n  // Expose utils & helpers for easy acces from plugins\n\n  /**\n   * MarkdownIt#utils -> utils\n   *\n   * Assorted utility functions, useful to write plugins. See details\n   * [here](https://github.com/markdown-it/markdown-it/blob/master/lib/common/utils.js).\n   **/\n  this.utils = utils;\n\n  /**\n   * MarkdownIt#helpers -> helpers\n   *\n   * Link components parser functions, useful to write plugins. See details\n   * [here](https://github.com/markdown-it/markdown-it/blob/master/lib/helpers).\n   **/\n  this.helpers = utils.assign({}, helpers);\n\n\n  this.options = {};\n  this.configure(presetName);\n\n  if (options) { this.set(options); }\n}\n\n\n/** chainable\n * MarkdownIt.set(options)\n *\n * Set parser options (in the same format as in constructor). Probably, you\n * will never need it, but you can change options after constructor call.\n *\n * ##### Example\n *\n * ```javascript\n * var md = require('markdown-it')()\n *             .set({ html: true, breaks: true })\n *             .set({ typographer, true });\n * ```\n *\n * __Note:__ To achieve the best possible performance, don't modify a\n * `markdown-it` instance options on the fly. If you need multiple configurations\n * it's best to create multiple instances and initialize each with separate\n * config.\n **/\nMarkdownIt.prototype.set = function (options) {\n  utils.assign(this.options, options);\n  return this;\n};\n\n\n/** chainable, internal\n * MarkdownIt.configure(presets)\n *\n * Batch load of all options and compenent settings. This is internal method,\n * and you probably will not need it. But if you with - see available presets\n * and data structure [here](https://github.com/markdown-it/markdown-it/tree/master/lib/presets)\n *\n * We strongly recommend to use presets instead of direct config loads. That\n * will give better compatibility with next versions.\n **/\nMarkdownIt.prototype.configure = function (presets) {\n  var self = this, presetName;\n\n  if (utils.isString(presets)) {\n    presetName = presets;\n    presets = config[presetName];\n    if (!presets) { throw new Error('Wrong `markdown-it` preset \"' + presetName + '\", check name'); }\n  }\n\n  if (!presets) { throw new Error('Wrong `markdown-it` preset, can\\'t be empty'); }\n\n  if (presets.options) { self.set(presets.options); }\n\n  if (presets.components) {\n    Object.keys(presets.components).forEach(function (name) {\n      if (presets.components[name].rules) {\n        self[name].ruler.enableOnly(presets.components[name].rules);\n      }\n      if (presets.components[name].rules2) {\n        self[name].ruler2.enableOnly(presets.components[name].rules2);\n      }\n    });\n  }\n  return this;\n};\n\n\n/** chainable\n * MarkdownIt.enable(list, ignoreInvalid)\n * - list (String|Array): rule name or list of rule names to enable\n * - ignoreInvalid (Boolean): set `true` to ignore errors when rule not found.\n *\n * Enable list or rules. It will automatically find appropriate components,\n * containing rules with given names. If rule not found, and `ignoreInvalid`\n * not set - throws exception.\n *\n * ##### Example\n *\n * ```javascript\n * var md = require('markdown-it')()\n *             .enable(['sub', 'sup'])\n *             .disable('smartquotes');\n * ```\n **/\nMarkdownIt.prototype.enable = function (list, ignoreInvalid) {\n  var result = [];\n\n  if (!Array.isArray(list)) { list = [ list ]; }\n\n  [ 'core', 'block', 'inline' ].forEach(function (chain) {\n    result = result.concat(this[chain].ruler.enable(list, true));\n  }, this);\n\n  result = result.concat(this.inline.ruler2.enable(list, true));\n\n  var missed = list.filter(function (name) { return result.indexOf(name) < 0; });\n\n  if (missed.length && !ignoreInvalid) {\n    throw new Error('MarkdownIt. Failed to enable unknown rule(s): ' + missed);\n  }\n\n  return this;\n};\n\n\n/** chainable\n * MarkdownIt.disable(list, ignoreInvalid)\n * - list (String|Array): rule name or list of rule names to disable.\n * - ignoreInvalid (Boolean): set `true` to ignore errors when rule not found.\n *\n * The same as [[MarkdownIt.enable]], but turn specified rules off.\n **/\nMarkdownIt.prototype.disable = function (list, ignoreInvalid) {\n  var result = [];\n\n  if (!Array.isArray(list)) { list = [ list ]; }\n\n  [ 'core', 'block', 'inline' ].forEach(function (chain) {\n    result = result.concat(this[chain].ruler.disable(list, true));\n  }, this);\n\n  result = result.concat(this.inline.ruler2.disable(list, true));\n\n  var missed = list.filter(function (name) { return result.indexOf(name) < 0; });\n\n  if (missed.length && !ignoreInvalid) {\n    throw new Error('MarkdownIt. Failed to disable unknown rule(s): ' + missed);\n  }\n  return this;\n};\n\n\n/** chainable\n * MarkdownIt.use(plugin, params)\n *\n * Load specified plugin with given params into current parser instance.\n * It's just a sugar to call `plugin(md, params)` with curring.\n *\n * ##### Example\n *\n * ```javascript\n * var iterator = require('markdown-it-for-inline');\n * var md = require('markdown-it')()\n *             .use(iterator, 'foo_replace', 'text', function (tokens, idx) {\n *               tokens[idx].content = tokens[idx].content.replace(/foo/g, 'bar');\n *             });\n * ```\n **/\nMarkdownIt.prototype.use = function (plugin /*, params, ... */) {\n  var args = [ this ].concat(Array.prototype.slice.call(arguments, 1));\n  plugin.apply(plugin, args);\n  return this;\n};\n\n\n/** internal\n * MarkdownIt.parse(src, env) -> Array\n * - src (String): source string\n * - env (Object): environment sandbox\n *\n * Parse input string and returns list of block tokens (special token type\n * \"inline\" will contain list of inline tokens). You should not call this\n * method directly, until you write custom renderer (for example, to produce\n * AST).\n *\n * `env` is used to pass data between \"distributed\" rules and return additional\n * metadata like reference info, needed for the renderer. It also can be used to\n * inject data in specific cases. Usually, you will be ok to pass `{}`,\n * and then pass updated object to renderer.\n **/\nMarkdownIt.prototype.parse = function (src, env) {\n  if (typeof src !== 'string') {\n    throw new Error('Input data should be a String');\n  }\n\n  var state = new this.core.State(src, this, env);\n\n  this.core.process(state);\n\n  return state.tokens;\n};\n\n\n/**\n * MarkdownIt.render(src [, env]) -> String\n * - src (String): source string\n * - env (Object): environment sandbox\n *\n * Render markdown string into html. It does all magic for you :).\n *\n * `env` can be used to inject additional metadata (`{}` by default).\n * But you will not need it with high probability. See also comment\n * in [[MarkdownIt.parse]].\n **/\nMarkdownIt.prototype.render = function (src, env) {\n  env = env || {};\n\n  return this.renderer.render(this.parse(src, env), this.options, env);\n};\n\n\n/** internal\n * MarkdownIt.parseInline(src, env) -> Array\n * - src (String): source string\n * - env (Object): environment sandbox\n *\n * The same as [[MarkdownIt.parse]] but skip all block rules. It returns the\n * block tokens list with the single `inline` element, containing parsed inline\n * tokens in `children` property. Also updates `env` object.\n **/\nMarkdownIt.prototype.parseInline = function (src, env) {\n  var state = new this.core.State(src, this, env);\n\n  state.inlineMode = true;\n  this.core.process(state);\n\n  return state.tokens;\n};\n\n\n/**\n * MarkdownIt.renderInline(src [, env]) -> String\n * - src (String): source string\n * - env (Object): environment sandbox\n *\n * Similar to [[MarkdownIt.render]] but for single paragraph content. Result\n * will NOT be wrapped into `<p>` tags.\n **/\nMarkdownIt.prototype.renderInline = function (src, env) {\n  env = env || {};\n\n  return this.renderer.render(this.parseInline(src, env), this.options, env);\n};\n\n\nmodule.exports = MarkdownIt;\n","\n'use strict';\n\n\nvar encodeCache = {};\n\n\n// Create a lookup array where anything but characters in `chars` string\n// and alphanumeric chars is percent-encoded.\n//\nfunction getEncodeCache(exclude) {\n  var i, ch, cache = encodeCache[exclude];\n  if (cache) { return cache; }\n\n  cache = encodeCache[exclude] = [];\n\n  for (i = 0; i < 128; i++) {\n    ch = String.fromCharCode(i);\n\n    if (/^[0-9a-z]$/i.test(ch)) {\n      // always allow unencoded alphanumeric characters\n      cache.push(ch);\n    } else {\n      cache.push('%' + ('0' + i.toString(16).toUpperCase()).slice(-2));\n    }\n  }\n\n  for (i = 0; i < exclude.length; i++) {\n    cache[exclude.charCodeAt(i)] = exclude[i];\n  }\n\n  return cache;\n}\n\n\n// Encode unsafe characters with percent-encoding, skipping already\n// encoded sequences.\n//\n//  - string       - string to encode\n//  - exclude      - list of characters to ignore (in addition to a-zA-Z0-9)\n//  - keepEscaped  - don't encode '%' in a correct escape sequence (default: true)\n//\nfunction encode(string, exclude, keepEscaped) {\n  var i, l, code, nextCode, cache,\n      result = '';\n\n  if (typeof exclude !== 'string') {\n    // encode(string, keepEscaped)\n    keepEscaped  = exclude;\n    exclude = encode.defaultChars;\n  }\n\n  if (typeof keepEscaped === 'undefined') {\n    keepEscaped = true;\n  }\n\n  cache = getEncodeCache(exclude);\n\n  for (i = 0, l = string.length; i < l; i++) {\n    code = string.charCodeAt(i);\n\n    if (keepEscaped && code === 0x25 /* % */ && i + 2 < l) {\n      if (/^[0-9a-f]{2}$/i.test(string.slice(i + 1, i + 3))) {\n        result += string.slice(i, i + 3);\n        i += 2;\n        continue;\n      }\n    }\n\n    if (code < 128) {\n      result += cache[code];\n      continue;\n    }\n\n    if (code >= 0xD800 && code <= 0xDFFF) {\n      if (code >= 0xD800 && code <= 0xDBFF && i + 1 < l) {\n        nextCode = string.charCodeAt(i + 1);\n        if (nextCode >= 0xDC00 && nextCode <= 0xDFFF) {\n          result += encodeURIComponent(string[i] + string[i + 1]);\n          i++;\n          continue;\n        }\n      }\n      result += '%EF%BF%BD';\n      continue;\n    }\n\n    result += encodeURIComponent(string[i]);\n  }\n\n  return result;\n}\n\nencode.defaultChars   = \";/?:@&=+$,-_.!~*'()#\";\nencode.componentChars = \"-_.!~*'()\";\n\n\nmodule.exports = encode;\n","\n'use strict';\n\n\n/* eslint-disable no-bitwise */\n\nvar decodeCache = {};\n\nfunction getDecodeCache(exclude) {\n  var i, ch, cache = decodeCache[exclude];\n  if (cache) { return cache; }\n\n  cache = decodeCache[exclude] = [];\n\n  for (i = 0; i < 128; i++) {\n    ch = String.fromCharCode(i);\n    cache.push(ch);\n  }\n\n  for (i = 0; i < exclude.length; i++) {\n    ch = exclude.charCodeAt(i);\n    cache[ch] = '%' + ('0' + ch.toString(16).toUpperCase()).slice(-2);\n  }\n\n  return cache;\n}\n\n\n// Decode percent-encoded string.\n//\nfunction decode(string, exclude) {\n  var cache;\n\n  if (typeof exclude !== 'string') {\n    exclude = decode.defaultChars;\n  }\n\n  cache = getDecodeCache(exclude);\n\n  return string.replace(/(%[a-f0-9]{2})+/gi, function(seq) {\n    var i, l, b1, b2, b3, b4, chr,\n        result = '';\n\n    for (i = 0, l = seq.length; i < l; i += 3) {\n      b1 = parseInt(seq.slice(i + 1, i + 3), 16);\n\n      if (b1 < 0x80) {\n        result += cache[b1];\n        continue;\n      }\n\n      if ((b1 & 0xE0) === 0xC0 && (i + 3 < l)) {\n        // 110xxxxx 10xxxxxx\n        b2 = parseInt(seq.slice(i + 4, i + 6), 16);\n\n        if ((b2 & 0xC0) === 0x80) {\n          chr = ((b1 << 6) & 0x7C0) | (b2 & 0x3F);\n\n          if (chr < 0x80) {\n            result += '\\ufffd\\ufffd';\n          } else {\n            result += String.fromCharCode(chr);\n          }\n\n          i += 3;\n          continue;\n        }\n      }\n\n      if ((b1 & 0xF0) === 0xE0 && (i + 6 < l)) {\n        // 1110xxxx 10xxxxxx 10xxxxxx\n        b2 = parseInt(seq.slice(i + 4, i + 6), 16);\n        b3 = parseInt(seq.slice(i + 7, i + 9), 16);\n\n        if ((b2 & 0xC0) === 0x80 && (b3 & 0xC0) === 0x80) {\n          chr = ((b1 << 12) & 0xF000) | ((b2 << 6) & 0xFC0) | (b3 & 0x3F);\n\n          if (chr < 0x800 || (chr >= 0xD800 && chr <= 0xDFFF)) {\n            result += '\\ufffd\\ufffd\\ufffd';\n          } else {\n            result += String.fromCharCode(chr);\n          }\n\n          i += 6;\n          continue;\n        }\n      }\n\n      if ((b1 & 0xF8) === 0xF0 && (i + 9 < l)) {\n        // 111110xx 10xxxxxx 10xxxxxx 10xxxxxx\n        b2 = parseInt(seq.slice(i + 4, i + 6), 16);\n        b3 = parseInt(seq.slice(i + 7, i + 9), 16);\n        b4 = parseInt(seq.slice(i + 10, i + 12), 16);\n\n        if ((b2 & 0xC0) === 0x80 && (b3 & 0xC0) === 0x80 && (b4 & 0xC0) === 0x80) {\n          chr = ((b1 << 18) & 0x1C0000) | ((b2 << 12) & 0x3F000) | ((b3 << 6) & 0xFC0) | (b4 & 0x3F);\n\n          if (chr < 0x10000 || chr > 0x10FFFF) {\n            result += '\\ufffd\\ufffd\\ufffd\\ufffd';\n          } else {\n            chr -= 0x10000;\n            result += String.fromCharCode(0xD800 + (chr >> 10), 0xDC00 + (chr & 0x3FF));\n          }\n\n          i += 9;\n          continue;\n        }\n      }\n\n      result += '\\ufffd';\n    }\n\n    return result;\n  });\n}\n\n\ndecode.defaultChars   = ';/?:@&=+$,#';\ndecode.componentChars = '';\n\n\nmodule.exports = decode;\n","\n'use strict';\n\n\nmodule.exports = function format(url) {\n  var result = '';\n\n  result += url.protocol || '';\n  result += url.slashes ? '//' : '';\n  result += url.auth ? url.auth + '@' : '';\n\n  if (url.hostname && url.hostname.indexOf(':') !== -1) {\n    // ipv6 address\n    result += '[' + url.hostname + ']';\n  } else {\n    result += url.hostname || '';\n  }\n\n  result += url.port ? ':' + url.port : '';\n  result += url.pathname || '';\n  result += url.search || '';\n  result += url.hash || '';\n\n  return result;\n};\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n'use strict';\n\n//\n// Changes from joyent/node:\n//\n// 1. No leading slash in paths,\n//    e.g. in `url.parse('http://foo?bar')` pathname is ``, not `/`\n//\n// 2. Backslashes are not replaced with slashes,\n//    so `http:\\\\example.org\\` is treated like a relative path\n//\n// 3. Trailing colon is treated like a part of the path,\n//    i.e. in `http://example.org:foo` pathname is `:foo`\n//\n// 4. Nothing is URL-encoded in the resulting object,\n//    (in joyent/node some chars in auth and paths are encoded)\n//\n// 5. `url.parse()` does not have `parseQueryString` argument\n//\n// 6. Removed extraneous result properties: `host`, `path`, `query`, etc.,\n//    which can be constructed using other parts of the url.\n//\n\n\nfunction Url() {\n  this.protocol = null;\n  this.slashes = null;\n  this.auth = null;\n  this.port = null;\n  this.hostname = null;\n  this.hash = null;\n  this.search = null;\n  this.pathname = null;\n}\n\n// Reference: RFC 3986, RFC 1808, RFC 2396\n\n// define these here so at least they only have to be\n// compiled once on the first module load.\nvar protocolPattern = /^([a-z0-9.+-]+:)/i,\n    portPattern = /:[0-9]*$/,\n\n    // Special case for a simple path URL\n    simplePathPattern = /^(\\/\\/?(?!\\/)[^\\?\\s]*)(\\?[^\\s]*)?$/,\n\n    // RFC 2396: characters reserved for delimiting URLs.\n    // We actually just auto-escape these.\n    delims = [ '<', '>', '\"', '`', ' ', '\\r', '\\n', '\\t' ],\n\n    // RFC 2396: characters not allowed for various reasons.\n    unwise = [ '{', '}', '|', '\\\\', '^', '`' ].concat(delims),\n\n    // Allowed by RFCs, but cause of XSS attacks.  Always escape these.\n    autoEscape = [ '\\'' ].concat(unwise),\n    // Characters that are never ever allowed in a hostname.\n    // Note that any invalid chars are also handled, but these\n    // are the ones that are *expected* to be seen, so we fast-path\n    // them.\n    nonHostChars = [ '%', '/', '?', ';', '#' ].concat(autoEscape),\n    hostEndingChars = [ '/', '?', '#' ],\n    hostnameMaxLen = 255,\n    hostnamePartPattern = /^[+a-z0-9A-Z_-]{0,63}$/,\n    hostnamePartStart = /^([+a-z0-9A-Z_-]{0,63})(.*)$/,\n    // protocols that can allow \"unsafe\" and \"unwise\" chars.\n    /* eslint-disable no-script-url */\n    // protocols that never have a hostname.\n    hostlessProtocol = {\n      'javascript': true,\n      'javascript:': true\n    },\n    // protocols that always contain a // bit.\n    slashedProtocol = {\n      'http': true,\n      'https': true,\n      'ftp': true,\n      'gopher': true,\n      'file': true,\n      'http:': true,\n      'https:': true,\n      'ftp:': true,\n      'gopher:': true,\n      'file:': true\n    };\n    /* eslint-enable no-script-url */\n\nfunction urlParse(url, slashesDenoteHost) {\n  if (url && url instanceof Url) { return url; }\n\n  var u = new Url();\n  u.parse(url, slashesDenoteHost);\n  return u;\n}\n\nUrl.prototype.parse = function(url, slashesDenoteHost) {\n  var i, l, lowerProto, hec, slashes,\n      rest = url;\n\n  // trim before proceeding.\n  // This is to support parse stuff like \"  http://foo.com  \\n\"\n  rest = rest.trim();\n\n  if (!slashesDenoteHost && url.split('#').length === 1) {\n    // Try fast path regexp\n    var simplePath = simplePathPattern.exec(rest);\n    if (simplePath) {\n      this.pathname = simplePath[1];\n      if (simplePath[2]) {\n        this.search = simplePath[2];\n      }\n      return this;\n    }\n  }\n\n  var proto = protocolPattern.exec(rest);\n  if (proto) {\n    proto = proto[0];\n    lowerProto = proto.toLowerCase();\n    this.protocol = proto;\n    rest = rest.substr(proto.length);\n  }\n\n  // figure out if it's got a host\n  // user@server is *always* interpreted as a hostname, and url\n  // resolution will treat //foo/bar as host=foo,path=bar because that's\n  // how the browser resolves relative URLs.\n  if (slashesDenoteHost || proto || rest.match(/^\\/\\/[^@\\/]+@[^@\\/]+/)) {\n    slashes = rest.substr(0, 2) === '//';\n    if (slashes && !(proto && hostlessProtocol[proto])) {\n      rest = rest.substr(2);\n      this.slashes = true;\n    }\n  }\n\n  if (!hostlessProtocol[proto] &&\n      (slashes || (proto && !slashedProtocol[proto]))) {\n\n    // there's a hostname.\n    // the first instance of /, ?, ;, or # ends the host.\n    //\n    // If there is an @ in the hostname, then non-host chars *are* allowed\n    // to the left of the last @ sign, unless some host-ending character\n    // comes *before* the @-sign.\n    // URLs are obnoxious.\n    //\n    // ex:\n    // http://a@b@c/ => user:a@b host:c\n    // http://a@b?@c => user:a host:c path:/?@c\n\n    // v0.12 TODO(isaacs): This is not quite how Chrome does things.\n    // Review our test case against browsers more comprehensively.\n\n    // find the first instance of any hostEndingChars\n    var hostEnd = -1;\n    for (i = 0; i < hostEndingChars.length; i++) {\n      hec = rest.indexOf(hostEndingChars[i]);\n      if (hec !== -1 && (hostEnd === -1 || hec < hostEnd)) {\n        hostEnd = hec;\n      }\n    }\n\n    // at this point, either we have an explicit point where the\n    // auth portion cannot go past, or the last @ char is the decider.\n    var auth, atSign;\n    if (hostEnd === -1) {\n      // atSign can be anywhere.\n      atSign = rest.lastIndexOf('@');\n    } else {\n      // atSign must be in auth portion.\n      // http://a@b/c@d => host:b auth:a path:/c@d\n      atSign = rest.lastIndexOf('@', hostEnd);\n    }\n\n    // Now we have a portion which is definitely the auth.\n    // Pull that off.\n    if (atSign !== -1) {\n      auth = rest.slice(0, atSign);\n      rest = rest.slice(atSign + 1);\n      this.auth = auth;\n    }\n\n    // the host is the remaining to the left of the first non-host char\n    hostEnd = -1;\n    for (i = 0; i < nonHostChars.length; i++) {\n      hec = rest.indexOf(nonHostChars[i]);\n      if (hec !== -1 && (hostEnd === -1 || hec < hostEnd)) {\n        hostEnd = hec;\n      }\n    }\n    // if we still have not hit it, then the entire thing is a host.\n    if (hostEnd === -1) {\n      hostEnd = rest.length;\n    }\n\n    if (rest[hostEnd - 1] === ':') { hostEnd--; }\n    var host = rest.slice(0, hostEnd);\n    rest = rest.slice(hostEnd);\n\n    // pull out port.\n    this.parseHost(host);\n\n    // we've indicated that there is a hostname,\n    // so even if it's empty, it has to be present.\n    this.hostname = this.hostname || '';\n\n    // if hostname begins with [ and ends with ]\n    // assume that it's an IPv6 address.\n    var ipv6Hostname = this.hostname[0] === '[' &&\n        this.hostname[this.hostname.length - 1] === ']';\n\n    // validate a little.\n    if (!ipv6Hostname) {\n      var hostparts = this.hostname.split(/\\./);\n      for (i = 0, l = hostparts.length; i < l; i++) {\n        var part = hostparts[i];\n        if (!part) { continue; }\n        if (!part.match(hostnamePartPattern)) {\n          var newpart = '';\n          for (var j = 0, k = part.length; j < k; j++) {\n            if (part.charCodeAt(j) > 127) {\n              // we replace non-ASCII char with a temporary placeholder\n              // we need this to make sure size of hostname is not\n              // broken by replacing non-ASCII by nothing\n              newpart += 'x';\n            } else {\n              newpart += part[j];\n            }\n          }\n          // we test again with ASCII char only\n          if (!newpart.match(hostnamePartPattern)) {\n            var validParts = hostparts.slice(0, i);\n            var notHost = hostparts.slice(i + 1);\n            var bit = part.match(hostnamePartStart);\n            if (bit) {\n              validParts.push(bit[1]);\n              notHost.unshift(bit[2]);\n            }\n            if (notHost.length) {\n              rest = notHost.join('.') + rest;\n            }\n            this.hostname = validParts.join('.');\n            break;\n          }\n        }\n      }\n    }\n\n    if (this.hostname.length > hostnameMaxLen) {\n      this.hostname = '';\n    }\n\n    // strip [ and ] from the hostname\n    // the host field still retains them, though\n    if (ipv6Hostname) {\n      this.hostname = this.hostname.substr(1, this.hostname.length - 2);\n    }\n  }\n\n  // chop off from the tail first.\n  var hash = rest.indexOf('#');\n  if (hash !== -1) {\n    // got a fragment string.\n    this.hash = rest.substr(hash);\n    rest = rest.slice(0, hash);\n  }\n  var qm = rest.indexOf('?');\n  if (qm !== -1) {\n    this.search = rest.substr(qm);\n    rest = rest.slice(0, qm);\n  }\n  if (rest) { this.pathname = rest; }\n  if (slashedProtocol[lowerProto] &&\n      this.hostname && !this.pathname) {\n    this.pathname = '';\n  }\n\n  return this;\n};\n\nUrl.prototype.parseHost = function(host) {\n  var port = portPattern.exec(host);\n  if (port) {\n    port = port[0];\n    if (port !== ':') {\n      this.port = port.substr(1);\n    }\n    host = host.substr(0, host.length - port.length);\n  }\n  if (host) { this.hostname = host; }\n};\n\nmodule.exports = urlParse;\n","'use strict';\n\nexports.Any = require('./properties/Any/regex');\nexports.Cc  = require('./categories/Cc/regex');\nexports.Cf  = require('./categories/Cf/regex');\nexports.P   = require('./categories/P/regex');\nexports.Z   = require('./categories/Z/regex');\n","module.exports=/[\\xAD\\u0600-\\u0605\\u061C\\u06DD\\u070F\\u08E2\\u180E\\u200B-\\u200F\\u202A-\\u202E\\u2060-\\u2064\\u2066-\\u206F\\uFEFF\\uFFF9-\\uFFFB]|\\uD804[\\uDCBD\\uDCCD]|\\uD82F[\\uDCA0-\\uDCA3]|\\uD834[\\uDD73-\\uDD7A]|\\uDB40[\\uDC01\\uDC20-\\uDC7F]/","// Just a shortcut for bulk export\n'use strict';\n\n\nexports.parseLinkLabel       = require('./parse_link_label');\nexports.parseLinkDestination = require('./parse_link_destination');\nexports.parseLinkTitle       = require('./parse_link_title');\n","// Parse link label\n//\n// this function assumes that first character (\"[\") already matches;\n// returns the end of the label\n//\n'use strict';\n\nmodule.exports = function parseLinkLabel(state, start, disableNested) {\n  var level, found, marker, prevPos,\n      labelEnd = -1,\n      max = state.posMax,\n      oldPos = state.pos;\n\n  state.pos = start + 1;\n  level = 1;\n\n  while (state.pos < max) {\n    marker = state.src.charCodeAt(state.pos);\n    if (marker === 0x5D /* ] */) {\n      level--;\n      if (level === 0) {\n        found = true;\n        break;\n      }\n    }\n\n    prevPos = state.pos;\n    state.md.inline.skipToken(state);\n    if (marker === 0x5B /* [ */) {\n      if (prevPos === state.pos - 1) {\n        // increase level if we find text `[`, which is not a part of any token\n        level++;\n      } else if (disableNested) {\n        state.pos = oldPos;\n        return -1;\n      }\n    }\n  }\n\n  if (found) {\n    labelEnd = state.pos;\n  }\n\n  // restore old state\n  state.pos = oldPos;\n\n  return labelEnd;\n};\n","// Parse link destination\n//\n'use strict';\n\n\nvar unescapeAll = require('../common/utils').unescapeAll;\n\n\nmodule.exports = function parseLinkDestination(str, pos, max) {\n  var code, level,\n      lines = 0,\n      start = pos,\n      result = {\n        ok: false,\n        pos: 0,\n        lines: 0,\n        str: ''\n      };\n\n  if (str.charCodeAt(pos) === 0x3C /* < */) {\n    pos++;\n    while (pos < max) {\n      code = str.charCodeAt(pos);\n      if (code === 0x0A /* \\n */) { return result; }\n      if (code === 0x3E /* > */) {\n        result.pos = pos + 1;\n        result.str = unescapeAll(str.slice(start + 1, pos));\n        result.ok = true;\n        return result;\n      }\n      if (code === 0x5C /* \\ */ && pos + 1 < max) {\n        pos += 2;\n        continue;\n      }\n\n      pos++;\n    }\n\n    // no closing '>'\n    return result;\n  }\n\n  // this should be ... } else { ... branch\n\n  level = 0;\n  while (pos < max) {\n    code = str.charCodeAt(pos);\n\n    if (code === 0x20) { break; }\n\n    // ascii control characters\n    if (code < 0x20 || code === 0x7F) { break; }\n\n    if (code === 0x5C /* \\ */ && pos + 1 < max) {\n      pos += 2;\n      continue;\n    }\n\n    if (code === 0x28 /* ( */) {\n      level++;\n    }\n\n    if (code === 0x29 /* ) */) {\n      if (level === 0) { break; }\n      level--;\n    }\n\n    pos++;\n  }\n\n  if (start === pos) { return result; }\n  if (level !== 0) { return result; }\n\n  result.str = unescapeAll(str.slice(start, pos));\n  result.lines = lines;\n  result.pos = pos;\n  result.ok = true;\n  return result;\n};\n","// Parse link title\n//\n'use strict';\n\n\nvar unescapeAll = require('../common/utils').unescapeAll;\n\n\nmodule.exports = function parseLinkTitle(str, pos, max) {\n  var code,\n      marker,\n      lines = 0,\n      start = pos,\n      result = {\n        ok: false,\n        pos: 0,\n        lines: 0,\n        str: ''\n      };\n\n  if (pos >= max) { return result; }\n\n  marker = str.charCodeAt(pos);\n\n  if (marker !== 0x22 /* \" */ && marker !== 0x27 /* ' */ && marker !== 0x28 /* ( */) { return result; }\n\n  pos++;\n\n  // if opening marker is \"(\", switch it to closing marker \")\"\n  if (marker === 0x28) { marker = 0x29; }\n\n  while (pos < max) {\n    code = str.charCodeAt(pos);\n    if (code === marker) {\n      result.pos = pos + 1;\n      result.lines = lines;\n      result.str = unescapeAll(str.slice(start + 1, pos));\n      result.ok = true;\n      return result;\n    } else if (code === 0x0A) {\n      lines++;\n    } else if (code === 0x5C /* \\ */ && pos + 1 < max) {\n      pos++;\n      if (str.charCodeAt(pos) === 0x0A) {\n        lines++;\n      }\n    }\n\n    pos++;\n  }\n\n  return result;\n};\n","/**\n * class Renderer\n *\n * Generates HTML from parsed token stream. Each instance has independent\n * copy of rules. Those can be rewritten with ease. Also, you can add new\n * rules if you create plugin and adds new token types.\n **/\n'use strict';\n\n\nvar assign          = require('./common/utils').assign;\nvar unescapeAll     = require('./common/utils').unescapeAll;\nvar escapeHtml      = require('./common/utils').escapeHtml;\n\n\n////////////////////////////////////////////////////////////////////////////////\n\nvar default_rules = {};\n\n\ndefault_rules.code_inline = function (tokens, idx, options, env, slf) {\n  var token = tokens[idx];\n\n  return  '<code' + slf.renderAttrs(token) + '>' +\n          escapeHtml(tokens[idx].content) +\n          '</code>';\n};\n\n\ndefault_rules.code_block = function (tokens, idx, options, env, slf) {\n  var token = tokens[idx];\n\n  return  '<pre' + slf.renderAttrs(token) + '><code>' +\n          escapeHtml(tokens[idx].content) +\n          '</code></pre>\\n';\n};\n\n\ndefault_rules.fence = function (tokens, idx, options, env, slf) {\n  var token = tokens[idx],\n      info = token.info ? unescapeAll(token.info).trim() : '',\n      langName = '',\n      highlighted, i, tmpAttrs, tmpToken;\n\n  if (info) {\n    langName = info.split(/\\s+/g)[0];\n  }\n\n  if (options.highlight) {\n    highlighted = options.highlight(token.content, langName) || escapeHtml(token.content);\n  } else {\n    highlighted = escapeHtml(token.content);\n  }\n\n  if (highlighted.indexOf('<pre') === 0) {\n    return highlighted + '\\n';\n  }\n\n  // If language exists, inject class gently, without modifying original token.\n  // May be, one day we will add .clone() for token and simplify this part, but\n  // now we prefer to keep things local.\n  if (info) {\n    i        = token.attrIndex('class');\n    tmpAttrs = token.attrs ? token.attrs.slice() : [];\n\n    if (i < 0) {\n      tmpAttrs.push([ 'class', options.langPrefix + langName ]);\n    } else {\n      tmpAttrs[i][1] += ' ' + options.langPrefix + langName;\n    }\n\n    // Fake token just to render attributes\n    tmpToken = {\n      attrs: tmpAttrs\n    };\n\n    return  '<pre><code' + slf.renderAttrs(tmpToken) + '>'\n          + highlighted\n          + '</code></pre>\\n';\n  }\n\n\n  return  '<pre><code' + slf.renderAttrs(token) + '>'\n        + highlighted\n        + '</code></pre>\\n';\n};\n\n\ndefault_rules.image = function (tokens, idx, options, env, slf) {\n  var token = tokens[idx];\n\n  // \"alt\" attr MUST be set, even if empty. Because it's mandatory and\n  // should be placed on proper position for tests.\n  //\n  // Replace content with actual value\n\n  token.attrs[token.attrIndex('alt')][1] =\n    slf.renderInlineAsText(token.children, options, env);\n\n  return slf.renderToken(tokens, idx, options);\n};\n\n\ndefault_rules.hardbreak = function (tokens, idx, options /*, env */) {\n  return options.xhtmlOut ? '<br />\\n' : '<br>\\n';\n};\ndefault_rules.softbreak = function (tokens, idx, options /*, env */) {\n  return options.breaks ? (options.xhtmlOut ? '<br />\\n' : '<br>\\n') : '\\n';\n};\n\n\ndefault_rules.text = function (tokens, idx /*, options, env */) {\n  return escapeHtml(tokens[idx].content);\n};\n\n\ndefault_rules.html_block = function (tokens, idx /*, options, env */) {\n  return tokens[idx].content;\n};\ndefault_rules.html_inline = function (tokens, idx /*, options, env */) {\n  return tokens[idx].content;\n};\n\n\n/**\n * new Renderer()\n *\n * Creates new [[Renderer]] instance and fill [[Renderer#rules]] with defaults.\n **/\nfunction Renderer() {\n\n  /**\n   * Renderer#rules -> Object\n   *\n   * Contains render rules for tokens. Can be updated and extended.\n   *\n   * ##### Example\n   *\n   * ```javascript\n   * var md = require('markdown-it')();\n   *\n   * md.renderer.rules.strong_open  = function () { return '<b>'; };\n   * md.renderer.rules.strong_close = function () { return '</b>'; };\n   *\n   * var result = md.renderInline(...);\n   * ```\n   *\n   * Each rule is called as independent static function with fixed signature:\n   *\n   * ```javascript\n   * function my_token_render(tokens, idx, options, env, renderer) {\n   *   // ...\n   *   return renderedHTML;\n   * }\n   * ```\n   *\n   * See [source code](https://github.com/markdown-it/markdown-it/blob/master/lib/renderer.js)\n   * for more details and examples.\n   **/\n  this.rules = assign({}, default_rules);\n}\n\n\n/**\n * Renderer.renderAttrs(token) -> String\n *\n * Render token attributes to string.\n **/\nRenderer.prototype.renderAttrs = function renderAttrs(token) {\n  var i, l, result;\n\n  if (!token.attrs) { return ''; }\n\n  result = '';\n\n  for (i = 0, l = token.attrs.length; i < l; i++) {\n    result += ' ' + escapeHtml(token.attrs[i][0]) + '=\"' + escapeHtml(token.attrs[i][1]) + '\"';\n  }\n\n  return result;\n};\n\n\n/**\n * Renderer.renderToken(tokens, idx, options) -> String\n * - tokens (Array): list of tokens\n * - idx (Numbed): token index to render\n * - options (Object): params of parser instance\n *\n * Default token renderer. Can be overriden by custom function\n * in [[Renderer#rules]].\n **/\nRenderer.prototype.renderToken = function renderToken(tokens, idx, options) {\n  var nextToken,\n      result = '',\n      needLf = false,\n      token = tokens[idx];\n\n  // Tight list paragraphs\n  if (token.hidden) {\n    return '';\n  }\n\n  // Insert a newline between hidden paragraph and subsequent opening\n  // block-level tag.\n  //\n  // For example, here we should insert a newline before blockquote:\n  //  - a\n  //    >\n  //\n  if (token.block && token.nesting !== -1 && idx && tokens[idx - 1].hidden) {\n    result += '\\n';\n  }\n\n  // Add token name, e.g. `<img`\n  result += (token.nesting === -1 ? '</' : '<') + token.tag;\n\n  // Encode attributes, e.g. `<img src=\"foo\"`\n  result += this.renderAttrs(token);\n\n  // Add a slash for self-closing tags, e.g. `<img src=\"foo\" /`\n  if (token.nesting === 0 && options.xhtmlOut) {\n    result += ' /';\n  }\n\n  // Check if we need to add a newline after this tag\n  if (token.block) {\n    needLf = true;\n\n    if (token.nesting === 1) {\n      if (idx + 1 < tokens.length) {\n        nextToken = tokens[idx + 1];\n\n        if (nextToken.type === 'inline' || nextToken.hidden) {\n          // Block-level tag containing an inline tag.\n          //\n          needLf = false;\n\n        } else if (nextToken.nesting === -1 && nextToken.tag === token.tag) {\n          // Opening tag + closing tag of the same type. E.g. `<li></li>`.\n          //\n          needLf = false;\n        }\n      }\n    }\n  }\n\n  result += needLf ? '>\\n' : '>';\n\n  return result;\n};\n\n\n/**\n * Renderer.renderInline(tokens, options, env) -> String\n * - tokens (Array): list on block tokens to renter\n * - options (Object): params of parser instance\n * - env (Object): additional data from parsed input (references, for example)\n *\n * The same as [[Renderer.render]], but for single token of `inline` type.\n **/\nRenderer.prototype.renderInline = function (tokens, options, env) {\n  var type,\n      result = '',\n      rules = this.rules;\n\n  for (var i = 0, len = tokens.length; i < len; i++) {\n    type = tokens[i].type;\n\n    if (typeof rules[type] !== 'undefined') {\n      result += rules[type](tokens, i, options, env, this);\n    } else {\n      result += this.renderToken(tokens, i, options);\n    }\n  }\n\n  return result;\n};\n\n\n/** internal\n * Renderer.renderInlineAsText(tokens, options, env) -> String\n * - tokens (Array): list on block tokens to renter\n * - options (Object): params of parser instance\n * - env (Object): additional data from parsed input (references, for example)\n *\n * Special kludge for image `alt` attributes to conform CommonMark spec.\n * Don't try to use it! Spec requires to show `alt` content with stripped markup,\n * instead of simple escaping.\n **/\nRenderer.prototype.renderInlineAsText = function (tokens, options, env) {\n  var result = '';\n\n  for (var i = 0, len = tokens.length; i < len; i++) {\n    if (tokens[i].type === 'text') {\n      result += tokens[i].content;\n    } else if (tokens[i].type === 'image') {\n      result += this.renderInlineAsText(tokens[i].children, options, env);\n    }\n  }\n\n  return result;\n};\n\n\n/**\n * Renderer.render(tokens, options, env) -> String\n * - tokens (Array): list on block tokens to renter\n * - options (Object): params of parser instance\n * - env (Object): additional data from parsed input (references, for example)\n *\n * Takes token stream and generates HTML. Probably, you will never need to call\n * this method directly.\n **/\nRenderer.prototype.render = function (tokens, options, env) {\n  var i, len, type,\n      result = '',\n      rules = this.rules;\n\n  for (i = 0, len = tokens.length; i < len; i++) {\n    type = tokens[i].type;\n\n    if (type === 'inline') {\n      result += this.renderInline(tokens[i].children, options, env);\n    } else if (typeof rules[type] !== 'undefined') {\n      result += rules[tokens[i].type](tokens, i, options, env, this);\n    } else {\n      result += this.renderToken(tokens, i, options, env);\n    }\n  }\n\n  return result;\n};\n\nmodule.exports = Renderer;\n","/** internal\n * class Core\n *\n * Top-level rules executor. Glues block/inline parsers and does intermediate\n * transformations.\n **/\n'use strict';\n\n\nvar Ruler  = require('./ruler');\n\n\nvar _rules = [\n  [ 'normalize',      require('./rules_core/normalize')      ],\n  [ 'block',          require('./rules_core/block')          ],\n  [ 'inline',         require('./rules_core/inline')         ],\n  [ 'linkify',        require('./rules_core/linkify')        ],\n  [ 'replacements',   require('./rules_core/replacements')   ],\n  [ 'smartquotes',    require('./rules_core/smartquotes')    ]\n];\n\n\n/**\n * new Core()\n **/\nfunction Core() {\n  /**\n   * Core#ruler -> Ruler\n   *\n   * [[Ruler]] instance. Keep configuration of core rules.\n   **/\n  this.ruler = new Ruler();\n\n  for (var i = 0; i < _rules.length; i++) {\n    this.ruler.push(_rules[i][0], _rules[i][1]);\n  }\n}\n\n\n/**\n * Core.process(state)\n *\n * Executes core chain rules.\n **/\nCore.prototype.process = function (state) {\n  var i, l, rules;\n\n  rules = this.ruler.getRules('');\n\n  for (i = 0, l = rules.length; i < l; i++) {\n    rules[i](state);\n  }\n};\n\nCore.prototype.State = require('./rules_core/state_core');\n\n\nmodule.exports = Core;\n","// Normalize input string\n\n'use strict';\n\n\n// https://spec.commonmark.org/0.29/#line-ending\nvar NEWLINES_RE  = /\\r\\n?|\\n/g;\nvar NULL_RE      = /\\0/g;\n\n\nmodule.exports = function normalize(state) {\n  var str;\n\n  // Normalize newlines\n  str = state.src.replace(NEWLINES_RE, '\\n');\n\n  // Replace NULL characters\n  str = str.replace(NULL_RE, '\\uFFFD');\n\n  state.src = str;\n};\n","'use strict';\n\n\nmodule.exports = function block(state) {\n  var token;\n\n  if (state.inlineMode) {\n    token          = new state.Token('inline', '', 0);\n    token.content  = state.src;\n    token.map      = [ 0, 1 ];\n    token.children = [];\n    state.tokens.push(token);\n  } else {\n    state.md.block.parse(state.src, state.md, state.env, state.tokens);\n  }\n};\n","'use strict';\n\nmodule.exports = function inline(state) {\n  var tokens = state.tokens, tok, i, l;\n\n  // Parse inlines\n  for (i = 0, l = tokens.length; i < l; i++) {\n    tok = tokens[i];\n    if (tok.type === 'inline') {\n      state.md.inline.parse(tok.content, state.md, state.env, tok.children);\n    }\n  }\n};\n","// Replace link-like texts with link nodes.\n//\n// Currently restricted by `md.validateLink()` to http/https/ftp\n//\n'use strict';\n\n\nvar arrayReplaceAt = require('../common/utils').arrayReplaceAt;\n\n\nfunction isLinkOpen(str) {\n  return /^<a[>\\s]/i.test(str);\n}\nfunction isLinkClose(str) {\n  return /^<\\/a\\s*>/i.test(str);\n}\n\n\nmodule.exports = function linkify(state) {\n  var i, j, l, tokens, token, currentToken, nodes, ln, text, pos, lastPos,\n      level, htmlLinkLevel, url, fullUrl, urlText,\n      blockTokens = state.tokens,\n      links;\n\n  if (!state.md.options.linkify) { return; }\n\n  for (j = 0, l = blockTokens.length; j < l; j++) {\n    if (blockTokens[j].type !== 'inline' ||\n        !state.md.linkify.pretest(blockTokens[j].content)) {\n      continue;\n    }\n\n    tokens = blockTokens[j].children;\n\n    htmlLinkLevel = 0;\n\n    // We scan from the end, to keep position when new tags added.\n    // Use reversed logic in links start/end match\n    for (i = tokens.length - 1; i >= 0; i--) {\n      currentToken = tokens[i];\n\n      // Skip content of markdown links\n      if (currentToken.type === 'link_close') {\n        i--;\n        while (tokens[i].level !== currentToken.level && tokens[i].type !== 'link_open') {\n          i--;\n        }\n        continue;\n      }\n\n      // Skip content of html tag links\n      if (currentToken.type === 'html_inline') {\n        if (isLinkOpen(currentToken.content) && htmlLinkLevel > 0) {\n          htmlLinkLevel--;\n        }\n        if (isLinkClose(currentToken.content)) {\n          htmlLinkLevel++;\n        }\n      }\n      if (htmlLinkLevel > 0) { continue; }\n\n      if (currentToken.type === 'text' && state.md.linkify.test(currentToken.content)) {\n\n        text = currentToken.content;\n        links = state.md.linkify.match(text);\n\n        // Now split string to nodes\n        nodes = [];\n        level = currentToken.level;\n        lastPos = 0;\n\n        for (ln = 0; ln < links.length; ln++) {\n\n          url = links[ln].url;\n          fullUrl = state.md.normalizeLink(url);\n          if (!state.md.validateLink(fullUrl)) { continue; }\n\n          urlText = links[ln].text;\n\n          // Linkifier might send raw hostnames like \"example.com\", where url\n          // starts with domain name. So we prepend http:// in those cases,\n          // and remove it afterwards.\n          //\n          if (!links[ln].schema) {\n            urlText = state.md.normalizeLinkText('http://' + urlText).replace(/^http:\\/\\//, '');\n          } else if (links[ln].schema === 'mailto:' && !/^mailto:/i.test(urlText)) {\n            urlText = state.md.normalizeLinkText('mailto:' + urlText).replace(/^mailto:/, '');\n          } else {\n            urlText = state.md.normalizeLinkText(urlText);\n          }\n\n          pos = links[ln].index;\n\n          if (pos > lastPos) {\n            token         = new state.Token('text', '', 0);\n            token.content = text.slice(lastPos, pos);\n            token.level   = level;\n            nodes.push(token);\n          }\n\n          token         = new state.Token('link_open', 'a', 1);\n          token.attrs   = [ [ 'href', fullUrl ] ];\n          token.level   = level++;\n          token.markup  = 'linkify';\n          token.info    = 'auto';\n          nodes.push(token);\n\n          token         = new state.Token('text', '', 0);\n          token.content = urlText;\n          token.level   = level;\n          nodes.push(token);\n\n          token         = new state.Token('link_close', 'a', -1);\n          token.level   = --level;\n          token.markup  = 'linkify';\n          token.info    = 'auto';\n          nodes.push(token);\n\n          lastPos = links[ln].lastIndex;\n        }\n        if (lastPos < text.length) {\n          token         = new state.Token('text', '', 0);\n          token.content = text.slice(lastPos);\n          token.level   = level;\n          nodes.push(token);\n        }\n\n        // replace current node\n        blockTokens[j].children = tokens = arrayReplaceAt(tokens, i, nodes);\n      }\n    }\n  }\n};\n","// Simple typographic replacements\n//\n// (c) (C) → ©\n// (tm) (TM) → ™\n// (r) (R) → ®\n// +- → ±\n// (p) (P) -> §\n// ... → … (also ?.... → ?.., !.... → !..)\n// ???????? → ???, !!!!! → !!!, `,,` → `,`\n// -- → &ndash;, --- → &mdash;\n//\n'use strict';\n\n// TODO:\n// - fractionals 1/2, 1/4, 3/4 -> ½, ¼, ¾\n// - miltiplication 2 x 4 -> 2 × 4\n\nvar RARE_RE = /\\+-|\\.\\.|\\?\\?\\?\\?|!!!!|,,|--/;\n\n// Workaround for phantomjs - need regex without /g flag,\n// or root check will fail every second time\nvar SCOPED_ABBR_TEST_RE = /\\((c|tm|r|p)\\)/i;\n\nvar SCOPED_ABBR_RE = /\\((c|tm|r|p)\\)/ig;\nvar SCOPED_ABBR = {\n  c: '©',\n  r: '®',\n  p: '§',\n  tm: '™'\n};\n\nfunction replaceFn(match, name) {\n  return SCOPED_ABBR[name.toLowerCase()];\n}\n\nfunction replace_scoped(inlineTokens) {\n  var i, token, inside_autolink = 0;\n\n  for (i = inlineTokens.length - 1; i >= 0; i--) {\n    token = inlineTokens[i];\n\n    if (token.type === 'text' && !inside_autolink) {\n      token.content = token.content.replace(SCOPED_ABBR_RE, replaceFn);\n    }\n\n    if (token.type === 'link_open' && token.info === 'auto') {\n      inside_autolink--;\n    }\n\n    if (token.type === 'link_close' && token.info === 'auto') {\n      inside_autolink++;\n    }\n  }\n}\n\nfunction replace_rare(inlineTokens) {\n  var i, token, inside_autolink = 0;\n\n  for (i = inlineTokens.length - 1; i >= 0; i--) {\n    token = inlineTokens[i];\n\n    if (token.type === 'text' && !inside_autolink) {\n      if (RARE_RE.test(token.content)) {\n        token.content = token.content\n          .replace(/\\+-/g, '±')\n          // .., ..., ....... -> …\n          // but ?..... & !..... -> ?.. & !..\n          .replace(/\\.{2,}/g, '…').replace(/([?!])…/g, '$1..')\n          .replace(/([?!]){4,}/g, '$1$1$1').replace(/,{2,}/g, ',')\n          // em-dash\n          .replace(/(^|[^-])---([^-]|$)/mg, '$1\\u2014$2')\n          // en-dash\n          .replace(/(^|\\s)--(\\s|$)/mg, '$1\\u2013$2')\n          .replace(/(^|[^-\\s])--([^-\\s]|$)/mg, '$1\\u2013$2');\n      }\n    }\n\n    if (token.type === 'link_open' && token.info === 'auto') {\n      inside_autolink--;\n    }\n\n    if (token.type === 'link_close' && token.info === 'auto') {\n      inside_autolink++;\n    }\n  }\n}\n\n\nmodule.exports = function replace(state) {\n  var blkIdx;\n\n  if (!state.md.options.typographer) { return; }\n\n  for (blkIdx = state.tokens.length - 1; blkIdx >= 0; blkIdx--) {\n\n    if (state.tokens[blkIdx].type !== 'inline') { continue; }\n\n    if (SCOPED_ABBR_TEST_RE.test(state.tokens[blkIdx].content)) {\n      replace_scoped(state.tokens[blkIdx].children);\n    }\n\n    if (RARE_RE.test(state.tokens[blkIdx].content)) {\n      replace_rare(state.tokens[blkIdx].children);\n    }\n\n  }\n};\n","// Convert straight quotation marks to typographic ones\n//\n'use strict';\n\n\nvar isWhiteSpace   = require('../common/utils').isWhiteSpace;\nvar isPunctChar    = require('../common/utils').isPunctChar;\nvar isMdAsciiPunct = require('../common/utils').isMdAsciiPunct;\n\nvar QUOTE_TEST_RE = /['\"]/;\nvar QUOTE_RE = /['\"]/g;\nvar APOSTROPHE = '\\u2019'; /* ’ */\n\n\nfunction replaceAt(str, index, ch) {\n  return str.substr(0, index) + ch + str.substr(index + 1);\n}\n\nfunction process_inlines(tokens, state) {\n  var i, token, text, t, pos, max, thisLevel, item, lastChar, nextChar,\n      isLastPunctChar, isNextPunctChar, isLastWhiteSpace, isNextWhiteSpace,\n      canOpen, canClose, j, isSingle, stack, openQuote, closeQuote;\n\n  stack = [];\n\n  for (i = 0; i < tokens.length; i++) {\n    token = tokens[i];\n\n    thisLevel = tokens[i].level;\n\n    for (j = stack.length - 1; j >= 0; j--) {\n      if (stack[j].level <= thisLevel) { break; }\n    }\n    stack.length = j + 1;\n\n    if (token.type !== 'text') { continue; }\n\n    text = token.content;\n    pos = 0;\n    max = text.length;\n\n    /*eslint no-labels:0,block-scoped-var:0*/\n    OUTER:\n    while (pos < max) {\n      QUOTE_RE.lastIndex = pos;\n      t = QUOTE_RE.exec(text);\n      if (!t) { break; }\n\n      canOpen = canClose = true;\n      pos = t.index + 1;\n      isSingle = (t[0] === \"'\");\n\n      // Find previous character,\n      // default to space if it's the beginning of the line\n      //\n      lastChar = 0x20;\n\n      if (t.index - 1 >= 0) {\n        lastChar = text.charCodeAt(t.index - 1);\n      } else {\n        for (j = i - 1; j >= 0; j--) {\n          if (tokens[j].type === 'softbreak' || tokens[j].type === 'hardbreak') break; // lastChar defaults to 0x20\n          if (tokens[j].type !== 'text') continue;\n\n          lastChar = tokens[j].content.charCodeAt(tokens[j].content.length - 1);\n          break;\n        }\n      }\n\n      // Find next character,\n      // default to space if it's the end of the line\n      //\n      nextChar = 0x20;\n\n      if (pos < max) {\n        nextChar = text.charCodeAt(pos);\n      } else {\n        for (j = i + 1; j < tokens.length; j++) {\n          if (tokens[j].type === 'softbreak' || tokens[j].type === 'hardbreak') break; // nextChar defaults to 0x20\n          if (tokens[j].type !== 'text') continue;\n\n          nextChar = tokens[j].content.charCodeAt(0);\n          break;\n        }\n      }\n\n      isLastPunctChar = isMdAsciiPunct(lastChar) || isPunctChar(String.fromCharCode(lastChar));\n      isNextPunctChar = isMdAsciiPunct(nextChar) || isPunctChar(String.fromCharCode(nextChar));\n\n      isLastWhiteSpace = isWhiteSpace(lastChar);\n      isNextWhiteSpace = isWhiteSpace(nextChar);\n\n      if (isNextWhiteSpace) {\n        canOpen = false;\n      } else if (isNextPunctChar) {\n        if (!(isLastWhiteSpace || isLastPunctChar)) {\n          canOpen = false;\n        }\n      }\n\n      if (isLastWhiteSpace) {\n        canClose = false;\n      } else if (isLastPunctChar) {\n        if (!(isNextWhiteSpace || isNextPunctChar)) {\n          canClose = false;\n        }\n      }\n\n      if (nextChar === 0x22 /* \" */ && t[0] === '\"') {\n        if (lastChar >= 0x30 /* 0 */ && lastChar <= 0x39 /* 9 */) {\n          // special case: 1\"\" - count first quote as an inch\n          canClose = canOpen = false;\n        }\n      }\n\n      if (canOpen && canClose) {\n        // treat this as the middle of the word\n        canOpen = false;\n        canClose = isNextPunctChar;\n      }\n\n      if (!canOpen && !canClose) {\n        // middle of word\n        if (isSingle) {\n          token.content = replaceAt(token.content, t.index, APOSTROPHE);\n        }\n        continue;\n      }\n\n      if (canClose) {\n        // this could be a closing quote, rewind the stack to get a match\n        for (j = stack.length - 1; j >= 0; j--) {\n          item = stack[j];\n          if (stack[j].level < thisLevel) { break; }\n          if (item.single === isSingle && stack[j].level === thisLevel) {\n            item = stack[j];\n\n            if (isSingle) {\n              openQuote = state.md.options.quotes[2];\n              closeQuote = state.md.options.quotes[3];\n            } else {\n              openQuote = state.md.options.quotes[0];\n              closeQuote = state.md.options.quotes[1];\n            }\n\n            // replace token.content *before* tokens[item.token].content,\n            // because, if they are pointing at the same token, replaceAt\n            // could mess up indices when quote length != 1\n            token.content = replaceAt(token.content, t.index, closeQuote);\n            tokens[item.token].content = replaceAt(\n              tokens[item.token].content, item.pos, openQuote);\n\n            pos += closeQuote.length - 1;\n            if (item.token === i) { pos += openQuote.length - 1; }\n\n            text = token.content;\n            max = text.length;\n\n            stack.length = j;\n            continue OUTER;\n          }\n        }\n      }\n\n      if (canOpen) {\n        stack.push({\n          token: i,\n          pos: t.index,\n          single: isSingle,\n          level: thisLevel\n        });\n      } else if (canClose && isSingle) {\n        token.content = replaceAt(token.content, t.index, APOSTROPHE);\n      }\n    }\n  }\n}\n\n\nmodule.exports = function smartquotes(state) {\n  /*eslint max-depth:0*/\n  var blkIdx;\n\n  if (!state.md.options.typographer) { return; }\n\n  for (blkIdx = state.tokens.length - 1; blkIdx >= 0; blkIdx--) {\n\n    if (state.tokens[blkIdx].type !== 'inline' ||\n        !QUOTE_TEST_RE.test(state.tokens[blkIdx].content)) {\n      continue;\n    }\n\n    process_inlines(state.tokens[blkIdx].children, state);\n  }\n};\n","// Core state object\n//\n'use strict';\n\nvar Token = require('../token');\n\n\nfunction StateCore(src, md, env) {\n  this.src = src;\n  this.env = env;\n  this.tokens = [];\n  this.inlineMode = false;\n  this.md = md; // link to parser instance\n}\n\n// re-export Token class to use in core rules\nStateCore.prototype.Token = Token;\n\n\nmodule.exports = StateCore;\n","/** internal\n * class ParserBlock\n *\n * Block-level tokenizer.\n **/\n'use strict';\n\n\nvar Ruler           = require('./ruler');\n\n\nvar _rules = [\n  // First 2 params - rule name & source. Secondary array - list of rules,\n  // which can be terminated by this one.\n  [ 'table',      require('./rules_block/table'),      [ 'paragraph', 'reference' ] ],\n  [ 'code',       require('./rules_block/code') ],\n  [ 'fence',      require('./rules_block/fence'),      [ 'paragraph', 'reference', 'blockquote', 'list' ] ],\n  [ 'blockquote', require('./rules_block/blockquote'), [ 'paragraph', 'reference', 'blockquote', 'list' ] ],\n  [ 'hr',         require('./rules_block/hr'),         [ 'paragraph', 'reference', 'blockquote', 'list' ] ],\n  [ 'list',       require('./rules_block/list'),       [ 'paragraph', 'reference', 'blockquote' ] ],\n  [ 'reference',  require('./rules_block/reference') ],\n  [ 'heading',    require('./rules_block/heading'),    [ 'paragraph', 'reference', 'blockquote' ] ],\n  [ 'lheading',   require('./rules_block/lheading') ],\n  [ 'html_block', require('./rules_block/html_block'), [ 'paragraph', 'reference', 'blockquote' ] ],\n  [ 'paragraph',  require('./rules_block/paragraph') ]\n];\n\n\n/**\n * new ParserBlock()\n **/\nfunction ParserBlock() {\n  /**\n   * ParserBlock#ruler -> Ruler\n   *\n   * [[Ruler]] instance. Keep configuration of block rules.\n   **/\n  this.ruler = new Ruler();\n\n  for (var i = 0; i < _rules.length; i++) {\n    this.ruler.push(_rules[i][0], _rules[i][1], { alt: (_rules[i][2] || []).slice() });\n  }\n}\n\n\n// Generate tokens for input range\n//\nParserBlock.prototype.tokenize = function (state, startLine, endLine) {\n  var ok, i,\n      rules = this.ruler.getRules(''),\n      len = rules.length,\n      line = startLine,\n      hasEmptyLines = false,\n      maxNesting = state.md.options.maxNesting;\n\n  while (line < endLine) {\n    state.line = line = state.skipEmptyLines(line);\n    if (line >= endLine) { break; }\n\n    // Termination condition for nested calls.\n    // Nested calls currently used for blockquotes & lists\n    if (state.sCount[line] < state.blkIndent) { break; }\n\n    // If nesting level exceeded - skip tail to the end. That's not ordinary\n    // situation and we should not care about content.\n    if (state.level >= maxNesting) {\n      state.line = endLine;\n      break;\n    }\n\n    // Try all possible rules.\n    // On success, rule should:\n    //\n    // - update `state.line`\n    // - update `state.tokens`\n    // - return true\n\n    for (i = 0; i < len; i++) {\n      ok = rules[i](state, line, endLine, false);\n      if (ok) { break; }\n    }\n\n    // set state.tight if we had an empty line before current tag\n    // i.e. latest empty line should not count\n    state.tight = !hasEmptyLines;\n\n    // paragraph might \"eat\" one newline after it in nested lists\n    if (state.isEmpty(state.line - 1)) {\n      hasEmptyLines = true;\n    }\n\n    line = state.line;\n\n    if (line < endLine && state.isEmpty(line)) {\n      hasEmptyLines = true;\n      line++;\n      state.line = line;\n    }\n  }\n};\n\n\n/**\n * ParserBlock.parse(str, md, env, outTokens)\n *\n * Process input string and push block tokens into `outTokens`\n **/\nParserBlock.prototype.parse = function (src, md, env, outTokens) {\n  var state;\n\n  if (!src) { return; }\n\n  state = new this.State(src, md, env, outTokens);\n\n  this.tokenize(state, state.line, state.lineMax);\n};\n\n\nParserBlock.prototype.State = require('./rules_block/state_block');\n\n\nmodule.exports = ParserBlock;\n","// GFM table, non-standard\n\n'use strict';\n\nvar isSpace = require('../common/utils').isSpace;\n\n\nfunction getLine(state, line) {\n  var pos = state.bMarks[line] + state.blkIndent,\n      max = state.eMarks[line];\n\n  return state.src.substr(pos, max - pos);\n}\n\nfunction escapedSplit(str) {\n  var result = [],\n      pos = 0,\n      max = str.length,\n      ch,\n      escapes = 0,\n      lastPos = 0,\n      backTicked = false,\n      lastBackTick = 0;\n\n  ch  = str.charCodeAt(pos);\n\n  while (pos < max) {\n    if (ch === 0x60/* ` */) {\n      if (backTicked) {\n        // make \\` close code sequence, but not open it;\n        // the reason is: `\\` is correct code block\n        backTicked = false;\n        lastBackTick = pos;\n      } else if (escapes % 2 === 0) {\n        backTicked = true;\n        lastBackTick = pos;\n      }\n    } else if (ch === 0x7c/* | */ && (escapes % 2 === 0) && !backTicked) {\n      result.push(str.substring(lastPos, pos));\n      lastPos = pos + 1;\n    }\n\n    if (ch === 0x5c/* \\ */) {\n      escapes++;\n    } else {\n      escapes = 0;\n    }\n\n    pos++;\n\n    // If there was an un-closed backtick, go back to just after\n    // the last backtick, but as if it was a normal character\n    if (pos === max && backTicked) {\n      backTicked = false;\n      pos = lastBackTick + 1;\n    }\n\n    ch = str.charCodeAt(pos);\n  }\n\n  result.push(str.substring(lastPos));\n\n  return result;\n}\n\n\nmodule.exports = function table(state, startLine, endLine, silent) {\n  var ch, lineText, pos, i, nextLine, columns, columnCount, token,\n      aligns, t, tableLines, tbodyLines;\n\n  // should have at least two lines\n  if (startLine + 2 > endLine) { return false; }\n\n  nextLine = startLine + 1;\n\n  if (state.sCount[nextLine] < state.blkIndent) { return false; }\n\n  // if it's indented more than 3 spaces, it should be a code block\n  if (state.sCount[nextLine] - state.blkIndent >= 4) { return false; }\n\n  // first character of the second line should be '|', '-', ':',\n  // and no other characters are allowed but spaces;\n  // basically, this is the equivalent of /^[-:|][-:|\\s]*$/ regexp\n\n  pos = state.bMarks[nextLine] + state.tShift[nextLine];\n  if (pos >= state.eMarks[nextLine]) { return false; }\n\n  ch = state.src.charCodeAt(pos++);\n  if (ch !== 0x7C/* | */ && ch !== 0x2D/* - */ && ch !== 0x3A/* : */) { return false; }\n\n  while (pos < state.eMarks[nextLine]) {\n    ch = state.src.charCodeAt(pos);\n\n    if (ch !== 0x7C/* | */ && ch !== 0x2D/* - */ && ch !== 0x3A/* : */ && !isSpace(ch)) { return false; }\n\n    pos++;\n  }\n\n  lineText = getLine(state, startLine + 1);\n\n  columns = lineText.split('|');\n  aligns = [];\n  for (i = 0; i < columns.length; i++) {\n    t = columns[i].trim();\n    if (!t) {\n      // allow empty columns before and after table, but not in between columns;\n      // e.g. allow ` |---| `, disallow ` ---||--- `\n      if (i === 0 || i === columns.length - 1) {\n        continue;\n      } else {\n        return false;\n      }\n    }\n\n    if (!/^:?-+:?$/.test(t)) { return false; }\n    if (t.charCodeAt(t.length - 1) === 0x3A/* : */) {\n      aligns.push(t.charCodeAt(0) === 0x3A/* : */ ? 'center' : 'right');\n    } else if (t.charCodeAt(0) === 0x3A/* : */) {\n      aligns.push('left');\n    } else {\n      aligns.push('');\n    }\n  }\n\n  lineText = getLine(state, startLine).trim();\n  if (lineText.indexOf('|') === -1) { return false; }\n  if (state.sCount[startLine] - state.blkIndent >= 4) { return false; }\n  columns = escapedSplit(lineText.replace(/^\\||\\|$/g, ''));\n\n  // header row will define an amount of columns in the entire table,\n  // and align row shouldn't be smaller than that (the rest of the rows can)\n  columnCount = columns.length;\n  if (columnCount > aligns.length) { return false; }\n\n  if (silent) { return true; }\n\n  token     = state.push('table_open', 'table', 1);\n  token.map = tableLines = [ startLine, 0 ];\n\n  token     = state.push('thead_open', 'thead', 1);\n  token.map = [ startLine, startLine + 1 ];\n\n  token     = state.push('tr_open', 'tr', 1);\n  token.map = [ startLine, startLine + 1 ];\n\n  for (i = 0; i < columns.length; i++) {\n    token          = state.push('th_open', 'th', 1);\n    token.map      = [ startLine, startLine + 1 ];\n    if (aligns[i]) {\n      token.attrs  = [ [ 'style', 'text-align:' + aligns[i] ] ];\n    }\n\n    token          = state.push('inline', '', 0);\n    token.content  = columns[i].trim();\n    token.map      = [ startLine, startLine + 1 ];\n    token.children = [];\n\n    token          = state.push('th_close', 'th', -1);\n  }\n\n  token     = state.push('tr_close', 'tr', -1);\n  token     = state.push('thead_close', 'thead', -1);\n\n  token     = state.push('tbody_open', 'tbody', 1);\n  token.map = tbodyLines = [ startLine + 2, 0 ];\n\n  for (nextLine = startLine + 2; nextLine < endLine; nextLine++) {\n    if (state.sCount[nextLine] < state.blkIndent) { break; }\n\n    lineText = getLine(state, nextLine).trim();\n    if (lineText.indexOf('|') === -1) { break; }\n    if (state.sCount[nextLine] - state.blkIndent >= 4) { break; }\n    columns = escapedSplit(lineText.replace(/^\\||\\|$/g, ''));\n\n    token = state.push('tr_open', 'tr', 1);\n    for (i = 0; i < columnCount; i++) {\n      token          = state.push('td_open', 'td', 1);\n      if (aligns[i]) {\n        token.attrs  = [ [ 'style', 'text-align:' + aligns[i] ] ];\n      }\n\n      token          = state.push('inline', '', 0);\n      token.content  = columns[i] ? columns[i].trim() : '';\n      token.children = [];\n\n      token          = state.push('td_close', 'td', -1);\n    }\n    token = state.push('tr_close', 'tr', -1);\n  }\n  token = state.push('tbody_close', 'tbody', -1);\n  token = state.push('table_close', 'table', -1);\n\n  tableLines[1] = tbodyLines[1] = nextLine;\n  state.line = nextLine;\n  return true;\n};\n","// Code block (4 spaces padded)\n\n'use strict';\n\n\nmodule.exports = function code(state, startLine, endLine/*, silent*/) {\n  var nextLine, last, token;\n\n  if (state.sCount[startLine] - state.blkIndent < 4) { return false; }\n\n  last = nextLine = startLine + 1;\n\n  while (nextLine < endLine) {\n    if (state.isEmpty(nextLine)) {\n      nextLine++;\n      continue;\n    }\n\n    if (state.sCount[nextLine] - state.blkIndent >= 4) {\n      nextLine++;\n      last = nextLine;\n      continue;\n    }\n    break;\n  }\n\n  state.line = last;\n\n  token         = state.push('code_block', 'code', 0);\n  token.content = state.getLines(startLine, last, 4 + state.blkIndent, true);\n  token.map     = [ startLine, state.line ];\n\n  return true;\n};\n","// fences (``` lang, ~~~ lang)\n\n'use strict';\n\n\nmodule.exports = function fence(state, startLine, endLine, silent) {\n  var marker, len, params, nextLine, mem, token, markup,\n      haveEndMarker = false,\n      pos = state.bMarks[startLine] + state.tShift[startLine],\n      max = state.eMarks[startLine];\n\n  // if it's indented more than 3 spaces, it should be a code block\n  if (state.sCount[startLine] - state.blkIndent >= 4) { return false; }\n\n  if (pos + 3 > max) { return false; }\n\n  marker = state.src.charCodeAt(pos);\n\n  if (marker !== 0x7E/* ~ */ && marker !== 0x60 /* ` */) {\n    return false;\n  }\n\n  // scan marker length\n  mem = pos;\n  pos = state.skipChars(pos, marker);\n\n  len = pos - mem;\n\n  if (len < 3) { return false; }\n\n  markup = state.src.slice(mem, pos);\n  params = state.src.slice(pos, max);\n\n  if (marker === 0x60 /* ` */) {\n    if (params.indexOf(String.fromCharCode(marker)) >= 0) {\n      return false;\n    }\n  }\n\n  // Since start is found, we can report success here in validation mode\n  if (silent) { return true; }\n\n  // search end of block\n  nextLine = startLine;\n\n  for (;;) {\n    nextLine++;\n    if (nextLine >= endLine) {\n      // unclosed block should be autoclosed by end of document.\n      // also block seems to be autoclosed by end of parent\n      break;\n    }\n\n    pos = mem = state.bMarks[nextLine] + state.tShift[nextLine];\n    max = state.eMarks[nextLine];\n\n    if (pos < max && state.sCount[nextLine] < state.blkIndent) {\n      // non-empty line with negative indent should stop the list:\n      // - ```\n      //  test\n      break;\n    }\n\n    if (state.src.charCodeAt(pos) !== marker) { continue; }\n\n    if (state.sCount[nextLine] - state.blkIndent >= 4) {\n      // closing fence should be indented less than 4 spaces\n      continue;\n    }\n\n    pos = state.skipChars(pos, marker);\n\n    // closing code fence must be at least as long as the opening one\n    if (pos - mem < len) { continue; }\n\n    // make sure tail has spaces only\n    pos = state.skipSpaces(pos);\n\n    if (pos < max) { continue; }\n\n    haveEndMarker = true;\n    // found!\n    break;\n  }\n\n  // If a fence has heading spaces, they should be removed from its inner block\n  len = state.sCount[startLine];\n\n  state.line = nextLine + (haveEndMarker ? 1 : 0);\n\n  token         = state.push('fence', 'code', 0);\n  token.info    = params;\n  token.content = state.getLines(startLine + 1, nextLine, len, true);\n  token.markup  = markup;\n  token.map     = [ startLine, state.line ];\n\n  return true;\n};\n","// Block quotes\n\n'use strict';\n\nvar isSpace = require('../common/utils').isSpace;\n\n\nmodule.exports = function blockquote(state, startLine, endLine, silent) {\n  var adjustTab,\n      ch,\n      i,\n      initial,\n      l,\n      lastLineEmpty,\n      lines,\n      nextLine,\n      offset,\n      oldBMarks,\n      oldBSCount,\n      oldIndent,\n      oldParentType,\n      oldSCount,\n      oldTShift,\n      spaceAfterMarker,\n      terminate,\n      terminatorRules,\n      token,\n      wasOutdented,\n      oldLineMax = state.lineMax,\n      pos = state.bMarks[startLine] + state.tShift[startLine],\n      max = state.eMarks[startLine];\n\n  // if it's indented more than 3 spaces, it should be a code block\n  if (state.sCount[startLine] - state.blkIndent >= 4) { return false; }\n\n  // check the block quote marker\n  if (state.src.charCodeAt(pos++) !== 0x3E/* > */) { return false; }\n\n  // we know that it's going to be a valid blockquote,\n  // so no point trying to find the end of it in silent mode\n  if (silent) { return true; }\n\n  // skip spaces after \">\" and re-calculate offset\n  initial = offset = state.sCount[startLine] + pos - (state.bMarks[startLine] + state.tShift[startLine]);\n\n  // skip one optional space after '>'\n  if (state.src.charCodeAt(pos) === 0x20 /* space */) {\n    // ' >   test '\n    //     ^ -- position start of line here:\n    pos++;\n    initial++;\n    offset++;\n    adjustTab = false;\n    spaceAfterMarker = true;\n  } else if (state.src.charCodeAt(pos) === 0x09 /* tab */) {\n    spaceAfterMarker = true;\n\n    if ((state.bsCount[startLine] + offset) % 4 === 3) {\n      // '  >\\t  test '\n      //       ^ -- position start of line here (tab has width===1)\n      pos++;\n      initial++;\n      offset++;\n      adjustTab = false;\n    } else {\n      // ' >\\t  test '\n      //    ^ -- position start of line here + shift bsCount slightly\n      //         to make extra space appear\n      adjustTab = true;\n    }\n  } else {\n    spaceAfterMarker = false;\n  }\n\n  oldBMarks = [ state.bMarks[startLine] ];\n  state.bMarks[startLine] = pos;\n\n  while (pos < max) {\n    ch = state.src.charCodeAt(pos);\n\n    if (isSpace(ch)) {\n      if (ch === 0x09) {\n        offset += 4 - (offset + state.bsCount[startLine] + (adjustTab ? 1 : 0)) % 4;\n      } else {\n        offset++;\n      }\n    } else {\n      break;\n    }\n\n    pos++;\n  }\n\n  oldBSCount = [ state.bsCount[startLine] ];\n  state.bsCount[startLine] = state.sCount[startLine] + 1 + (spaceAfterMarker ? 1 : 0);\n\n  lastLineEmpty = pos >= max;\n\n  oldSCount = [ state.sCount[startLine] ];\n  state.sCount[startLine] = offset - initial;\n\n  oldTShift = [ state.tShift[startLine] ];\n  state.tShift[startLine] = pos - state.bMarks[startLine];\n\n  terminatorRules = state.md.block.ruler.getRules('blockquote');\n\n  oldParentType = state.parentType;\n  state.parentType = 'blockquote';\n  wasOutdented = false;\n\n  // Search the end of the block\n  //\n  // Block ends with either:\n  //  1. an empty line outside:\n  //     ```\n  //     > test\n  //\n  //     ```\n  //  2. an empty line inside:\n  //     ```\n  //     >\n  //     test\n  //     ```\n  //  3. another tag:\n  //     ```\n  //     > test\n  //      - - -\n  //     ```\n  for (nextLine = startLine + 1; nextLine < endLine; nextLine++) {\n    // check if it's outdented, i.e. it's inside list item and indented\n    // less than said list item:\n    //\n    // ```\n    // 1. anything\n    //    > current blockquote\n    // 2. checking this line\n    // ```\n    if (state.sCount[nextLine] < state.blkIndent) wasOutdented = true;\n\n    pos = state.bMarks[nextLine] + state.tShift[nextLine];\n    max = state.eMarks[nextLine];\n\n    if (pos >= max) {\n      // Case 1: line is not inside the blockquote, and this line is empty.\n      break;\n    }\n\n    if (state.src.charCodeAt(pos++) === 0x3E/* > */ && !wasOutdented) {\n      // This line is inside the blockquote.\n\n      // skip spaces after \">\" and re-calculate offset\n      initial = offset = state.sCount[nextLine] + pos - (state.bMarks[nextLine] + state.tShift[nextLine]);\n\n      // skip one optional space after '>'\n      if (state.src.charCodeAt(pos) === 0x20 /* space */) {\n        // ' >   test '\n        //     ^ -- position start of line here:\n        pos++;\n        initial++;\n        offset++;\n        adjustTab = false;\n        spaceAfterMarker = true;\n      } else if (state.src.charCodeAt(pos) === 0x09 /* tab */) {\n        spaceAfterMarker = true;\n\n        if ((state.bsCount[nextLine] + offset) % 4 === 3) {\n          // '  >\\t  test '\n          //       ^ -- position start of line here (tab has width===1)\n          pos++;\n          initial++;\n          offset++;\n          adjustTab = false;\n        } else {\n          // ' >\\t  test '\n          //    ^ -- position start of line here + shift bsCount slightly\n          //         to make extra space appear\n          adjustTab = true;\n        }\n      } else {\n        spaceAfterMarker = false;\n      }\n\n      oldBMarks.push(state.bMarks[nextLine]);\n      state.bMarks[nextLine] = pos;\n\n      while (pos < max) {\n        ch = state.src.charCodeAt(pos);\n\n        if (isSpace(ch)) {\n          if (ch === 0x09) {\n            offset += 4 - (offset + state.bsCount[nextLine] + (adjustTab ? 1 : 0)) % 4;\n          } else {\n            offset++;\n          }\n        } else {\n          break;\n        }\n\n        pos++;\n      }\n\n      lastLineEmpty = pos >= max;\n\n      oldBSCount.push(state.bsCount[nextLine]);\n      state.bsCount[nextLine] = state.sCount[nextLine] + 1 + (spaceAfterMarker ? 1 : 0);\n\n      oldSCount.push(state.sCount[nextLine]);\n      state.sCount[nextLine] = offset - initial;\n\n      oldTShift.push(state.tShift[nextLine]);\n      state.tShift[nextLine] = pos - state.bMarks[nextLine];\n      continue;\n    }\n\n    // Case 2: line is not inside the blockquote, and the last line was empty.\n    if (lastLineEmpty) { break; }\n\n    // Case 3: another tag found.\n    terminate = false;\n    for (i = 0, l = terminatorRules.length; i < l; i++) {\n      if (terminatorRules[i](state, nextLine, endLine, true)) {\n        terminate = true;\n        break;\n      }\n    }\n\n    if (terminate) {\n      // Quirk to enforce \"hard termination mode\" for paragraphs;\n      // normally if you call `tokenize(state, startLine, nextLine)`,\n      // paragraphs will look below nextLine for paragraph continuation,\n      // but if blockquote is terminated by another tag, they shouldn't\n      state.lineMax = nextLine;\n\n      if (state.blkIndent !== 0) {\n        // state.blkIndent was non-zero, we now set it to zero,\n        // so we need to re-calculate all offsets to appear as\n        // if indent wasn't changed\n        oldBMarks.push(state.bMarks[nextLine]);\n        oldBSCount.push(state.bsCount[nextLine]);\n        oldTShift.push(state.tShift[nextLine]);\n        oldSCount.push(state.sCount[nextLine]);\n        state.sCount[nextLine] -= state.blkIndent;\n      }\n\n      break;\n    }\n\n    oldBMarks.push(state.bMarks[nextLine]);\n    oldBSCount.push(state.bsCount[nextLine]);\n    oldTShift.push(state.tShift[nextLine]);\n    oldSCount.push(state.sCount[nextLine]);\n\n    // A negative indentation means that this is a paragraph continuation\n    //\n    state.sCount[nextLine] = -1;\n  }\n\n  oldIndent = state.blkIndent;\n  state.blkIndent = 0;\n\n  token        = state.push('blockquote_open', 'blockquote', 1);\n  token.markup = '>';\n  token.map    = lines = [ startLine, 0 ];\n\n  state.md.block.tokenize(state, startLine, nextLine);\n\n  token        = state.push('blockquote_close', 'blockquote', -1);\n  token.markup = '>';\n\n  state.lineMax = oldLineMax;\n  state.parentType = oldParentType;\n  lines[1] = state.line;\n\n  // Restore original tShift; this might not be necessary since the parser\n  // has already been here, but just to make sure we can do that.\n  for (i = 0; i < oldTShift.length; i++) {\n    state.bMarks[i + startLine] = oldBMarks[i];\n    state.tShift[i + startLine] = oldTShift[i];\n    state.sCount[i + startLine] = oldSCount[i];\n    state.bsCount[i + startLine] = oldBSCount[i];\n  }\n  state.blkIndent = oldIndent;\n\n  return true;\n};\n","// Horizontal rule\n\n'use strict';\n\nvar isSpace = require('../common/utils').isSpace;\n\n\nmodule.exports = function hr(state, startLine, endLine, silent) {\n  var marker, cnt, ch, token,\n      pos = state.bMarks[startLine] + state.tShift[startLine],\n      max = state.eMarks[startLine];\n\n  // if it's indented more than 3 spaces, it should be a code block\n  if (state.sCount[startLine] - state.blkIndent >= 4) { return false; }\n\n  marker = state.src.charCodeAt(pos++);\n\n  // Check hr marker\n  if (marker !== 0x2A/* * */ &&\n      marker !== 0x2D/* - */ &&\n      marker !== 0x5F/* _ */) {\n    return false;\n  }\n\n  // markers can be mixed with spaces, but there should be at least 3 of them\n\n  cnt = 1;\n  while (pos < max) {\n    ch = state.src.charCodeAt(pos++);\n    if (ch !== marker && !isSpace(ch)) { return false; }\n    if (ch === marker) { cnt++; }\n  }\n\n  if (cnt < 3) { return false; }\n\n  if (silent) { return true; }\n\n  state.line = startLine + 1;\n\n  token        = state.push('hr', 'hr', 0);\n  token.map    = [ startLine, state.line ];\n  token.markup = Array(cnt + 1).join(String.fromCharCode(marker));\n\n  return true;\n};\n","// Lists\n\n'use strict';\n\nvar isSpace = require('../common/utils').isSpace;\n\n\n// Search `[-+*][\\n ]`, returns next pos after marker on success\n// or -1 on fail.\nfunction skipBulletListMarker(state, startLine) {\n  var marker, pos, max, ch;\n\n  pos = state.bMarks[startLine] + state.tShift[startLine];\n  max = state.eMarks[startLine];\n\n  marker = state.src.charCodeAt(pos++);\n  // Check bullet\n  if (marker !== 0x2A/* * */ &&\n      marker !== 0x2D/* - */ &&\n      marker !== 0x2B/* + */) {\n    return -1;\n  }\n\n  if (pos < max) {\n    ch = state.src.charCodeAt(pos);\n\n    if (!isSpace(ch)) {\n      // \" -test \" - is not a list item\n      return -1;\n    }\n  }\n\n  return pos;\n}\n\n// Search `\\d+[.)][\\n ]`, returns next pos after marker on success\n// or -1 on fail.\nfunction skipOrderedListMarker(state, startLine) {\n  var ch,\n      start = state.bMarks[startLine] + state.tShift[startLine],\n      pos = start,\n      max = state.eMarks[startLine];\n\n  // List marker should have at least 2 chars (digit + dot)\n  if (pos + 1 >= max) { return -1; }\n\n  ch = state.src.charCodeAt(pos++);\n\n  if (ch < 0x30/* 0 */ || ch > 0x39/* 9 */) { return -1; }\n\n  for (;;) {\n    // EOL -> fail\n    if (pos >= max) { return -1; }\n\n    ch = state.src.charCodeAt(pos++);\n\n    if (ch >= 0x30/* 0 */ && ch <= 0x39/* 9 */) {\n\n      // List marker should have no more than 9 digits\n      // (prevents integer overflow in browsers)\n      if (pos - start >= 10) { return -1; }\n\n      continue;\n    }\n\n    // found valid marker\n    if (ch === 0x29/* ) */ || ch === 0x2e/* . */) {\n      break;\n    }\n\n    return -1;\n  }\n\n\n  if (pos < max) {\n    ch = state.src.charCodeAt(pos);\n\n    if (!isSpace(ch)) {\n      // \" 1.test \" - is not a list item\n      return -1;\n    }\n  }\n  return pos;\n}\n\nfunction markTightParagraphs(state, idx) {\n  var i, l,\n      level = state.level + 2;\n\n  for (i = idx + 2, l = state.tokens.length - 2; i < l; i++) {\n    if (state.tokens[i].level === level && state.tokens[i].type === 'paragraph_open') {\n      state.tokens[i + 2].hidden = true;\n      state.tokens[i].hidden = true;\n      i += 2;\n    }\n  }\n}\n\n\nmodule.exports = function list(state, startLine, endLine, silent) {\n  var ch,\n      contentStart,\n      i,\n      indent,\n      indentAfterMarker,\n      initial,\n      isOrdered,\n      itemLines,\n      l,\n      listLines,\n      listTokIdx,\n      markerCharCode,\n      markerValue,\n      max,\n      nextLine,\n      offset,\n      oldListIndent,\n      oldParentType,\n      oldSCount,\n      oldTShift,\n      oldTight,\n      pos,\n      posAfterMarker,\n      prevEmptyEnd,\n      start,\n      terminate,\n      terminatorRules,\n      token,\n      isTerminatingParagraph = false,\n      tight = true;\n\n  // if it's indented more than 3 spaces, it should be a code block\n  if (state.sCount[startLine] - state.blkIndent >= 4) { return false; }\n\n  // Special case:\n  //  - item 1\n  //   - item 2\n  //    - item 3\n  //     - item 4\n  //      - this one is a paragraph continuation\n  if (state.listIndent >= 0 &&\n      state.sCount[startLine] - state.listIndent >= 4 &&\n      state.sCount[startLine] < state.blkIndent) {\n    return false;\n  }\n\n  // limit conditions when list can interrupt\n  // a paragraph (validation mode only)\n  if (silent && state.parentType === 'paragraph') {\n    // Next list item should still terminate previous list item;\n    //\n    // This code can fail if plugins use blkIndent as well as lists,\n    // but I hope the spec gets fixed long before that happens.\n    //\n    if (state.tShift[startLine] >= state.blkIndent) {\n      isTerminatingParagraph = true;\n    }\n  }\n\n  // Detect list type and position after marker\n  if ((posAfterMarker = skipOrderedListMarker(state, startLine)) >= 0) {\n    isOrdered = true;\n    start = state.bMarks[startLine] + state.tShift[startLine];\n    markerValue = Number(state.src.substr(start, posAfterMarker - start - 1));\n\n    // If we're starting a new ordered list right after\n    // a paragraph, it should start with 1.\n    if (isTerminatingParagraph && markerValue !== 1) return false;\n\n  } else if ((posAfterMarker = skipBulletListMarker(state, startLine)) >= 0) {\n    isOrdered = false;\n\n  } else {\n    return false;\n  }\n\n  // If we're starting a new unordered list right after\n  // a paragraph, first line should not be empty.\n  if (isTerminatingParagraph) {\n    if (state.skipSpaces(posAfterMarker) >= state.eMarks[startLine]) return false;\n  }\n\n  // We should terminate list on style change. Remember first one to compare.\n  markerCharCode = state.src.charCodeAt(posAfterMarker - 1);\n\n  // For validation mode we can terminate immediately\n  if (silent) { return true; }\n\n  // Start list\n  listTokIdx = state.tokens.length;\n\n  if (isOrdered) {\n    token       = state.push('ordered_list_open', 'ol', 1);\n    if (markerValue !== 1) {\n      token.attrs = [ [ 'start', markerValue ] ];\n    }\n\n  } else {\n    token       = state.push('bullet_list_open', 'ul', 1);\n  }\n\n  token.map    = listLines = [ startLine, 0 ];\n  token.markup = String.fromCharCode(markerCharCode);\n\n  //\n  // Iterate list items\n  //\n\n  nextLine = startLine;\n  prevEmptyEnd = false;\n  terminatorRules = state.md.block.ruler.getRules('list');\n\n  oldParentType = state.parentType;\n  state.parentType = 'list';\n\n  while (nextLine < endLine) {\n    pos = posAfterMarker;\n    max = state.eMarks[nextLine];\n\n    initial = offset = state.sCount[nextLine] + posAfterMarker - (state.bMarks[startLine] + state.tShift[startLine]);\n\n    while (pos < max) {\n      ch = state.src.charCodeAt(pos);\n\n      if (ch === 0x09) {\n        offset += 4 - (offset + state.bsCount[nextLine]) % 4;\n      } else if (ch === 0x20) {\n        offset++;\n      } else {\n        break;\n      }\n\n      pos++;\n    }\n\n    contentStart = pos;\n\n    if (contentStart >= max) {\n      // trimming space in \"-    \\n  3\" case, indent is 1 here\n      indentAfterMarker = 1;\n    } else {\n      indentAfterMarker = offset - initial;\n    }\n\n    // If we have more than 4 spaces, the indent is 1\n    // (the rest is just indented code block)\n    if (indentAfterMarker > 4) { indentAfterMarker = 1; }\n\n    // \"  -  test\"\n    //  ^^^^^ - calculating total length of this thing\n    indent = initial + indentAfterMarker;\n\n    // Run subparser & write tokens\n    token        = state.push('list_item_open', 'li', 1);\n    token.markup = String.fromCharCode(markerCharCode);\n    token.map    = itemLines = [ startLine, 0 ];\n\n    // change current state, then restore it after parser subcall\n    oldTight = state.tight;\n    oldTShift = state.tShift[startLine];\n    oldSCount = state.sCount[startLine];\n\n    //  - example list\n    // ^ listIndent position will be here\n    //   ^ blkIndent position will be here\n    //\n    oldListIndent = state.listIndent;\n    state.listIndent = state.blkIndent;\n    state.blkIndent = indent;\n\n    state.tight = true;\n    state.tShift[startLine] = contentStart - state.bMarks[startLine];\n    state.sCount[startLine] = offset;\n\n    if (contentStart >= max && state.isEmpty(startLine + 1)) {\n      // workaround for this case\n      // (list item is empty, list terminates before \"foo\"):\n      // ~~~~~~~~\n      //   -\n      //\n      //     foo\n      // ~~~~~~~~\n      state.line = Math.min(state.line + 2, endLine);\n    } else {\n      state.md.block.tokenize(state, startLine, endLine, true);\n    }\n\n    // If any of list item is tight, mark list as tight\n    if (!state.tight || prevEmptyEnd) {\n      tight = false;\n    }\n    // Item become loose if finish with empty line,\n    // but we should filter last element, because it means list finish\n    prevEmptyEnd = (state.line - startLine) > 1 && state.isEmpty(state.line - 1);\n\n    state.blkIndent = state.listIndent;\n    state.listIndent = oldListIndent;\n    state.tShift[startLine] = oldTShift;\n    state.sCount[startLine] = oldSCount;\n    state.tight = oldTight;\n\n    token        = state.push('list_item_close', 'li', -1);\n    token.markup = String.fromCharCode(markerCharCode);\n\n    nextLine = startLine = state.line;\n    itemLines[1] = nextLine;\n    contentStart = state.bMarks[startLine];\n\n    if (nextLine >= endLine) { break; }\n\n    //\n    // Try to check if list is terminated or continued.\n    //\n    if (state.sCount[nextLine] < state.blkIndent) { break; }\n\n    // if it's indented more than 3 spaces, it should be a code block\n    if (state.sCount[startLine] - state.blkIndent >= 4) { break; }\n\n    // fail if terminating block found\n    terminate = false;\n    for (i = 0, l = terminatorRules.length; i < l; i++) {\n      if (terminatorRules[i](state, nextLine, endLine, true)) {\n        terminate = true;\n        break;\n      }\n    }\n    if (terminate) { break; }\n\n    // fail if list has another type\n    if (isOrdered) {\n      posAfterMarker = skipOrderedListMarker(state, nextLine);\n      if (posAfterMarker < 0) { break; }\n    } else {\n      posAfterMarker = skipBulletListMarker(state, nextLine);\n      if (posAfterMarker < 0) { break; }\n    }\n\n    if (markerCharCode !== state.src.charCodeAt(posAfterMarker - 1)) { break; }\n  }\n\n  // Finalize list\n  if (isOrdered) {\n    token = state.push('ordered_list_close', 'ol', -1);\n  } else {\n    token = state.push('bullet_list_close', 'ul', -1);\n  }\n  token.markup = String.fromCharCode(markerCharCode);\n\n  listLines[1] = nextLine;\n  state.line = nextLine;\n\n  state.parentType = oldParentType;\n\n  // mark paragraphs tight if needed\n  if (tight) {\n    markTightParagraphs(state, listTokIdx);\n  }\n\n  return true;\n};\n","'use strict';\n\n\nvar normalizeReference   = require('../common/utils').normalizeReference;\nvar isSpace              = require('../common/utils').isSpace;\n\n\nmodule.exports = function reference(state, startLine, _endLine, silent) {\n  var ch,\n      destEndPos,\n      destEndLineNo,\n      endLine,\n      href,\n      i,\n      l,\n      label,\n      labelEnd,\n      oldParentType,\n      res,\n      start,\n      str,\n      terminate,\n      terminatorRules,\n      title,\n      lines = 0,\n      pos = state.bMarks[startLine] + state.tShift[startLine],\n      max = state.eMarks[startLine],\n      nextLine = startLine + 1;\n\n  // if it's indented more than 3 spaces, it should be a code block\n  if (state.sCount[startLine] - state.blkIndent >= 4) { return false; }\n\n  if (state.src.charCodeAt(pos) !== 0x5B/* [ */) { return false; }\n\n  // Simple check to quickly interrupt scan on [link](url) at the start of line.\n  // Can be useful on practice: https://github.com/markdown-it/markdown-it/issues/54\n  while (++pos < max) {\n    if (state.src.charCodeAt(pos) === 0x5D /* ] */ &&\n        state.src.charCodeAt(pos - 1) !== 0x5C/* \\ */) {\n      if (pos + 1 === max) { return false; }\n      if (state.src.charCodeAt(pos + 1) !== 0x3A/* : */) { return false; }\n      break;\n    }\n  }\n\n  endLine = state.lineMax;\n\n  // jump line-by-line until empty one or EOF\n  terminatorRules = state.md.block.ruler.getRules('reference');\n\n  oldParentType = state.parentType;\n  state.parentType = 'reference';\n\n  for (; nextLine < endLine && !state.isEmpty(nextLine); nextLine++) {\n    // this would be a code block normally, but after paragraph\n    // it's considered a lazy continuation regardless of what's there\n    if (state.sCount[nextLine] - state.blkIndent > 3) { continue; }\n\n    // quirk for blockquotes, this line should already be checked by that rule\n    if (state.sCount[nextLine] < 0) { continue; }\n\n    // Some tags can terminate paragraph without empty line.\n    terminate = false;\n    for (i = 0, l = terminatorRules.length; i < l; i++) {\n      if (terminatorRules[i](state, nextLine, endLine, true)) {\n        terminate = true;\n        break;\n      }\n    }\n    if (terminate) { break; }\n  }\n\n  str = state.getLines(startLine, nextLine, state.blkIndent, false).trim();\n  max = str.length;\n\n  for (pos = 1; pos < max; pos++) {\n    ch = str.charCodeAt(pos);\n    if (ch === 0x5B /* [ */) {\n      return false;\n    } else if (ch === 0x5D /* ] */) {\n      labelEnd = pos;\n      break;\n    } else if (ch === 0x0A /* \\n */) {\n      lines++;\n    } else if (ch === 0x5C /* \\ */) {\n      pos++;\n      if (pos < max && str.charCodeAt(pos) === 0x0A) {\n        lines++;\n      }\n    }\n  }\n\n  if (labelEnd < 0 || str.charCodeAt(labelEnd + 1) !== 0x3A/* : */) { return false; }\n\n  // [label]:   destination   'title'\n  //         ^^^ skip optional whitespace here\n  for (pos = labelEnd + 2; pos < max; pos++) {\n    ch = str.charCodeAt(pos);\n    if (ch === 0x0A) {\n      lines++;\n    } else if (isSpace(ch)) {\n      /*eslint no-empty:0*/\n    } else {\n      break;\n    }\n  }\n\n  // [label]:   destination   'title'\n  //            ^^^^^^^^^^^ parse this\n  res = state.md.helpers.parseLinkDestination(str, pos, max);\n  if (!res.ok) { return false; }\n\n  href = state.md.normalizeLink(res.str);\n  if (!state.md.validateLink(href)) { return false; }\n\n  pos = res.pos;\n  lines += res.lines;\n\n  // save cursor state, we could require to rollback later\n  destEndPos = pos;\n  destEndLineNo = lines;\n\n  // [label]:   destination   'title'\n  //                       ^^^ skipping those spaces\n  start = pos;\n  for (; pos < max; pos++) {\n    ch = str.charCodeAt(pos);\n    if (ch === 0x0A) {\n      lines++;\n    } else if (isSpace(ch)) {\n      /*eslint no-empty:0*/\n    } else {\n      break;\n    }\n  }\n\n  // [label]:   destination   'title'\n  //                          ^^^^^^^ parse this\n  res = state.md.helpers.parseLinkTitle(str, pos, max);\n  if (pos < max && start !== pos && res.ok) {\n    title = res.str;\n    pos = res.pos;\n    lines += res.lines;\n  } else {\n    title = '';\n    pos = destEndPos;\n    lines = destEndLineNo;\n  }\n\n  // skip trailing spaces until the rest of the line\n  while (pos < max) {\n    ch = str.charCodeAt(pos);\n    if (!isSpace(ch)) { break; }\n    pos++;\n  }\n\n  if (pos < max && str.charCodeAt(pos) !== 0x0A) {\n    if (title) {\n      // garbage at the end of the line after title,\n      // but it could still be a valid reference if we roll back\n      title = '';\n      pos = destEndPos;\n      lines = destEndLineNo;\n      while (pos < max) {\n        ch = str.charCodeAt(pos);\n        if (!isSpace(ch)) { break; }\n        pos++;\n      }\n    }\n  }\n\n  if (pos < max && str.charCodeAt(pos) !== 0x0A) {\n    // garbage at the end of the line\n    return false;\n  }\n\n  label = normalizeReference(str.slice(1, labelEnd));\n  if (!label) {\n    // CommonMark 0.20 disallows empty labels\n    return false;\n  }\n\n  // Reference can not terminate anything. This check is for safety only.\n  /*istanbul ignore if*/\n  if (silent) { return true; }\n\n  if (typeof state.env.references === 'undefined') {\n    state.env.references = {};\n  }\n  if (typeof state.env.references[label] === 'undefined') {\n    state.env.references[label] = { title: title, href: href };\n  }\n\n  state.parentType = oldParentType;\n\n  state.line = startLine + lines + 1;\n  return true;\n};\n","// heading (#, ##, ...)\n\n'use strict';\n\nvar isSpace = require('../common/utils').isSpace;\n\n\nmodule.exports = function heading(state, startLine, endLine, silent) {\n  var ch, level, tmp, token,\n      pos = state.bMarks[startLine] + state.tShift[startLine],\n      max = state.eMarks[startLine];\n\n  // if it's indented more than 3 spaces, it should be a code block\n  if (state.sCount[startLine] - state.blkIndent >= 4) { return false; }\n\n  ch  = state.src.charCodeAt(pos);\n\n  if (ch !== 0x23/* # */ || pos >= max) { return false; }\n\n  // count heading level\n  level = 1;\n  ch = state.src.charCodeAt(++pos);\n  while (ch === 0x23/* # */ && pos < max && level <= 6) {\n    level++;\n    ch = state.src.charCodeAt(++pos);\n  }\n\n  if (level > 6 || (pos < max && !isSpace(ch))) { return false; }\n\n  if (silent) { return true; }\n\n  // Let's cut tails like '    ###  ' from the end of string\n\n  max = state.skipSpacesBack(max, pos);\n  tmp = state.skipCharsBack(max, 0x23, pos); // #\n  if (tmp > pos && isSpace(state.src.charCodeAt(tmp - 1))) {\n    max = tmp;\n  }\n\n  state.line = startLine + 1;\n\n  token        = state.push('heading_open', 'h' + String(level), 1);\n  token.markup = '########'.slice(0, level);\n  token.map    = [ startLine, state.line ];\n\n  token          = state.push('inline', '', 0);\n  token.content  = state.src.slice(pos, max).trim();\n  token.map      = [ startLine, state.line ];\n  token.children = [];\n\n  token        = state.push('heading_close', 'h' + String(level), -1);\n  token.markup = '########'.slice(0, level);\n\n  return true;\n};\n","// lheading (---, ===)\n\n'use strict';\n\n\nmodule.exports = function lheading(state, startLine, endLine/*, silent*/) {\n  var content, terminate, i, l, token, pos, max, level, marker,\n      nextLine = startLine + 1, oldParentType,\n      terminatorRules = state.md.block.ruler.getRules('paragraph');\n\n  // if it's indented more than 3 spaces, it should be a code block\n  if (state.sCount[startLine] - state.blkIndent >= 4) { return false; }\n\n  oldParentType = state.parentType;\n  state.parentType = 'paragraph'; // use paragraph to match terminatorRules\n\n  // jump line-by-line until empty one or EOF\n  for (; nextLine < endLine && !state.isEmpty(nextLine); nextLine++) {\n    // this would be a code block normally, but after paragraph\n    // it's considered a lazy continuation regardless of what's there\n    if (state.sCount[nextLine] - state.blkIndent > 3) { continue; }\n\n    //\n    // Check for underline in setext header\n    //\n    if (state.sCount[nextLine] >= state.blkIndent) {\n      pos = state.bMarks[nextLine] + state.tShift[nextLine];\n      max = state.eMarks[nextLine];\n\n      if (pos < max) {\n        marker = state.src.charCodeAt(pos);\n\n        if (marker === 0x2D/* - */ || marker === 0x3D/* = */) {\n          pos = state.skipChars(pos, marker);\n          pos = state.skipSpaces(pos);\n\n          if (pos >= max) {\n            level = (marker === 0x3D/* = */ ? 1 : 2);\n            break;\n          }\n        }\n      }\n    }\n\n    // quirk for blockquotes, this line should already be checked by that rule\n    if (state.sCount[nextLine] < 0) { continue; }\n\n    // Some tags can terminate paragraph without empty line.\n    terminate = false;\n    for (i = 0, l = terminatorRules.length; i < l; i++) {\n      if (terminatorRules[i](state, nextLine, endLine, true)) {\n        terminate = true;\n        break;\n      }\n    }\n    if (terminate) { break; }\n  }\n\n  if (!level) {\n    // Didn't find valid underline\n    return false;\n  }\n\n  content = state.getLines(startLine, nextLine, state.blkIndent, false).trim();\n\n  state.line = nextLine + 1;\n\n  token          = state.push('heading_open', 'h' + String(level), 1);\n  token.markup   = String.fromCharCode(marker);\n  token.map      = [ startLine, state.line ];\n\n  token          = state.push('inline', '', 0);\n  token.content  = content;\n  token.map      = [ startLine, state.line - 1 ];\n  token.children = [];\n\n  token          = state.push('heading_close', 'h' + String(level), -1);\n  token.markup   = String.fromCharCode(marker);\n\n  state.parentType = oldParentType;\n\n  return true;\n};\n","// HTML block\n\n'use strict';\n\n\nvar block_names = require('../common/html_blocks');\nvar HTML_OPEN_CLOSE_TAG_RE = require('../common/html_re').HTML_OPEN_CLOSE_TAG_RE;\n\n// An array of opening and corresponding closing sequences for html tags,\n// last argument defines whether it can terminate a paragraph or not\n//\nvar HTML_SEQUENCES = [\n  [ /^<(script|pre|style)(?=(\\s|>|$))/i, /<\\/(script|pre|style)>/i, true ],\n  [ /^<!--/,        /-->/,   true ],\n  [ /^<\\?/,         /\\?>/,   true ],\n  [ /^<![A-Z]/,     />/,     true ],\n  [ /^<!\\[CDATA\\[/, /\\]\\]>/, true ],\n  [ new RegExp('^</?(' + block_names.join('|') + ')(?=(\\\\s|/?>|$))', 'i'), /^$/, true ],\n  [ new RegExp(HTML_OPEN_CLOSE_TAG_RE.source + '\\\\s*$'),  /^$/, false ]\n];\n\n\nmodule.exports = function html_block(state, startLine, endLine, silent) {\n  var i, nextLine, token, lineText,\n      pos = state.bMarks[startLine] + state.tShift[startLine],\n      max = state.eMarks[startLine];\n\n  // if it's indented more than 3 spaces, it should be a code block\n  if (state.sCount[startLine] - state.blkIndent >= 4) { return false; }\n\n  if (!state.md.options.html) { return false; }\n\n  if (state.src.charCodeAt(pos) !== 0x3C/* < */) { return false; }\n\n  lineText = state.src.slice(pos, max);\n\n  for (i = 0; i < HTML_SEQUENCES.length; i++) {\n    if (HTML_SEQUENCES[i][0].test(lineText)) { break; }\n  }\n\n  if (i === HTML_SEQUENCES.length) { return false; }\n\n  if (silent) {\n    // true if this sequence can be a terminator, false otherwise\n    return HTML_SEQUENCES[i][2];\n  }\n\n  nextLine = startLine + 1;\n\n  // If we are here - we detected HTML block.\n  // Let's roll down till block end.\n  if (!HTML_SEQUENCES[i][1].test(lineText)) {\n    for (; nextLine < endLine; nextLine++) {\n      if (state.sCount[nextLine] < state.blkIndent) { break; }\n\n      pos = state.bMarks[nextLine] + state.tShift[nextLine];\n      max = state.eMarks[nextLine];\n      lineText = state.src.slice(pos, max);\n\n      if (HTML_SEQUENCES[i][1].test(lineText)) {\n        if (lineText.length !== 0) { nextLine++; }\n        break;\n      }\n    }\n  }\n\n  state.line = nextLine;\n\n  token         = state.push('html_block', '', 0);\n  token.map     = [ startLine, nextLine ];\n  token.content = state.getLines(startLine, nextLine, state.blkIndent, true);\n\n  return true;\n};\n","// List of valid html blocks names, accorting to commonmark spec\n// http://jgm.github.io/CommonMark/spec.html#html-blocks\n\n'use strict';\n\n\nmodule.exports = [\n  'address',\n  'article',\n  'aside',\n  'base',\n  'basefont',\n  'blockquote',\n  'body',\n  'caption',\n  'center',\n  'col',\n  'colgroup',\n  'dd',\n  'details',\n  'dialog',\n  'dir',\n  'div',\n  'dl',\n  'dt',\n  'fieldset',\n  'figcaption',\n  'figure',\n  'footer',\n  'form',\n  'frame',\n  'frameset',\n  'h1',\n  'h2',\n  'h3',\n  'h4',\n  'h5',\n  'h6',\n  'head',\n  'header',\n  'hr',\n  'html',\n  'iframe',\n  'legend',\n  'li',\n  'link',\n  'main',\n  'menu',\n  'menuitem',\n  'meta',\n  'nav',\n  'noframes',\n  'ol',\n  'optgroup',\n  'option',\n  'p',\n  'param',\n  'section',\n  'source',\n  'summary',\n  'table',\n  'tbody',\n  'td',\n  'tfoot',\n  'th',\n  'thead',\n  'title',\n  'tr',\n  'track',\n  'ul'\n];\n","// Paragraph\n\n'use strict';\n\n\nmodule.exports = function paragraph(state, startLine/*, endLine*/) {\n  var content, terminate, i, l, token, oldParentType,\n      nextLine = startLine + 1,\n      terminatorRules = state.md.block.ruler.getRules('paragraph'),\n      endLine = state.lineMax;\n\n  oldParentType = state.parentType;\n  state.parentType = 'paragraph';\n\n  // jump line-by-line until empty one or EOF\n  for (; nextLine < endLine && !state.isEmpty(nextLine); nextLine++) {\n    // this would be a code block normally, but after paragraph\n    // it's considered a lazy continuation regardless of what's there\n    if (state.sCount[nextLine] - state.blkIndent > 3) { continue; }\n\n    // quirk for blockquotes, this line should already be checked by that rule\n    if (state.sCount[nextLine] < 0) { continue; }\n\n    // Some tags can terminate paragraph without empty line.\n    terminate = false;\n    for (i = 0, l = terminatorRules.length; i < l; i++) {\n      if (terminatorRules[i](state, nextLine, endLine, true)) {\n        terminate = true;\n        break;\n      }\n    }\n    if (terminate) { break; }\n  }\n\n  content = state.getLines(startLine, nextLine, state.blkIndent, false).trim();\n\n  state.line = nextLine;\n\n  token          = state.push('paragraph_open', 'p', 1);\n  token.map      = [ startLine, state.line ];\n\n  token          = state.push('inline', '', 0);\n  token.content  = content;\n  token.map      = [ startLine, state.line ];\n  token.children = [];\n\n  token          = state.push('paragraph_close', 'p', -1);\n\n  state.parentType = oldParentType;\n\n  return true;\n};\n","// Parser state class\n\n'use strict';\n\nvar Token = require('../token');\nvar isSpace = require('../common/utils').isSpace;\n\n\nfunction StateBlock(src, md, env, tokens) {\n  var ch, s, start, pos, len, indent, offset, indent_found;\n\n  this.src = src;\n\n  // link to parser instance\n  this.md     = md;\n\n  this.env = env;\n\n  //\n  // Internal state vartiables\n  //\n\n  this.tokens = tokens;\n\n  this.bMarks = [];  // line begin offsets for fast jumps\n  this.eMarks = [];  // line end offsets for fast jumps\n  this.tShift = [];  // offsets of the first non-space characters (tabs not expanded)\n  this.sCount = [];  // indents for each line (tabs expanded)\n\n  // An amount of virtual spaces (tabs expanded) between beginning\n  // of each line (bMarks) and real beginning of that line.\n  //\n  // It exists only as a hack because blockquotes override bMarks\n  // losing information in the process.\n  //\n  // It's used only when expanding tabs, you can think about it as\n  // an initial tab length, e.g. bsCount=21 applied to string `\\t123`\n  // means first tab should be expanded to 4-21%4 === 3 spaces.\n  //\n  this.bsCount = [];\n\n  // block parser variables\n  this.blkIndent  = 0; // required block content indent (for example, if we are\n                       // inside a list, it would be positioned after list marker)\n  this.line       = 0; // line index in src\n  this.lineMax    = 0; // lines count\n  this.tight      = false;  // loose/tight mode for lists\n  this.ddIndent   = -1; // indent of the current dd block (-1 if there isn't any)\n  this.listIndent = -1; // indent of the current list block (-1 if there isn't any)\n\n  // can be 'blockquote', 'list', 'root', 'paragraph' or 'reference'\n  // used in lists to determine if they interrupt a paragraph\n  this.parentType = 'root';\n\n  this.level = 0;\n\n  // renderer\n  this.result = '';\n\n  // Create caches\n  // Generate markers.\n  s = this.src;\n  indent_found = false;\n\n  for (start = pos = indent = offset = 0, len = s.length; pos < len; pos++) {\n    ch = s.charCodeAt(pos);\n\n    if (!indent_found) {\n      if (isSpace(ch)) {\n        indent++;\n\n        if (ch === 0x09) {\n          offset += 4 - offset % 4;\n        } else {\n          offset++;\n        }\n        continue;\n      } else {\n        indent_found = true;\n      }\n    }\n\n    if (ch === 0x0A || pos === len - 1) {\n      if (ch !== 0x0A) { pos++; }\n      this.bMarks.push(start);\n      this.eMarks.push(pos);\n      this.tShift.push(indent);\n      this.sCount.push(offset);\n      this.bsCount.push(0);\n\n      indent_found = false;\n      indent = 0;\n      offset = 0;\n      start = pos + 1;\n    }\n  }\n\n  // Push fake entry to simplify cache bounds checks\n  this.bMarks.push(s.length);\n  this.eMarks.push(s.length);\n  this.tShift.push(0);\n  this.sCount.push(0);\n  this.bsCount.push(0);\n\n  this.lineMax = this.bMarks.length - 1; // don't count last fake line\n}\n\n// Push new token to \"stream\".\n//\nStateBlock.prototype.push = function (type, tag, nesting) {\n  var token = new Token(type, tag, nesting);\n  token.block = true;\n\n  if (nesting < 0) this.level--; // closing tag\n  token.level = this.level;\n  if (nesting > 0) this.level++; // opening tag\n\n  this.tokens.push(token);\n  return token;\n};\n\nStateBlock.prototype.isEmpty = function isEmpty(line) {\n  return this.bMarks[line] + this.tShift[line] >= this.eMarks[line];\n};\n\nStateBlock.prototype.skipEmptyLines = function skipEmptyLines(from) {\n  for (var max = this.lineMax; from < max; from++) {\n    if (this.bMarks[from] + this.tShift[from] < this.eMarks[from]) {\n      break;\n    }\n  }\n  return from;\n};\n\n// Skip spaces from given position.\nStateBlock.prototype.skipSpaces = function skipSpaces(pos) {\n  var ch;\n\n  for (var max = this.src.length; pos < max; pos++) {\n    ch = this.src.charCodeAt(pos);\n    if (!isSpace(ch)) { break; }\n  }\n  return pos;\n};\n\n// Skip spaces from given position in reverse.\nStateBlock.prototype.skipSpacesBack = function skipSpacesBack(pos, min) {\n  if (pos <= min) { return pos; }\n\n  while (pos > min) {\n    if (!isSpace(this.src.charCodeAt(--pos))) { return pos + 1; }\n  }\n  return pos;\n};\n\n// Skip char codes from given position\nStateBlock.prototype.skipChars = function skipChars(pos, code) {\n  for (var max = this.src.length; pos < max; pos++) {\n    if (this.src.charCodeAt(pos) !== code) { break; }\n  }\n  return pos;\n};\n\n// Skip char codes reverse from given position - 1\nStateBlock.prototype.skipCharsBack = function skipCharsBack(pos, code, min) {\n  if (pos <= min) { return pos; }\n\n  while (pos > min) {\n    if (code !== this.src.charCodeAt(--pos)) { return pos + 1; }\n  }\n  return pos;\n};\n\n// cut lines range from source.\nStateBlock.prototype.getLines = function getLines(begin, end, indent, keepLastLF) {\n  var i, lineIndent, ch, first, last, queue, lineStart,\n      line = begin;\n\n  if (begin >= end) {\n    return '';\n  }\n\n  queue = new Array(end - begin);\n\n  for (i = 0; line < end; line++, i++) {\n    lineIndent = 0;\n    lineStart = first = this.bMarks[line];\n\n    if (line + 1 < end || keepLastLF) {\n      // No need for bounds check because we have fake entry on tail.\n      last = this.eMarks[line] + 1;\n    } else {\n      last = this.eMarks[line];\n    }\n\n    while (first < last && lineIndent < indent) {\n      ch = this.src.charCodeAt(first);\n\n      if (isSpace(ch)) {\n        if (ch === 0x09) {\n          lineIndent += 4 - (lineIndent + this.bsCount[line]) % 4;\n        } else {\n          lineIndent++;\n        }\n      } else if (first - lineStart < this.tShift[line]) {\n        // patched tShift masked characters to look like spaces (blockquotes, list markers)\n        lineIndent++;\n      } else {\n        break;\n      }\n\n      first++;\n    }\n\n    if (lineIndent > indent) {\n      // partially expanding tabs in code blocks, e.g '\\t\\tfoobar'\n      // with indent=2 becomes '  \\tfoobar'\n      queue[i] = new Array(lineIndent - indent + 1).join(' ') + this.src.slice(first, last);\n    } else {\n      queue[i] = this.src.slice(first, last);\n    }\n  }\n\n  return queue.join('');\n};\n\n// re-export Token class to use in block rules\nStateBlock.prototype.Token = Token;\n\n\nmodule.exports = StateBlock;\n","/** internal\n * class ParserInline\n *\n * Tokenizes paragraph content.\n **/\n'use strict';\n\n\nvar Ruler           = require('./ruler');\n\n\n////////////////////////////////////////////////////////////////////////////////\n// Parser rules\n\nvar _rules = [\n  [ 'text',            require('./rules_inline/text') ],\n  [ 'newline',         require('./rules_inline/newline') ],\n  [ 'escape',          require('./rules_inline/escape') ],\n  [ 'backticks',       require('./rules_inline/backticks') ],\n  [ 'strikethrough',   require('./rules_inline/strikethrough').tokenize ],\n  [ 'emphasis',        require('./rules_inline/emphasis').tokenize ],\n  [ 'link',            require('./rules_inline/link') ],\n  [ 'image',           require('./rules_inline/image') ],\n  [ 'autolink',        require('./rules_inline/autolink') ],\n  [ 'html_inline',     require('./rules_inline/html_inline') ],\n  [ 'entity',          require('./rules_inline/entity') ]\n];\n\nvar _rules2 = [\n  [ 'balance_pairs',   require('./rules_inline/balance_pairs') ],\n  [ 'strikethrough',   require('./rules_inline/strikethrough').postProcess ],\n  [ 'emphasis',        require('./rules_inline/emphasis').postProcess ],\n  [ 'text_collapse',   require('./rules_inline/text_collapse') ]\n];\n\n\n/**\n * new ParserInline()\n **/\nfunction ParserInline() {\n  var i;\n\n  /**\n   * ParserInline#ruler -> Ruler\n   *\n   * [[Ruler]] instance. Keep configuration of inline rules.\n   **/\n  this.ruler = new Ruler();\n\n  for (i = 0; i < _rules.length; i++) {\n    this.ruler.push(_rules[i][0], _rules[i][1]);\n  }\n\n  /**\n   * ParserInline#ruler2 -> Ruler\n   *\n   * [[Ruler]] instance. Second ruler used for post-processing\n   * (e.g. in emphasis-like rules).\n   **/\n  this.ruler2 = new Ruler();\n\n  for (i = 0; i < _rules2.length; i++) {\n    this.ruler2.push(_rules2[i][0], _rules2[i][1]);\n  }\n}\n\n\n// Skip single token by running all rules in validation mode;\n// returns `true` if any rule reported success\n//\nParserInline.prototype.skipToken = function (state) {\n  var ok, i, pos = state.pos,\n      rules = this.ruler.getRules(''),\n      len = rules.length,\n      maxNesting = state.md.options.maxNesting,\n      cache = state.cache;\n\n\n  if (typeof cache[pos] !== 'undefined') {\n    state.pos = cache[pos];\n    return;\n  }\n\n  if (state.level < maxNesting) {\n    for (i = 0; i < len; i++) {\n      // Increment state.level and decrement it later to limit recursion.\n      // It's harmless to do here, because no tokens are created. But ideally,\n      // we'd need a separate private state variable for this purpose.\n      //\n      state.level++;\n      ok = rules[i](state, true);\n      state.level--;\n\n      if (ok) { break; }\n    }\n  } else {\n    // Too much nesting, just skip until the end of the paragraph.\n    //\n    // NOTE: this will cause links to behave incorrectly in the following case,\n    //       when an amount of `[` is exactly equal to `maxNesting + 1`:\n    //\n    //       [[[[[[[[[[[[[[[[[[[[[foo]()\n    //\n    // TODO: remove this workaround when CM standard will allow nested links\n    //       (we can replace it by preventing links from being parsed in\n    //       validation mode)\n    //\n    state.pos = state.posMax;\n  }\n\n  if (!ok) { state.pos++; }\n  cache[pos] = state.pos;\n};\n\n\n// Generate tokens for input range\n//\nParserInline.prototype.tokenize = function (state) {\n  var ok, i,\n      rules = this.ruler.getRules(''),\n      len = rules.length,\n      end = state.posMax,\n      maxNesting = state.md.options.maxNesting;\n\n  while (state.pos < end) {\n    // Try all possible rules.\n    // On success, rule should:\n    //\n    // - update `state.pos`\n    // - update `state.tokens`\n    // - return true\n\n    if (state.level < maxNesting) {\n      for (i = 0; i < len; i++) {\n        ok = rules[i](state, false);\n        if (ok) { break; }\n      }\n    }\n\n    if (ok) {\n      if (state.pos >= end) { break; }\n      continue;\n    }\n\n    state.pending += state.src[state.pos++];\n  }\n\n  if (state.pending) {\n    state.pushPending();\n  }\n};\n\n\n/**\n * ParserInline.parse(str, md, env, outTokens)\n *\n * Process input string and push inline tokens into `outTokens`\n **/\nParserInline.prototype.parse = function (str, md, env, outTokens) {\n  var i, rules, len;\n  var state = new this.State(str, md, env, outTokens);\n\n  this.tokenize(state);\n\n  rules = this.ruler2.getRules('');\n  len = rules.length;\n\n  for (i = 0; i < len; i++) {\n    rules[i](state);\n  }\n};\n\n\nParserInline.prototype.State = require('./rules_inline/state_inline');\n\n\nmodule.exports = ParserInline;\n","// Skip text characters for text token, place those to pending buffer\n// and increment current pos\n\n'use strict';\n\n\n// Rule to skip pure text\n// '{}$%@~+=:' reserved for extentions\n\n// !, \", #, $, %, &, ', (, ), *, +, ,, -, ., /, :, ;, <, =, >, ?, @, [, \\, ], ^, _, `, {, |, }, or ~\n\n// !!!! Don't confuse with \"Markdown ASCII Punctuation\" chars\n// http://spec.commonmark.org/0.15/#ascii-punctuation-character\nfunction isTerminatorChar(ch) {\n  switch (ch) {\n    case 0x0A/* \\n */:\n    case 0x21/* ! */:\n    case 0x23/* # */:\n    case 0x24/* $ */:\n    case 0x25/* % */:\n    case 0x26/* & */:\n    case 0x2A/* * */:\n    case 0x2B/* + */:\n    case 0x2D/* - */:\n    case 0x3A/* : */:\n    case 0x3C/* < */:\n    case 0x3D/* = */:\n    case 0x3E/* > */:\n    case 0x40/* @ */:\n    case 0x5B/* [ */:\n    case 0x5C/* \\ */:\n    case 0x5D/* ] */:\n    case 0x5E/* ^ */:\n    case 0x5F/* _ */:\n    case 0x60/* ` */:\n    case 0x7B/* { */:\n    case 0x7D/* } */:\n    case 0x7E/* ~ */:\n      return true;\n    default:\n      return false;\n  }\n}\n\nmodule.exports = function text(state, silent) {\n  var pos = state.pos;\n\n  while (pos < state.posMax && !isTerminatorChar(state.src.charCodeAt(pos))) {\n    pos++;\n  }\n\n  if (pos === state.pos) { return false; }\n\n  if (!silent) { state.pending += state.src.slice(state.pos, pos); }\n\n  state.pos = pos;\n\n  return true;\n};\n\n// Alternative implementation, for memory.\n//\n// It costs 10% of performance, but allows extend terminators list, if place it\n// to `ParcerInline` property. Probably, will switch to it sometime, such\n// flexibility required.\n\n/*\nvar TERMINATOR_RE = /[\\n!#$%&*+\\-:<=>@[\\\\\\]^_`{}~]/;\n\nmodule.exports = function text(state, silent) {\n  var pos = state.pos,\n      idx = state.src.slice(pos).search(TERMINATOR_RE);\n\n  // first char is terminator -> empty text\n  if (idx === 0) { return false; }\n\n  // no terminator -> text till end of string\n  if (idx < 0) {\n    if (!silent) { state.pending += state.src.slice(pos); }\n    state.pos = state.src.length;\n    return true;\n  }\n\n  if (!silent) { state.pending += state.src.slice(pos, pos + idx); }\n\n  state.pos += idx;\n\n  return true;\n};*/\n","// Proceess '\\n'\n\n'use strict';\n\nvar isSpace = require('../common/utils').isSpace;\n\n\nmodule.exports = function newline(state, silent) {\n  var pmax, max, pos = state.pos;\n\n  if (state.src.charCodeAt(pos) !== 0x0A/* \\n */) { return false; }\n\n  pmax = state.pending.length - 1;\n  max = state.posMax;\n\n  // '  \\n' -> hardbreak\n  // Lookup in pending chars is bad practice! Don't copy to other rules!\n  // Pending string is stored in concat mode, indexed lookups will cause\n  // convertion to flat mode.\n  if (!silent) {\n    if (pmax >= 0 && state.pending.charCodeAt(pmax) === 0x20) {\n      if (pmax >= 1 && state.pending.charCodeAt(pmax - 1) === 0x20) {\n        state.pending = state.pending.replace(/ +$/, '');\n        state.push('hardbreak', 'br', 0);\n      } else {\n        state.pending = state.pending.slice(0, -1);\n        state.push('softbreak', 'br', 0);\n      }\n\n    } else {\n      state.push('softbreak', 'br', 0);\n    }\n  }\n\n  pos++;\n\n  // skip heading spaces for next line\n  while (pos < max && isSpace(state.src.charCodeAt(pos))) { pos++; }\n\n  state.pos = pos;\n  return true;\n};\n","// Process escaped chars and hardbreaks\n\n'use strict';\n\nvar isSpace = require('../common/utils').isSpace;\n\nvar ESCAPED = [];\n\nfor (var i = 0; i < 256; i++) { ESCAPED.push(0); }\n\n'\\\\!\"#$%&\\'()*+,./:;<=>?@[]^_`{|}~-'\n  .split('').forEach(function (ch) { ESCAPED[ch.charCodeAt(0)] = 1; });\n\n\nmodule.exports = function escape(state, silent) {\n  var ch, pos = state.pos, max = state.posMax;\n\n  if (state.src.charCodeAt(pos) !== 0x5C/* \\ */) { return false; }\n\n  pos++;\n\n  if (pos < max) {\n    ch = state.src.charCodeAt(pos);\n\n    if (ch < 256 && ESCAPED[ch] !== 0) {\n      if (!silent) { state.pending += state.src[pos]; }\n      state.pos += 2;\n      return true;\n    }\n\n    if (ch === 0x0A) {\n      if (!silent) {\n        state.push('hardbreak', 'br', 0);\n      }\n\n      pos++;\n      // skip leading whitespaces from next line\n      while (pos < max) {\n        ch = state.src.charCodeAt(pos);\n        if (!isSpace(ch)) { break; }\n        pos++;\n      }\n\n      state.pos = pos;\n      return true;\n    }\n  }\n\n  if (!silent) { state.pending += '\\\\'; }\n  state.pos++;\n  return true;\n};\n","// Parse backticks\n\n'use strict';\n\nmodule.exports = function backtick(state, silent) {\n  var start, max, marker, matchStart, matchEnd, token,\n      pos = state.pos,\n      ch = state.src.charCodeAt(pos);\n\n  if (ch !== 0x60/* ` */) { return false; }\n\n  start = pos;\n  pos++;\n  max = state.posMax;\n\n  while (pos < max && state.src.charCodeAt(pos) === 0x60/* ` */) { pos++; }\n\n  marker = state.src.slice(start, pos);\n\n  matchStart = matchEnd = pos;\n\n  while ((matchStart = state.src.indexOf('`', matchEnd)) !== -1) {\n    matchEnd = matchStart + 1;\n\n    while (matchEnd < max && state.src.charCodeAt(matchEnd) === 0x60/* ` */) { matchEnd++; }\n\n    if (matchEnd - matchStart === marker.length) {\n      if (!silent) {\n        token         = state.push('code_inline', 'code', 0);\n        token.markup  = marker;\n        token.content = state.src.slice(pos, matchStart)\n          .replace(/\\n/g, ' ')\n          .replace(/^ (.+) $/, '$1');\n      }\n      state.pos = matchEnd;\n      return true;\n    }\n  }\n\n  if (!silent) { state.pending += marker; }\n  state.pos += marker.length;\n  return true;\n};\n","// Process [link](<to> \"stuff\")\n\n'use strict';\n\nvar normalizeReference   = require('../common/utils').normalizeReference;\nvar isSpace              = require('../common/utils').isSpace;\n\n\nmodule.exports = function link(state, silent) {\n  var attrs,\n      code,\n      label,\n      labelEnd,\n      labelStart,\n      pos,\n      res,\n      ref,\n      title,\n      token,\n      href = '',\n      oldPos = state.pos,\n      max = state.posMax,\n      start = state.pos,\n      parseReference = true;\n\n  if (state.src.charCodeAt(state.pos) !== 0x5B/* [ */) { return false; }\n\n  labelStart = state.pos + 1;\n  labelEnd = state.md.helpers.parseLinkLabel(state, state.pos, true);\n\n  // parser failed to find ']', so it's not a valid link\n  if (labelEnd < 0) { return false; }\n\n  pos = labelEnd + 1;\n  if (pos < max && state.src.charCodeAt(pos) === 0x28/* ( */) {\n    //\n    // Inline link\n    //\n\n    // might have found a valid shortcut link, disable reference parsing\n    parseReference = false;\n\n    // [link](  <href>  \"title\"  )\n    //        ^^ skipping these spaces\n    pos++;\n    for (; pos < max; pos++) {\n      code = state.src.charCodeAt(pos);\n      if (!isSpace(code) && code !== 0x0A) { break; }\n    }\n    if (pos >= max) { return false; }\n\n    // [link](  <href>  \"title\"  )\n    //          ^^^^^^ parsing link destination\n    start = pos;\n    res = state.md.helpers.parseLinkDestination(state.src, pos, state.posMax);\n    if (res.ok) {\n      href = state.md.normalizeLink(res.str);\n      if (state.md.validateLink(href)) {\n        pos = res.pos;\n      } else {\n        href = '';\n      }\n    }\n\n    // [link](  <href>  \"title\"  )\n    //                ^^ skipping these spaces\n    start = pos;\n    for (; pos < max; pos++) {\n      code = state.src.charCodeAt(pos);\n      if (!isSpace(code) && code !== 0x0A) { break; }\n    }\n\n    // [link](  <href>  \"title\"  )\n    //                  ^^^^^^^ parsing link title\n    res = state.md.helpers.parseLinkTitle(state.src, pos, state.posMax);\n    if (pos < max && start !== pos && res.ok) {\n      title = res.str;\n      pos = res.pos;\n\n      // [link](  <href>  \"title\"  )\n      //                         ^^ skipping these spaces\n      for (; pos < max; pos++) {\n        code = state.src.charCodeAt(pos);\n        if (!isSpace(code) && code !== 0x0A) { break; }\n      }\n    } else {\n      title = '';\n    }\n\n    if (pos >= max || state.src.charCodeAt(pos) !== 0x29/* ) */) {\n      // parsing a valid shortcut link failed, fallback to reference\n      parseReference = true;\n    }\n    pos++;\n  }\n\n  if (parseReference) {\n    //\n    // Link reference\n    //\n    if (typeof state.env.references === 'undefined') { return false; }\n\n    if (pos < max && state.src.charCodeAt(pos) === 0x5B/* [ */) {\n      start = pos + 1;\n      pos = state.md.helpers.parseLinkLabel(state, pos);\n      if (pos >= 0) {\n        label = state.src.slice(start, pos++);\n      } else {\n        pos = labelEnd + 1;\n      }\n    } else {\n      pos = labelEnd + 1;\n    }\n\n    // covers label === '' and label === undefined\n    // (collapsed reference link and shortcut reference link respectively)\n    if (!label) { label = state.src.slice(labelStart, labelEnd); }\n\n    ref = state.env.references[normalizeReference(label)];\n    if (!ref) {\n      state.pos = oldPos;\n      return false;\n    }\n    href = ref.href;\n    title = ref.title;\n  }\n\n  //\n  // We found the end of the link, and know for a fact it's a valid link;\n  // so all that's left to do is to call tokenizer.\n  //\n  if (!silent) {\n    state.pos = labelStart;\n    state.posMax = labelEnd;\n\n    token        = state.push('link_open', 'a', 1);\n    token.attrs  = attrs = [ [ 'href', href ] ];\n    if (title) {\n      attrs.push([ 'title', title ]);\n    }\n\n    state.md.inline.tokenize(state);\n\n    token        = state.push('link_close', 'a', -1);\n  }\n\n  state.pos = pos;\n  state.posMax = max;\n  return true;\n};\n","// Process ![image](<src> \"title\")\n\n'use strict';\n\nvar normalizeReference   = require('../common/utils').normalizeReference;\nvar isSpace              = require('../common/utils').isSpace;\n\n\nmodule.exports = function image(state, silent) {\n  var attrs,\n      code,\n      content,\n      label,\n      labelEnd,\n      labelStart,\n      pos,\n      ref,\n      res,\n      title,\n      token,\n      tokens,\n      start,\n      href = '',\n      oldPos = state.pos,\n      max = state.posMax;\n\n  if (state.src.charCodeAt(state.pos) !== 0x21/* ! */) { return false; }\n  if (state.src.charCodeAt(state.pos + 1) !== 0x5B/* [ */) { return false; }\n\n  labelStart = state.pos + 2;\n  labelEnd = state.md.helpers.parseLinkLabel(state, state.pos + 1, false);\n\n  // parser failed to find ']', so it's not a valid link\n  if (labelEnd < 0) { return false; }\n\n  pos = labelEnd + 1;\n  if (pos < max && state.src.charCodeAt(pos) === 0x28/* ( */) {\n    //\n    // Inline link\n    //\n\n    // [link](  <href>  \"title\"  )\n    //        ^^ skipping these spaces\n    pos++;\n    for (; pos < max; pos++) {\n      code = state.src.charCodeAt(pos);\n      if (!isSpace(code) && code !== 0x0A) { break; }\n    }\n    if (pos >= max) { return false; }\n\n    // [link](  <href>  \"title\"  )\n    //          ^^^^^^ parsing link destination\n    start = pos;\n    res = state.md.helpers.parseLinkDestination(state.src, pos, state.posMax);\n    if (res.ok) {\n      href = state.md.normalizeLink(res.str);\n      if (state.md.validateLink(href)) {\n        pos = res.pos;\n      } else {\n        href = '';\n      }\n    }\n\n    // [link](  <href>  \"title\"  )\n    //                ^^ skipping these spaces\n    start = pos;\n    for (; pos < max; pos++) {\n      code = state.src.charCodeAt(pos);\n      if (!isSpace(code) && code !== 0x0A) { break; }\n    }\n\n    // [link](  <href>  \"title\"  )\n    //                  ^^^^^^^ parsing link title\n    res = state.md.helpers.parseLinkTitle(state.src, pos, state.posMax);\n    if (pos < max && start !== pos && res.ok) {\n      title = res.str;\n      pos = res.pos;\n\n      // [link](  <href>  \"title\"  )\n      //                         ^^ skipping these spaces\n      for (; pos < max; pos++) {\n        code = state.src.charCodeAt(pos);\n        if (!isSpace(code) && code !== 0x0A) { break; }\n      }\n    } else {\n      title = '';\n    }\n\n    if (pos >= max || state.src.charCodeAt(pos) !== 0x29/* ) */) {\n      state.pos = oldPos;\n      return false;\n    }\n    pos++;\n  } else {\n    //\n    // Link reference\n    //\n    if (typeof state.env.references === 'undefined') { return false; }\n\n    if (pos < max && state.src.charCodeAt(pos) === 0x5B/* [ */) {\n      start = pos + 1;\n      pos = state.md.helpers.parseLinkLabel(state, pos);\n      if (pos >= 0) {\n        label = state.src.slice(start, pos++);\n      } else {\n        pos = labelEnd + 1;\n      }\n    } else {\n      pos = labelEnd + 1;\n    }\n\n    // covers label === '' and label === undefined\n    // (collapsed reference link and shortcut reference link respectively)\n    if (!label) { label = state.src.slice(labelStart, labelEnd); }\n\n    ref = state.env.references[normalizeReference(label)];\n    if (!ref) {\n      state.pos = oldPos;\n      return false;\n    }\n    href = ref.href;\n    title = ref.title;\n  }\n\n  //\n  // We found the end of the link, and know for a fact it's a valid link;\n  // so all that's left to do is to call tokenizer.\n  //\n  if (!silent) {\n    content = state.src.slice(labelStart, labelEnd);\n\n    state.md.inline.parse(\n      content,\n      state.md,\n      state.env,\n      tokens = []\n    );\n\n    token          = state.push('image', 'img', 0);\n    token.attrs    = attrs = [ [ 'src', href ], [ 'alt', '' ] ];\n    token.children = tokens;\n    token.content  = content;\n\n    if (title) {\n      attrs.push([ 'title', title ]);\n    }\n  }\n\n  state.pos = pos;\n  state.posMax = max;\n  return true;\n};\n","// Process autolinks '<protocol:...>'\n\n'use strict';\n\n\n/*eslint max-len:0*/\nvar EMAIL_RE    = /^<([a-zA-Z0-9.!#$%&'*+\\/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*)>/;\nvar AUTOLINK_RE = /^<([a-zA-Z][a-zA-Z0-9+.\\-]{1,31}):([^<>\\x00-\\x20]*)>/;\n\n\nmodule.exports = function autolink(state, silent) {\n  var tail, linkMatch, emailMatch, url, fullUrl, token,\n      pos = state.pos;\n\n  if (state.src.charCodeAt(pos) !== 0x3C/* < */) { return false; }\n\n  tail = state.src.slice(pos);\n\n  if (tail.indexOf('>') < 0) { return false; }\n\n  if (AUTOLINK_RE.test(tail)) {\n    linkMatch = tail.match(AUTOLINK_RE);\n\n    url = linkMatch[0].slice(1, -1);\n    fullUrl = state.md.normalizeLink(url);\n    if (!state.md.validateLink(fullUrl)) { return false; }\n\n    if (!silent) {\n      token         = state.push('link_open', 'a', 1);\n      token.attrs   = [ [ 'href', fullUrl ] ];\n      token.markup  = 'autolink';\n      token.info    = 'auto';\n\n      token         = state.push('text', '', 0);\n      token.content = state.md.normalizeLinkText(url);\n\n      token         = state.push('link_close', 'a', -1);\n      token.markup  = 'autolink';\n      token.info    = 'auto';\n    }\n\n    state.pos += linkMatch[0].length;\n    return true;\n  }\n\n  if (EMAIL_RE.test(tail)) {\n    emailMatch = tail.match(EMAIL_RE);\n\n    url = emailMatch[0].slice(1, -1);\n    fullUrl = state.md.normalizeLink('mailto:' + url);\n    if (!state.md.validateLink(fullUrl)) { return false; }\n\n    if (!silent) {\n      token         = state.push('link_open', 'a', 1);\n      token.attrs   = [ [ 'href', fullUrl ] ];\n      token.markup  = 'autolink';\n      token.info    = 'auto';\n\n      token         = state.push('text', '', 0);\n      token.content = state.md.normalizeLinkText(url);\n\n      token         = state.push('link_close', 'a', -1);\n      token.markup  = 'autolink';\n      token.info    = 'auto';\n    }\n\n    state.pos += emailMatch[0].length;\n    return true;\n  }\n\n  return false;\n};\n","// Process html tags\n\n'use strict';\n\n\nvar HTML_TAG_RE = require('../common/html_re').HTML_TAG_RE;\n\n\nfunction isLetter(ch) {\n  /*eslint no-bitwise:0*/\n  var lc = ch | 0x20; // to lower case\n  return (lc >= 0x61/* a */) && (lc <= 0x7a/* z */);\n}\n\n\nmodule.exports = function html_inline(state, silent) {\n  var ch, match, max, token,\n      pos = state.pos;\n\n  if (!state.md.options.html) { return false; }\n\n  // Check start\n  max = state.posMax;\n  if (state.src.charCodeAt(pos) !== 0x3C/* < */ ||\n      pos + 2 >= max) {\n    return false;\n  }\n\n  // Quick fail on second char\n  ch = state.src.charCodeAt(pos + 1);\n  if (ch !== 0x21/* ! */ &&\n      ch !== 0x3F/* ? */ &&\n      ch !== 0x2F/* / */ &&\n      !isLetter(ch)) {\n    return false;\n  }\n\n  match = state.src.slice(pos).match(HTML_TAG_RE);\n  if (!match) { return false; }\n\n  if (!silent) {\n    token         = state.push('html_inline', '', 0);\n    token.content = state.src.slice(pos, pos + match[0].length);\n  }\n  state.pos += match[0].length;\n  return true;\n};\n","// Process html entity - &#123;, &#xAF;, &quot;, ...\n\n'use strict';\n\nvar entities          = require('../common/entities');\nvar has               = require('../common/utils').has;\nvar isValidEntityCode = require('../common/utils').isValidEntityCode;\nvar fromCodePoint     = require('../common/utils').fromCodePoint;\n\n\nvar DIGITAL_RE = /^&#((?:x[a-f0-9]{1,6}|[0-9]{1,7}));/i;\nvar NAMED_RE   = /^&([a-z][a-z0-9]{1,31});/i;\n\n\nmodule.exports = function entity(state, silent) {\n  var ch, code, match, pos = state.pos, max = state.posMax;\n\n  if (state.src.charCodeAt(pos) !== 0x26/* & */) { return false; }\n\n  if (pos + 1 < max) {\n    ch = state.src.charCodeAt(pos + 1);\n\n    if (ch === 0x23 /* # */) {\n      match = state.src.slice(pos).match(DIGITAL_RE);\n      if (match) {\n        if (!silent) {\n          code = match[1][0].toLowerCase() === 'x' ? parseInt(match[1].slice(1), 16) : parseInt(match[1], 10);\n          state.pending += isValidEntityCode(code) ? fromCodePoint(code) : fromCodePoint(0xFFFD);\n        }\n        state.pos += match[0].length;\n        return true;\n      }\n    } else {\n      match = state.src.slice(pos).match(NAMED_RE);\n      if (match) {\n        if (has(entities, match[1])) {\n          if (!silent) { state.pending += entities[match[1]]; }\n          state.pos += match[0].length;\n          return true;\n        }\n      }\n    }\n  }\n\n  if (!silent) { state.pending += '&'; }\n  state.pos++;\n  return true;\n};\n","// For each opening emphasis-like marker find a matching closing one\n//\n'use strict';\n\n\nfunction processDelimiters(state, delimiters) {\n  var closerIdx, openerIdx, closer, opener, minOpenerIdx, newMinOpenerIdx,\n      isOddMatch, lastJump,\n      openersBottom = {},\n      max = delimiters.length;\n\n  for (closerIdx = 0; closerIdx < max; closerIdx++) {\n    closer = delimiters[closerIdx];\n\n    // Length is only used for emphasis-specific \"rule of 3\",\n    // if it's not defined (in strikethrough or 3rd party plugins),\n    // we can default it to 0 to disable those checks.\n    //\n    closer.length = closer.length || 0;\n\n    if (!closer.close) continue;\n\n    // Previously calculated lower bounds (previous fails)\n    // for each marker and each delimiter length modulo 3.\n    if (!openersBottom.hasOwnProperty(closer.marker)) {\n      openersBottom[closer.marker] = [ -1, -1, -1 ];\n    }\n\n    minOpenerIdx = openersBottom[closer.marker][closer.length % 3];\n    newMinOpenerIdx = -1;\n\n    openerIdx = closerIdx - closer.jump - 1;\n\n    for (; openerIdx > minOpenerIdx; openerIdx -= opener.jump + 1) {\n      opener = delimiters[openerIdx];\n\n      if (opener.marker !== closer.marker) continue;\n\n      if (newMinOpenerIdx === -1) newMinOpenerIdx = openerIdx;\n\n      if (opener.open &&\n          opener.end < 0 &&\n          opener.level === closer.level) {\n\n        isOddMatch = false;\n\n        // from spec:\n        //\n        // If one of the delimiters can both open and close emphasis, then the\n        // sum of the lengths of the delimiter runs containing the opening and\n        // closing delimiters must not be a multiple of 3 unless both lengths\n        // are multiples of 3.\n        //\n        if (opener.close || closer.open) {\n          if ((opener.length + closer.length) % 3 === 0) {\n            if (opener.length % 3 !== 0 || closer.length % 3 !== 0) {\n              isOddMatch = true;\n            }\n          }\n        }\n\n        if (!isOddMatch) {\n          // If previous delimiter cannot be an opener, we can safely skip\n          // the entire sequence in future checks. This is required to make\n          // sure algorithm has linear complexity (see *_*_*_*_*_... case).\n          //\n          lastJump = openerIdx > 0 && !delimiters[openerIdx - 1].open ?\n            delimiters[openerIdx - 1].jump + 1 :\n            0;\n\n          closer.jump  = closerIdx - openerIdx + lastJump;\n          closer.open  = false;\n          opener.end   = closerIdx;\n          opener.jump  = lastJump;\n          opener.close = false;\n          newMinOpenerIdx = -1;\n          break;\n        }\n      }\n    }\n\n    if (newMinOpenerIdx !== -1) {\n      // If match for this delimiter run failed, we want to set lower bound for\n      // future lookups. This is required to make sure algorithm has linear\n      // complexity.\n      //\n      // See details here:\n      // https://github.com/commonmark/cmark/issues/178#issuecomment-270417442\n      //\n      openersBottom[closer.marker][(closer.length || 0) % 3] = newMinOpenerIdx;\n    }\n  }\n}\n\n\nmodule.exports = function link_pairs(state) {\n  var curr,\n      tokens_meta = state.tokens_meta,\n      max = state.tokens_meta.length;\n\n  processDelimiters(state, state.delimiters);\n\n  for (curr = 0; curr < max; curr++) {\n    if (tokens_meta[curr] && tokens_meta[curr].delimiters) {\n      processDelimiters(state, tokens_meta[curr].delimiters);\n    }\n  }\n};\n","// Clean up tokens after emphasis and strikethrough postprocessing:\n// merge adjacent text nodes into one and re-calculate all token levels\n//\n// This is necessary because initially emphasis delimiter markers (*, _, ~)\n// are treated as their own separate text tokens. Then emphasis rule either\n// leaves them as text (needed to merge with adjacent text) or turns them\n// into opening/closing tags (which messes up levels inside).\n//\n'use strict';\n\n\nmodule.exports = function text_collapse(state) {\n  var curr, last,\n      level = 0,\n      tokens = state.tokens,\n      max = state.tokens.length;\n\n  for (curr = last = 0; curr < max; curr++) {\n    // re-calculate levels after emphasis/strikethrough turns some text nodes\n    // into opening/closing tags\n    if (tokens[curr].nesting < 0) level--; // closing tag\n    tokens[curr].level = level;\n    if (tokens[curr].nesting > 0) level++; // opening tag\n\n    if (tokens[curr].type === 'text' &&\n        curr + 1 < max &&\n        tokens[curr + 1].type === 'text') {\n\n      // collapse two adjacent text nodes\n      tokens[curr + 1].content = tokens[curr].content + tokens[curr + 1].content;\n    } else {\n      if (curr !== last) { tokens[last] = tokens[curr]; }\n\n      last++;\n    }\n  }\n\n  if (curr !== last) {\n    tokens.length = last;\n  }\n};\n","// Inline parser state\n\n'use strict';\n\n\nvar Token          = require('../token');\nvar isWhiteSpace   = require('../common/utils').isWhiteSpace;\nvar isPunctChar    = require('../common/utils').isPunctChar;\nvar isMdAsciiPunct = require('../common/utils').isMdAsciiPunct;\n\n\nfunction StateInline(src, md, env, outTokens) {\n  this.src = src;\n  this.env = env;\n  this.md = md;\n  this.tokens = outTokens;\n  this.tokens_meta = Array(outTokens.length);\n\n  this.pos = 0;\n  this.posMax = this.src.length;\n  this.level = 0;\n  this.pending = '';\n  this.pendingLevel = 0;\n\n  // Stores { start: end } pairs. Useful for backtrack\n  // optimization of pairs parse (emphasis, strikes).\n  this.cache = {};\n\n  // List of emphasis-like delimiters for current tag\n  this.delimiters = [];\n\n  // Stack of delimiter lists for upper level tags\n  this._prev_delimiters = [];\n}\n\n\n// Flush pending text\n//\nStateInline.prototype.pushPending = function () {\n  var token = new Token('text', '', 0);\n  token.content = this.pending;\n  token.level = this.pendingLevel;\n  this.tokens.push(token);\n  this.pending = '';\n  return token;\n};\n\n\n// Push new token to \"stream\".\n// If pending text exists - flush it as text token\n//\nStateInline.prototype.push = function (type, tag, nesting) {\n  if (this.pending) {\n    this.pushPending();\n  }\n\n  var token = new Token(type, tag, nesting);\n  var token_meta = null;\n\n  if (nesting < 0) {\n    // closing tag\n    this.level--;\n    this.delimiters = this._prev_delimiters.pop();\n  }\n\n  token.level = this.level;\n\n  if (nesting > 0) {\n    // opening tag\n    this.level++;\n    this._prev_delimiters.push(this.delimiters);\n    this.delimiters = [];\n    token_meta = { delimiters: this.delimiters };\n  }\n\n  this.pendingLevel = this.level;\n  this.tokens.push(token);\n  this.tokens_meta.push(token_meta);\n  return token;\n};\n\n\n// Scan a sequence of emphasis-like markers, and determine whether\n// it can start an emphasis sequence or end an emphasis sequence.\n//\n//  - start - position to scan from (it should point at a valid marker);\n//  - canSplitWord - determine if these markers can be found inside a word\n//\nStateInline.prototype.scanDelims = function (start, canSplitWord) {\n  var pos = start, lastChar, nextChar, count, can_open, can_close,\n      isLastWhiteSpace, isLastPunctChar,\n      isNextWhiteSpace, isNextPunctChar,\n      left_flanking = true,\n      right_flanking = true,\n      max = this.posMax,\n      marker = this.src.charCodeAt(start);\n\n  // treat beginning of the line as a whitespace\n  lastChar = start > 0 ? this.src.charCodeAt(start - 1) : 0x20;\n\n  while (pos < max && this.src.charCodeAt(pos) === marker) { pos++; }\n\n  count = pos - start;\n\n  // treat end of the line as a whitespace\n  nextChar = pos < max ? this.src.charCodeAt(pos) : 0x20;\n\n  isLastPunctChar = isMdAsciiPunct(lastChar) || isPunctChar(String.fromCharCode(lastChar));\n  isNextPunctChar = isMdAsciiPunct(nextChar) || isPunctChar(String.fromCharCode(nextChar));\n\n  isLastWhiteSpace = isWhiteSpace(lastChar);\n  isNextWhiteSpace = isWhiteSpace(nextChar);\n\n  if (isNextWhiteSpace) {\n    left_flanking = false;\n  } else if (isNextPunctChar) {\n    if (!(isLastWhiteSpace || isLastPunctChar)) {\n      left_flanking = false;\n    }\n  }\n\n  if (isLastWhiteSpace) {\n    right_flanking = false;\n  } else if (isLastPunctChar) {\n    if (!(isNextWhiteSpace || isNextPunctChar)) {\n      right_flanking = false;\n    }\n  }\n\n  if (!canSplitWord) {\n    can_open  = left_flanking  && (!right_flanking || isLastPunctChar);\n    can_close = right_flanking && (!left_flanking  || isNextPunctChar);\n  } else {\n    can_open  = left_flanking;\n    can_close = right_flanking;\n  }\n\n  return {\n    can_open:  can_open,\n    can_close: can_close,\n    length:    count\n  };\n};\n\n\n// re-export Token class to use in block rules\nStateInline.prototype.Token = Token;\n\n\nmodule.exports = StateInline;\n","'use strict';\n\n\n////////////////////////////////////////////////////////////////////////////////\n// Helpers\n\n// Merge objects\n//\nfunction assign(obj /*from1, from2, from3, ...*/) {\n  var sources = Array.prototype.slice.call(arguments, 1);\n\n  sources.forEach(function (source) {\n    if (!source) { return; }\n\n    Object.keys(source).forEach(function (key) {\n      obj[key] = source[key];\n    });\n  });\n\n  return obj;\n}\n\nfunction _class(obj) { return Object.prototype.toString.call(obj); }\nfunction isString(obj) { return _class(obj) === '[object String]'; }\nfunction isObject(obj) { return _class(obj) === '[object Object]'; }\nfunction isRegExp(obj) { return _class(obj) === '[object RegExp]'; }\nfunction isFunction(obj) { return _class(obj) === '[object Function]'; }\n\n\nfunction escapeRE(str) { return str.replace(/[.?*+^$[\\]\\\\(){}|-]/g, '\\\\$&'); }\n\n////////////////////////////////////////////////////////////////////////////////\n\n\nvar defaultOptions = {\n  fuzzyLink: true,\n  fuzzyEmail: true,\n  fuzzyIP: false\n};\n\n\nfunction isOptionsObj(obj) {\n  return Object.keys(obj || {}).reduce(function (acc, k) {\n    return acc || defaultOptions.hasOwnProperty(k);\n  }, false);\n}\n\n\nvar defaultSchemas = {\n  'http:': {\n    validate: function (text, pos, self) {\n      var tail = text.slice(pos);\n\n      if (!self.re.http) {\n        // compile lazily, because \"host\"-containing variables can change on tlds update.\n        self.re.http =  new RegExp(\n          '^\\\\/\\\\/' + self.re.src_auth + self.re.src_host_port_strict + self.re.src_path, 'i'\n        );\n      }\n      if (self.re.http.test(tail)) {\n        return tail.match(self.re.http)[0].length;\n      }\n      return 0;\n    }\n  },\n  'https:':  'http:',\n  'ftp:':    'http:',\n  '//':      {\n    validate: function (text, pos, self) {\n      var tail = text.slice(pos);\n\n      if (!self.re.no_http) {\n      // compile lazily, because \"host\"-containing variables can change on tlds update.\n        self.re.no_http =  new RegExp(\n          '^' +\n          self.re.src_auth +\n          // Don't allow single-level domains, because of false positives like '//test'\n          // with code comments\n          '(?:localhost|(?:(?:' + self.re.src_domain + ')\\\\.)+' + self.re.src_domain_root + ')' +\n          self.re.src_port +\n          self.re.src_host_terminator +\n          self.re.src_path,\n\n          'i'\n        );\n      }\n\n      if (self.re.no_http.test(tail)) {\n        // should not be `://` & `///`, that protects from errors in protocol name\n        if (pos >= 3 && text[pos - 3] === ':') { return 0; }\n        if (pos >= 3 && text[pos - 3] === '/') { return 0; }\n        return tail.match(self.re.no_http)[0].length;\n      }\n      return 0;\n    }\n  },\n  'mailto:': {\n    validate: function (text, pos, self) {\n      var tail = text.slice(pos);\n\n      if (!self.re.mailto) {\n        self.re.mailto =  new RegExp(\n          '^' + self.re.src_email_name + '@' + self.re.src_host_strict, 'i'\n        );\n      }\n      if (self.re.mailto.test(tail)) {\n        return tail.match(self.re.mailto)[0].length;\n      }\n      return 0;\n    }\n  }\n};\n\n/*eslint-disable max-len*/\n\n// RE pattern for 2-character tlds (autogenerated by ./support/tlds_2char_gen.js)\nvar tlds_2ch_src_re = 'a[cdefgilmnoqrstuwxz]|b[abdefghijmnorstvwyz]|c[acdfghiklmnoruvwxyz]|d[ejkmoz]|e[cegrstu]|f[ijkmor]|g[abdefghilmnpqrstuwy]|h[kmnrtu]|i[delmnoqrst]|j[emop]|k[eghimnprwyz]|l[abcikrstuvy]|m[acdeghklmnopqrstuvwxyz]|n[acefgilopruz]|om|p[aefghklmnrstwy]|qa|r[eosuw]|s[abcdeghijklmnortuvxyz]|t[cdfghjklmnortvwz]|u[agksyz]|v[aceginu]|w[fs]|y[et]|z[amw]';\n\n// DON'T try to make PRs with changes. Extend TLDs with LinkifyIt.tlds() instead\nvar tlds_default = 'biz|com|edu|gov|net|org|pro|web|xxx|aero|asia|coop|info|museum|name|shop|рф'.split('|');\n\n/*eslint-enable max-len*/\n\n////////////////////////////////////////////////////////////////////////////////\n\nfunction resetScanCache(self) {\n  self.__index__ = -1;\n  self.__text_cache__   = '';\n}\n\nfunction createValidator(re) {\n  return function (text, pos) {\n    var tail = text.slice(pos);\n\n    if (re.test(tail)) {\n      return tail.match(re)[0].length;\n    }\n    return 0;\n  };\n}\n\nfunction createNormalizer() {\n  return function (match, self) {\n    self.normalize(match);\n  };\n}\n\n// Schemas compiler. Build regexps.\n//\nfunction compile(self) {\n\n  // Load & clone RE patterns.\n  var re = self.re = require('./lib/re')(self.__opts__);\n\n  // Define dynamic patterns\n  var tlds = self.__tlds__.slice();\n\n  self.onCompile();\n\n  if (!self.__tlds_replaced__) {\n    tlds.push(tlds_2ch_src_re);\n  }\n  tlds.push(re.src_xn);\n\n  re.src_tlds = tlds.join('|');\n\n  function untpl(tpl) { return tpl.replace('%TLDS%', re.src_tlds); }\n\n  re.email_fuzzy      = RegExp(untpl(re.tpl_email_fuzzy), 'i');\n  re.link_fuzzy       = RegExp(untpl(re.tpl_link_fuzzy), 'i');\n  re.link_no_ip_fuzzy = RegExp(untpl(re.tpl_link_no_ip_fuzzy), 'i');\n  re.host_fuzzy_test  = RegExp(untpl(re.tpl_host_fuzzy_test), 'i');\n\n  //\n  // Compile each schema\n  //\n\n  var aliases = [];\n\n  self.__compiled__ = {}; // Reset compiled data\n\n  function schemaError(name, val) {\n    throw new Error('(LinkifyIt) Invalid schema \"' + name + '\": ' + val);\n  }\n\n  Object.keys(self.__schemas__).forEach(function (name) {\n    var val = self.__schemas__[name];\n\n    // skip disabled methods\n    if (val === null) { return; }\n\n    var compiled = { validate: null, link: null };\n\n    self.__compiled__[name] = compiled;\n\n    if (isObject(val)) {\n      if (isRegExp(val.validate)) {\n        compiled.validate = createValidator(val.validate);\n      } else if (isFunction(val.validate)) {\n        compiled.validate = val.validate;\n      } else {\n        schemaError(name, val);\n      }\n\n      if (isFunction(val.normalize)) {\n        compiled.normalize = val.normalize;\n      } else if (!val.normalize) {\n        compiled.normalize = createNormalizer();\n      } else {\n        schemaError(name, val);\n      }\n\n      return;\n    }\n\n    if (isString(val)) {\n      aliases.push(name);\n      return;\n    }\n\n    schemaError(name, val);\n  });\n\n  //\n  // Compile postponed aliases\n  //\n\n  aliases.forEach(function (alias) {\n    if (!self.__compiled__[self.__schemas__[alias]]) {\n      // Silently fail on missed schemas to avoid errons on disable.\n      // schemaError(alias, self.__schemas__[alias]);\n      return;\n    }\n\n    self.__compiled__[alias].validate =\n      self.__compiled__[self.__schemas__[alias]].validate;\n    self.__compiled__[alias].normalize =\n      self.__compiled__[self.__schemas__[alias]].normalize;\n  });\n\n  //\n  // Fake record for guessed links\n  //\n  self.__compiled__[''] = { validate: null, normalize: createNormalizer() };\n\n  //\n  // Build schema condition\n  //\n  var slist = Object.keys(self.__compiled__)\n                      .filter(function (name) {\n                        // Filter disabled & fake schemas\n                        return name.length > 0 && self.__compiled__[name];\n                      })\n                      .map(escapeRE)\n                      .join('|');\n  // (?!_) cause 1.5x slowdown\n  self.re.schema_test   = RegExp('(^|(?!_)(?:[><\\uff5c]|' + re.src_ZPCc + '))(' + slist + ')', 'i');\n  self.re.schema_search = RegExp('(^|(?!_)(?:[><\\uff5c]|' + re.src_ZPCc + '))(' + slist + ')', 'ig');\n\n  self.re.pretest = RegExp(\n    '(' + self.re.schema_test.source + ')|(' + self.re.host_fuzzy_test.source + ')|@',\n    'i'\n  );\n\n  //\n  // Cleanup\n  //\n\n  resetScanCache(self);\n}\n\n/**\n * class Match\n *\n * Match result. Single element of array, returned by [[LinkifyIt#match]]\n **/\nfunction Match(self, shift) {\n  var start = self.__index__,\n      end   = self.__last_index__,\n      text  = self.__text_cache__.slice(start, end);\n\n  /**\n   * Match#schema -> String\n   *\n   * Prefix (protocol) for matched string.\n   **/\n  this.schema    = self.__schema__.toLowerCase();\n  /**\n   * Match#index -> Number\n   *\n   * First position of matched string.\n   **/\n  this.index     = start + shift;\n  /**\n   * Match#lastIndex -> Number\n   *\n   * Next position after matched string.\n   **/\n  this.lastIndex = end + shift;\n  /**\n   * Match#raw -> String\n   *\n   * Matched string.\n   **/\n  this.raw       = text;\n  /**\n   * Match#text -> String\n   *\n   * Notmalized text of matched string.\n   **/\n  this.text      = text;\n  /**\n   * Match#url -> String\n   *\n   * Normalized url of matched string.\n   **/\n  this.url       = text;\n}\n\nfunction createMatch(self, shift) {\n  var match = new Match(self, shift);\n\n  self.__compiled__[match.schema].normalize(match, self);\n\n  return match;\n}\n\n\n/**\n * class LinkifyIt\n **/\n\n/**\n * new LinkifyIt(schemas, options)\n * - schemas (Object): Optional. Additional schemas to validate (prefix/validator)\n * - options (Object): { fuzzyLink|fuzzyEmail|fuzzyIP: true|false }\n *\n * Creates new linkifier instance with optional additional schemas.\n * Can be called without `new` keyword for convenience.\n *\n * By default understands:\n *\n * - `http(s)://...` , `ftp://...`, `mailto:...` & `//...` links\n * - \"fuzzy\" links and emails (example.com, foo@bar.com).\n *\n * `schemas` is an object, where each key/value describes protocol/rule:\n *\n * - __key__ - link prefix (usually, protocol name with `:` at the end, `skype:`\n *   for example). `linkify-it` makes shure that prefix is not preceeded with\n *   alphanumeric char and symbols. Only whitespaces and punctuation allowed.\n * - __value__ - rule to check tail after link prefix\n *   - _String_ - just alias to existing rule\n *   - _Object_\n *     - _validate_ - validator function (should return matched length on success),\n *       or `RegExp`.\n *     - _normalize_ - optional function to normalize text & url of matched result\n *       (for example, for @twitter mentions).\n *\n * `options`:\n *\n * - __fuzzyLink__ - recognige URL-s without `http(s):` prefix. Default `true`.\n * - __fuzzyIP__ - allow IPs in fuzzy links above. Can conflict with some texts\n *   like version numbers. Default `false`.\n * - __fuzzyEmail__ - recognize emails without `mailto:` prefix.\n *\n **/\nfunction LinkifyIt(schemas, options) {\n  if (!(this instanceof LinkifyIt)) {\n    return new LinkifyIt(schemas, options);\n  }\n\n  if (!options) {\n    if (isOptionsObj(schemas)) {\n      options = schemas;\n      schemas = {};\n    }\n  }\n\n  this.__opts__           = assign({}, defaultOptions, options);\n\n  // Cache last tested result. Used to skip repeating steps on next `match` call.\n  this.__index__          = -1;\n  this.__last_index__     = -1; // Next scan position\n  this.__schema__         = '';\n  this.__text_cache__     = '';\n\n  this.__schemas__        = assign({}, defaultSchemas, schemas);\n  this.__compiled__       = {};\n\n  this.__tlds__           = tlds_default;\n  this.__tlds_replaced__  = false;\n\n  this.re = {};\n\n  compile(this);\n}\n\n\n/** chainable\n * LinkifyIt#add(schema, definition)\n * - schema (String): rule name (fixed pattern prefix)\n * - definition (String|RegExp|Object): schema definition\n *\n * Add new rule definition. See constructor description for details.\n **/\nLinkifyIt.prototype.add = function add(schema, definition) {\n  this.__schemas__[schema] = definition;\n  compile(this);\n  return this;\n};\n\n\n/** chainable\n * LinkifyIt#set(options)\n * - options (Object): { fuzzyLink|fuzzyEmail|fuzzyIP: true|false }\n *\n * Set recognition options for links without schema.\n **/\nLinkifyIt.prototype.set = function set(options) {\n  this.__opts__ = assign(this.__opts__, options);\n  return this;\n};\n\n\n/**\n * LinkifyIt#test(text) -> Boolean\n *\n * Searches linkifiable pattern and returns `true` on success or `false` on fail.\n **/\nLinkifyIt.prototype.test = function test(text) {\n  // Reset scan cache\n  this.__text_cache__ = text;\n  this.__index__      = -1;\n\n  if (!text.length) { return false; }\n\n  var m, ml, me, len, shift, next, re, tld_pos, at_pos;\n\n  // try to scan for link with schema - that's the most simple rule\n  if (this.re.schema_test.test(text)) {\n    re = this.re.schema_search;\n    re.lastIndex = 0;\n    while ((m = re.exec(text)) !== null) {\n      len = this.testSchemaAt(text, m[2], re.lastIndex);\n      if (len) {\n        this.__schema__     = m[2];\n        this.__index__      = m.index + m[1].length;\n        this.__last_index__ = m.index + m[0].length + len;\n        break;\n      }\n    }\n  }\n\n  if (this.__opts__.fuzzyLink && this.__compiled__['http:']) {\n    // guess schemaless links\n    tld_pos = text.search(this.re.host_fuzzy_test);\n    if (tld_pos >= 0) {\n      // if tld is located after found link - no need to check fuzzy pattern\n      if (this.__index__ < 0 || tld_pos < this.__index__) {\n        if ((ml = text.match(this.__opts__.fuzzyIP ? this.re.link_fuzzy : this.re.link_no_ip_fuzzy)) !== null) {\n\n          shift = ml.index + ml[1].length;\n\n          if (this.__index__ < 0 || shift < this.__index__) {\n            this.__schema__     = '';\n            this.__index__      = shift;\n            this.__last_index__ = ml.index + ml[0].length;\n          }\n        }\n      }\n    }\n  }\n\n  if (this.__opts__.fuzzyEmail && this.__compiled__['mailto:']) {\n    // guess schemaless emails\n    at_pos = text.indexOf('@');\n    if (at_pos >= 0) {\n      // We can't skip this check, because this cases are possible:\n      // 192.168.1.1@gmail.com, my.in@example.com\n      if ((me = text.match(this.re.email_fuzzy)) !== null) {\n\n        shift = me.index + me[1].length;\n        next  = me.index + me[0].length;\n\n        if (this.__index__ < 0 || shift < this.__index__ ||\n            (shift === this.__index__ && next > this.__last_index__)) {\n          this.__schema__     = 'mailto:';\n          this.__index__      = shift;\n          this.__last_index__ = next;\n        }\n      }\n    }\n  }\n\n  return this.__index__ >= 0;\n};\n\n\n/**\n * LinkifyIt#pretest(text) -> Boolean\n *\n * Very quick check, that can give false positives. Returns true if link MAY BE\n * can exists. Can be used for speed optimization, when you need to check that\n * link NOT exists.\n **/\nLinkifyIt.prototype.pretest = function pretest(text) {\n  return this.re.pretest.test(text);\n};\n\n\n/**\n * LinkifyIt#testSchemaAt(text, name, position) -> Number\n * - text (String): text to scan\n * - name (String): rule (schema) name\n * - position (Number): text offset to check from\n *\n * Similar to [[LinkifyIt#test]] but checks only specific protocol tail exactly\n * at given position. Returns length of found pattern (0 on fail).\n **/\nLinkifyIt.prototype.testSchemaAt = function testSchemaAt(text, schema, pos) {\n  // If not supported schema check requested - terminate\n  if (!this.__compiled__[schema.toLowerCase()]) {\n    return 0;\n  }\n  return this.__compiled__[schema.toLowerCase()].validate(text, pos, this);\n};\n\n\n/**\n * LinkifyIt#match(text) -> Array|null\n *\n * Returns array of found link descriptions or `null` on fail. We strongly\n * recommend to use [[LinkifyIt#test]] first, for best speed.\n *\n * ##### Result match description\n *\n * - __schema__ - link schema, can be empty for fuzzy links, or `//` for\n *   protocol-neutral  links.\n * - __index__ - offset of matched text\n * - __lastIndex__ - index of next char after mathch end\n * - __raw__ - matched text\n * - __text__ - normalized text\n * - __url__ - link, generated from matched text\n **/\nLinkifyIt.prototype.match = function match(text) {\n  var shift = 0, result = [];\n\n  // Try to take previous element from cache, if .test() called before\n  if (this.__index__ >= 0 && this.__text_cache__ === text) {\n    result.push(createMatch(this, shift));\n    shift = this.__last_index__;\n  }\n\n  // Cut head if cache was used\n  var tail = shift ? text.slice(shift) : text;\n\n  // Scan string until end reached\n  while (this.test(tail)) {\n    result.push(createMatch(this, shift));\n\n    tail = tail.slice(this.__last_index__);\n    shift += this.__last_index__;\n  }\n\n  if (result.length) {\n    return result;\n  }\n\n  return null;\n};\n\n\n/** chainable\n * LinkifyIt#tlds(list [, keepOld]) -> this\n * - list (Array): list of tlds\n * - keepOld (Boolean): merge with current list if `true` (`false` by default)\n *\n * Load (or merge) new tlds list. Those are user for fuzzy links (without prefix)\n * to avoid false positives. By default this algorythm used:\n *\n * - hostname with any 2-letter root zones are ok.\n * - biz|com|edu|gov|net|org|pro|web|xxx|aero|asia|coop|info|museum|name|shop|рф\n *   are ok.\n * - encoded (`xn--...`) root zones are ok.\n *\n * If list is replaced, then exact match for 2-chars root zones will be checked.\n **/\nLinkifyIt.prototype.tlds = function tlds(list, keepOld) {\n  list = Array.isArray(list) ? list : [ list ];\n\n  if (!keepOld) {\n    this.__tlds__ = list.slice();\n    this.__tlds_replaced__ = true;\n    compile(this);\n    return this;\n  }\n\n  this.__tlds__ = this.__tlds__.concat(list)\n                                  .sort()\n                                  .filter(function (el, idx, arr) {\n                                    return el !== arr[idx - 1];\n                                  })\n                                  .reverse();\n\n  compile(this);\n  return this;\n};\n\n/**\n * LinkifyIt#normalize(match)\n *\n * Default normalizer (if schema does not define it's own).\n **/\nLinkifyIt.prototype.normalize = function normalize(match) {\n\n  // Do minimal possible changes by default. Need to collect feedback prior\n  // to move forward https://github.com/markdown-it/linkify-it/issues/1\n\n  if (!match.schema) { match.url = 'http://' + match.url; }\n\n  if (match.schema === 'mailto:' && !/^mailto:/i.test(match.url)) {\n    match.url = 'mailto:' + match.url;\n  }\n};\n\n\n/**\n * LinkifyIt#onCompile()\n *\n * Override to modify basic RegExp-s.\n **/\nLinkifyIt.prototype.onCompile = function onCompile() {\n};\n\n\nmodule.exports = LinkifyIt;\n","'use strict';\n\n\nmodule.exports = function (opts) {\n  var re = {};\n\n  // Use direct extract instead of `regenerate` to reduse browserified size\n  re.src_Any = require('uc.micro/properties/Any/regex').source;\n  re.src_Cc  = require('uc.micro/categories/Cc/regex').source;\n  re.src_Z   = require('uc.micro/categories/Z/regex').source;\n  re.src_P   = require('uc.micro/categories/P/regex').source;\n\n  // \\p{\\Z\\P\\Cc\\CF} (white spaces + control + format + punctuation)\n  re.src_ZPCc = [ re.src_Z, re.src_P, re.src_Cc ].join('|');\n\n  // \\p{\\Z\\Cc} (white spaces + control)\n  re.src_ZCc = [ re.src_Z, re.src_Cc ].join('|');\n\n  // Experimental. List of chars, completely prohibited in links\n  // because can separate it from other part of text\n  var text_separators = '[><\\uff5c]';\n\n  // All possible word characters (everything without punctuation, spaces & controls)\n  // Defined via punctuation & spaces to save space\n  // Should be something like \\p{\\L\\N\\S\\M} (\\w but without `_`)\n  re.src_pseudo_letter       = '(?:(?!' + text_separators + '|' + re.src_ZPCc + ')' + re.src_Any + ')';\n  // The same as abothe but without [0-9]\n  // var src_pseudo_letter_non_d = '(?:(?![0-9]|' + src_ZPCc + ')' + src_Any + ')';\n\n  ////////////////////////////////////////////////////////////////////////////////\n\n  re.src_ip4 =\n\n    '(?:(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)';\n\n  // Prohibit any of \"@/[]()\" in user/pass to avoid wrong domain fetch.\n  re.src_auth    = '(?:(?:(?!' + re.src_ZCc + '|[@/\\\\[\\\\]()]).)+@)?';\n\n  re.src_port =\n\n    '(?::(?:6(?:[0-4]\\\\d{3}|5(?:[0-4]\\\\d{2}|5(?:[0-2]\\\\d|3[0-5])))|[1-5]?\\\\d{1,4}))?';\n\n  re.src_host_terminator =\n\n    '(?=$|' + text_separators + '|' + re.src_ZPCc + ')(?!-|_|:\\\\d|\\\\.-|\\\\.(?!$|' + re.src_ZPCc + '))';\n\n  re.src_path =\n\n    '(?:' +\n      '[/?#]' +\n        '(?:' +\n          '(?!' + re.src_ZCc + '|' + text_separators + '|[()[\\\\]{}.,\"\\'?!\\\\-]).|' +\n          '\\\\[(?:(?!' + re.src_ZCc + '|\\\\]).)*\\\\]|' +\n          '\\\\((?:(?!' + re.src_ZCc + '|[)]).)*\\\\)|' +\n          '\\\\{(?:(?!' + re.src_ZCc + '|[}]).)*\\\\}|' +\n          '\\\\\"(?:(?!' + re.src_ZCc + '|[\"]).)+\\\\\"|' +\n          \"\\\\'(?:(?!\" + re.src_ZCc + \"|[']).)+\\\\'|\" +\n          \"\\\\'(?=\" + re.src_pseudo_letter + '|[-]).|' +  // allow `I'm_king` if no pair found\n          '\\\\.{2,4}[a-zA-Z0-9%/]|' + // github has ... in commit range links,\n                                     // google has .... in links (issue #66)\n                                     // Restrict to\n                                     // - english\n                                     // - percent-encoded\n                                     // - parts of file path\n                                     // until more examples found.\n          '\\\\.(?!' + re.src_ZCc + '|[.]).|' +\n          (opts && opts['---'] ?\n            '\\\\-(?!--(?:[^-]|$))(?:-*)|' // `---` => long dash, terminate\n            :\n            '\\\\-+|'\n          ) +\n          '\\\\,(?!' + re.src_ZCc + ').|' +      // allow `,,,` in paths\n          '\\\\!(?!' + re.src_ZCc + '|[!]).|' +\n          '\\\\?(?!' + re.src_ZCc + '|[?]).' +\n        ')+' +\n      '|\\\\/' +\n    ')?';\n\n  // Allow anything in markdown spec, forbid quote (\") at the first position\n  // because emails enclosed in quotes are far more common\n  re.src_email_name =\n\n    '[\\\\-;:&=\\\\+\\\\$,\\\\.a-zA-Z0-9_][\\\\-;:&=\\\\+\\\\$,\\\\\"\\\\.a-zA-Z0-9_]*';\n\n  re.src_xn =\n\n    'xn--[a-z0-9\\\\-]{1,59}';\n\n  // More to read about domain names\n  // http://serverfault.com/questions/638260/\n\n  re.src_domain_root =\n\n    // Allow letters & digits (http://test1)\n    '(?:' +\n      re.src_xn +\n      '|' +\n      re.src_pseudo_letter + '{1,63}' +\n    ')';\n\n  re.src_domain =\n\n    '(?:' +\n      re.src_xn +\n      '|' +\n      '(?:' + re.src_pseudo_letter + ')' +\n      '|' +\n      '(?:' + re.src_pseudo_letter + '(?:-|' + re.src_pseudo_letter + '){0,61}' + re.src_pseudo_letter + ')' +\n    ')';\n\n  re.src_host =\n\n    '(?:' +\n    // Don't need IP check, because digits are already allowed in normal domain names\n    //   src_ip4 +\n    // '|' +\n      '(?:(?:(?:' + re.src_domain + ')\\\\.)*' + re.src_domain/*_root*/ + ')' +\n    ')';\n\n  re.tpl_host_fuzzy =\n\n    '(?:' +\n      re.src_ip4 +\n    '|' +\n      '(?:(?:(?:' + re.src_domain + ')\\\\.)+(?:%TLDS%))' +\n    ')';\n\n  re.tpl_host_no_ip_fuzzy =\n\n    '(?:(?:(?:' + re.src_domain + ')\\\\.)+(?:%TLDS%))';\n\n  re.src_host_strict =\n\n    re.src_host + re.src_host_terminator;\n\n  re.tpl_host_fuzzy_strict =\n\n    re.tpl_host_fuzzy + re.src_host_terminator;\n\n  re.src_host_port_strict =\n\n    re.src_host + re.src_port + re.src_host_terminator;\n\n  re.tpl_host_port_fuzzy_strict =\n\n    re.tpl_host_fuzzy + re.src_port + re.src_host_terminator;\n\n  re.tpl_host_port_no_ip_fuzzy_strict =\n\n    re.tpl_host_no_ip_fuzzy + re.src_port + re.src_host_terminator;\n\n\n  ////////////////////////////////////////////////////////////////////////////////\n  // Main rules\n\n  // Rude test fuzzy links by host, for quick deny\n  re.tpl_host_fuzzy_test =\n\n    'localhost|www\\\\.|\\\\.\\\\d{1,3}\\\\.|(?:\\\\.(?:%TLDS%)(?:' + re.src_ZPCc + '|>|$))';\n\n  re.tpl_email_fuzzy =\n\n      '(^|' + text_separators + '|\"|\\\\(|' + re.src_ZCc + ')' +\n      '(' + re.src_email_name + '@' + re.tpl_host_fuzzy_strict + ')';\n\n  re.tpl_link_fuzzy =\n      // Fuzzy link can't be prepended with .:/\\- and non punctuation.\n      // but can start with > (markdown blockquote)\n      '(^|(?![.:/\\\\-_@])(?:[$+<=>^`|\\uff5c]|' + re.src_ZPCc + '))' +\n      '((?![$+<=>^`|\\uff5c])' + re.tpl_host_port_fuzzy_strict + re.src_path + ')';\n\n  re.tpl_link_no_ip_fuzzy =\n      // Fuzzy link can't be prepended with .:/\\- and non punctuation.\n      // but can start with > (markdown blockquote)\n      '(^|(?![.:/\\\\-_@])(?:[$+<=>^`|\\uff5c]|' + re.src_ZPCc + '))' +\n      '((?![$+<=>^`|\\uff5c])' + re.tpl_host_port_no_ip_fuzzy_strict + re.src_path + ')';\n\n  return re;\n};\n","/*! https://mths.be/punycode v1.4.1 by @mathias */\n;(function(root) {\n\n\t/** Detect free variables */\n\tvar freeExports = typeof exports == 'object' && exports &&\n\t\t!exports.nodeType && exports;\n\tvar freeModule = typeof module == 'object' && module &&\n\t\t!module.nodeType && module;\n\tvar freeGlobal = typeof global == 'object' && global;\n\tif (\n\t\tfreeGlobal.global === freeGlobal ||\n\t\tfreeGlobal.window === freeGlobal ||\n\t\tfreeGlobal.self === freeGlobal\n\t) {\n\t\troot = freeGlobal;\n\t}\n\n\t/**\n\t * The `punycode` object.\n\t * @name punycode\n\t * @type Object\n\t */\n\tvar punycode,\n\n\t/** Highest positive signed 32-bit float value */\n\tmaxInt = 2147483647, // aka. 0x7FFFFFFF or 2^31-1\n\n\t/** Bootstring parameters */\n\tbase = 36,\n\ttMin = 1,\n\ttMax = 26,\n\tskew = 38,\n\tdamp = 700,\n\tinitialBias = 72,\n\tinitialN = 128, // 0x80\n\tdelimiter = '-', // '\\x2D'\n\n\t/** Regular expressions */\n\tregexPunycode = /^xn--/,\n\tregexNonASCII = /[^\\x20-\\x7E]/, // unprintable ASCII chars + non-ASCII chars\n\tregexSeparators = /[\\x2E\\u3002\\uFF0E\\uFF61]/g, // RFC 3490 separators\n\n\t/** Error messages */\n\terrors = {\n\t\t'overflow': 'Overflow: input needs wider integers to process',\n\t\t'not-basic': 'Illegal input >= 0x80 (not a basic code point)',\n\t\t'invalid-input': 'Invalid input'\n\t},\n\n\t/** Convenience shortcuts */\n\tbaseMinusTMin = base - tMin,\n\tfloor = Math.floor,\n\tstringFromCharCode = String.fromCharCode,\n\n\t/** Temporary variable */\n\tkey;\n\n\t/*--------------------------------------------------------------------------*/\n\n\t/**\n\t * A generic error utility function.\n\t * @private\n\t * @param {String} type The error type.\n\t * @returns {Error} Throws a `RangeError` with the applicable error message.\n\t */\n\tfunction error(type) {\n\t\tthrow new RangeError(errors[type]);\n\t}\n\n\t/**\n\t * A generic `Array#map` utility function.\n\t * @private\n\t * @param {Array} array The array to iterate over.\n\t * @param {Function} callback The function that gets called for every array\n\t * item.\n\t * @returns {Array} A new array of values returned by the callback function.\n\t */\n\tfunction map(array, fn) {\n\t\tvar length = array.length;\n\t\tvar result = [];\n\t\twhile (length--) {\n\t\t\tresult[length] = fn(array[length]);\n\t\t}\n\t\treturn result;\n\t}\n\n\t/**\n\t * A simple `Array#map`-like wrapper to work with domain name strings or email\n\t * addresses.\n\t * @private\n\t * @param {String} domain The domain name or email address.\n\t * @param {Function} callback The function that gets called for every\n\t * character.\n\t * @returns {Array} A new string of characters returned by the callback\n\t * function.\n\t */\n\tfunction mapDomain(string, fn) {\n\t\tvar parts = string.split('@');\n\t\tvar result = '';\n\t\tif (parts.length > 1) {\n\t\t\t// In email addresses, only the domain name should be punycoded. Leave\n\t\t\t// the local part (i.e. everything up to `@`) intact.\n\t\t\tresult = parts[0] + '@';\n\t\t\tstring = parts[1];\n\t\t}\n\t\t// Avoid `split(regex)` for IE8 compatibility. See #17.\n\t\tstring = string.replace(regexSeparators, '\\x2E');\n\t\tvar labels = string.split('.');\n\t\tvar encoded = map(labels, fn).join('.');\n\t\treturn result + encoded;\n\t}\n\n\t/**\n\t * Creates an array containing the numeric code points of each Unicode\n\t * character in the string. While JavaScript uses UCS-2 internally,\n\t * this function will convert a pair of surrogate halves (each of which\n\t * UCS-2 exposes as separate characters) into a single code point,\n\t * matching UTF-16.\n\t * @see `punycode.ucs2.encode`\n\t * @see <https://mathiasbynens.be/notes/javascript-encoding>\n\t * @memberOf punycode.ucs2\n\t * @name decode\n\t * @param {String} string The Unicode input string (UCS-2).\n\t * @returns {Array} The new array of code points.\n\t */\n\tfunction ucs2decode(string) {\n\t\tvar output = [],\n\t\t    counter = 0,\n\t\t    length = string.length,\n\t\t    value,\n\t\t    extra;\n\t\twhile (counter < length) {\n\t\t\tvalue = string.charCodeAt(counter++);\n\t\t\tif (value >= 0xD800 && value <= 0xDBFF && counter < length) {\n\t\t\t\t// high surrogate, and there is a next character\n\t\t\t\textra = string.charCodeAt(counter++);\n\t\t\t\tif ((extra & 0xFC00) == 0xDC00) { // low surrogate\n\t\t\t\t\toutput.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000);\n\t\t\t\t} else {\n\t\t\t\t\t// unmatched surrogate; only append this code unit, in case the next\n\t\t\t\t\t// code unit is the high surrogate of a surrogate pair\n\t\t\t\t\toutput.push(value);\n\t\t\t\t\tcounter--;\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\toutput.push(value);\n\t\t\t}\n\t\t}\n\t\treturn output;\n\t}\n\n\t/**\n\t * Creates a string based on an array of numeric code points.\n\t * @see `punycode.ucs2.decode`\n\t * @memberOf punycode.ucs2\n\t * @name encode\n\t * @param {Array} codePoints The array of numeric code points.\n\t * @returns {String} The new Unicode string (UCS-2).\n\t */\n\tfunction ucs2encode(array) {\n\t\treturn map(array, function(value) {\n\t\t\tvar output = '';\n\t\t\tif (value > 0xFFFF) {\n\t\t\t\tvalue -= 0x10000;\n\t\t\t\toutput += stringFromCharCode(value >>> 10 & 0x3FF | 0xD800);\n\t\t\t\tvalue = 0xDC00 | value & 0x3FF;\n\t\t\t}\n\t\t\toutput += stringFromCharCode(value);\n\t\t\treturn output;\n\t\t}).join('');\n\t}\n\n\t/**\n\t * Converts a basic code point into a digit/integer.\n\t * @see `digitToBasic()`\n\t * @private\n\t * @param {Number} codePoint The basic numeric code point value.\n\t * @returns {Number} The numeric value of a basic code point (for use in\n\t * representing integers) in the range `0` to `base - 1`, or `base` if\n\t * the code point does not represent a value.\n\t */\n\tfunction basicToDigit(codePoint) {\n\t\tif (codePoint - 48 < 10) {\n\t\t\treturn codePoint - 22;\n\t\t}\n\t\tif (codePoint - 65 < 26) {\n\t\t\treturn codePoint - 65;\n\t\t}\n\t\tif (codePoint - 97 < 26) {\n\t\t\treturn codePoint - 97;\n\t\t}\n\t\treturn base;\n\t}\n\n\t/**\n\t * Converts a digit/integer into a basic code point.\n\t * @see `basicToDigit()`\n\t * @private\n\t * @param {Number} digit The numeric value of a basic code point.\n\t * @returns {Number} The basic code point whose value (when used for\n\t * representing integers) is `digit`, which needs to be in the range\n\t * `0` to `base - 1`. If `flag` is non-zero, the uppercase form is\n\t * used; else, the lowercase form is used. The behavior is undefined\n\t * if `flag` is non-zero and `digit` has no uppercase form.\n\t */\n\tfunction digitToBasic(digit, flag) {\n\t\t//  0..25 map to ASCII a..z or A..Z\n\t\t// 26..35 map to ASCII 0..9\n\t\treturn digit + 22 + 75 * (digit < 26) - ((flag != 0) << 5);\n\t}\n\n\t/**\n\t * Bias adaptation function as per section 3.4 of RFC 3492.\n\t * https://tools.ietf.org/html/rfc3492#section-3.4\n\t * @private\n\t */\n\tfunction adapt(delta, numPoints, firstTime) {\n\t\tvar k = 0;\n\t\tdelta = firstTime ? floor(delta / damp) : delta >> 1;\n\t\tdelta += floor(delta / numPoints);\n\t\tfor (/* no initialization */; delta > baseMinusTMin * tMax >> 1; k += base) {\n\t\t\tdelta = floor(delta / baseMinusTMin);\n\t\t}\n\t\treturn floor(k + (baseMinusTMin + 1) * delta / (delta + skew));\n\t}\n\n\t/**\n\t * Converts a Punycode string of ASCII-only symbols to a string of Unicode\n\t * symbols.\n\t * @memberOf punycode\n\t * @param {String} input The Punycode string of ASCII-only symbols.\n\t * @returns {String} The resulting string of Unicode symbols.\n\t */\n\tfunction decode(input) {\n\t\t// Don't use UCS-2\n\t\tvar output = [],\n\t\t    inputLength = input.length,\n\t\t    out,\n\t\t    i = 0,\n\t\t    n = initialN,\n\t\t    bias = initialBias,\n\t\t    basic,\n\t\t    j,\n\t\t    index,\n\t\t    oldi,\n\t\t    w,\n\t\t    k,\n\t\t    digit,\n\t\t    t,\n\t\t    /** Cached calculation results */\n\t\t    baseMinusT;\n\n\t\t// Handle the basic code points: let `basic` be the number of input code\n\t\t// points before the last delimiter, or `0` if there is none, then copy\n\t\t// the first basic code points to the output.\n\n\t\tbasic = input.lastIndexOf(delimiter);\n\t\tif (basic < 0) {\n\t\t\tbasic = 0;\n\t\t}\n\n\t\tfor (j = 0; j < basic; ++j) {\n\t\t\t// if it's not a basic code point\n\t\t\tif (input.charCodeAt(j) >= 0x80) {\n\t\t\t\terror('not-basic');\n\t\t\t}\n\t\t\toutput.push(input.charCodeAt(j));\n\t\t}\n\n\t\t// Main decoding loop: start just after the last delimiter if any basic code\n\t\t// points were copied; start at the beginning otherwise.\n\n\t\tfor (index = basic > 0 ? basic + 1 : 0; index < inputLength; /* no final expression */) {\n\n\t\t\t// `index` is the index of the next character to be consumed.\n\t\t\t// Decode a generalized variable-length integer into `delta`,\n\t\t\t// which gets added to `i`. The overflow checking is easier\n\t\t\t// if we increase `i` as we go, then subtract off its starting\n\t\t\t// value at the end to obtain `delta`.\n\t\t\tfor (oldi = i, w = 1, k = base; /* no condition */; k += base) {\n\n\t\t\t\tif (index >= inputLength) {\n\t\t\t\t\terror('invalid-input');\n\t\t\t\t}\n\n\t\t\t\tdigit = basicToDigit(input.charCodeAt(index++));\n\n\t\t\t\tif (digit >= base || digit > floor((maxInt - i) / w)) {\n\t\t\t\t\terror('overflow');\n\t\t\t\t}\n\n\t\t\t\ti += digit * w;\n\t\t\t\tt = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);\n\n\t\t\t\tif (digit < t) {\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\n\t\t\t\tbaseMinusT = base - t;\n\t\t\t\tif (w > floor(maxInt / baseMinusT)) {\n\t\t\t\t\terror('overflow');\n\t\t\t\t}\n\n\t\t\t\tw *= baseMinusT;\n\n\t\t\t}\n\n\t\t\tout = output.length + 1;\n\t\t\tbias = adapt(i - oldi, out, oldi == 0);\n\n\t\t\t// `i` was supposed to wrap around from `out` to `0`,\n\t\t\t// incrementing `n` each time, so we'll fix that now:\n\t\t\tif (floor(i / out) > maxInt - n) {\n\t\t\t\terror('overflow');\n\t\t\t}\n\n\t\t\tn += floor(i / out);\n\t\t\ti %= out;\n\n\t\t\t// Insert `n` at position `i` of the output\n\t\t\toutput.splice(i++, 0, n);\n\n\t\t}\n\n\t\treturn ucs2encode(output);\n\t}\n\n\t/**\n\t * Converts a string of Unicode symbols (e.g. a domain name label) to a\n\t * Punycode string of ASCII-only symbols.\n\t * @memberOf punycode\n\t * @param {String} input The string of Unicode symbols.\n\t * @returns {String} The resulting Punycode string of ASCII-only symbols.\n\t */\n\tfunction encode(input) {\n\t\tvar n,\n\t\t    delta,\n\t\t    handledCPCount,\n\t\t    basicLength,\n\t\t    bias,\n\t\t    j,\n\t\t    m,\n\t\t    q,\n\t\t    k,\n\t\t    t,\n\t\t    currentValue,\n\t\t    output = [],\n\t\t    /** `inputLength` will hold the number of code points in `input`. */\n\t\t    inputLength,\n\t\t    /** Cached calculation results */\n\t\t    handledCPCountPlusOne,\n\t\t    baseMinusT,\n\t\t    qMinusT;\n\n\t\t// Convert the input in UCS-2 to Unicode\n\t\tinput = ucs2decode(input);\n\n\t\t// Cache the length\n\t\tinputLength = input.length;\n\n\t\t// Initialize the state\n\t\tn = initialN;\n\t\tdelta = 0;\n\t\tbias = initialBias;\n\n\t\t// Handle the basic code points\n\t\tfor (j = 0; j < inputLength; ++j) {\n\t\t\tcurrentValue = input[j];\n\t\t\tif (currentValue < 0x80) {\n\t\t\t\toutput.push(stringFromCharCode(currentValue));\n\t\t\t}\n\t\t}\n\n\t\thandledCPCount = basicLength = output.length;\n\n\t\t// `handledCPCount` is the number of code points that have been handled;\n\t\t// `basicLength` is the number of basic code points.\n\n\t\t// Finish the basic string - if it is not empty - with a delimiter\n\t\tif (basicLength) {\n\t\t\toutput.push(delimiter);\n\t\t}\n\n\t\t// Main encoding loop:\n\t\twhile (handledCPCount < inputLength) {\n\n\t\t\t// All non-basic code points < n have been handled already. Find the next\n\t\t\t// larger one:\n\t\t\tfor (m = maxInt, j = 0; j < inputLength; ++j) {\n\t\t\t\tcurrentValue = input[j];\n\t\t\t\tif (currentValue >= n && currentValue < m) {\n\t\t\t\t\tm = currentValue;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Increase `delta` enough to advance the decoder's <n,i> state to <m,0>,\n\t\t\t// but guard against overflow\n\t\t\thandledCPCountPlusOne = handledCPCount + 1;\n\t\t\tif (m - n > floor((maxInt - delta) / handledCPCountPlusOne)) {\n\t\t\t\terror('overflow');\n\t\t\t}\n\n\t\t\tdelta += (m - n) * handledCPCountPlusOne;\n\t\t\tn = m;\n\n\t\t\tfor (j = 0; j < inputLength; ++j) {\n\t\t\t\tcurrentValue = input[j];\n\n\t\t\t\tif (currentValue < n && ++delta > maxInt) {\n\t\t\t\t\terror('overflow');\n\t\t\t\t}\n\n\t\t\t\tif (currentValue == n) {\n\t\t\t\t\t// Represent delta as a generalized variable-length integer\n\t\t\t\t\tfor (q = delta, k = base; /* no condition */; k += base) {\n\t\t\t\t\t\tt = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);\n\t\t\t\t\t\tif (q < t) {\n\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t}\n\t\t\t\t\t\tqMinusT = q - t;\n\t\t\t\t\t\tbaseMinusT = base - t;\n\t\t\t\t\t\toutput.push(\n\t\t\t\t\t\t\tstringFromCharCode(digitToBasic(t + qMinusT % baseMinusT, 0))\n\t\t\t\t\t\t);\n\t\t\t\t\t\tq = floor(qMinusT / baseMinusT);\n\t\t\t\t\t}\n\n\t\t\t\t\toutput.push(stringFromCharCode(digitToBasic(q, 0)));\n\t\t\t\t\tbias = adapt(delta, handledCPCountPlusOne, handledCPCount == basicLength);\n\t\t\t\t\tdelta = 0;\n\t\t\t\t\t++handledCPCount;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t++delta;\n\t\t\t++n;\n\n\t\t}\n\t\treturn output.join('');\n\t}\n\n\t/**\n\t * Converts a Punycode string representing a domain name or an email address\n\t * to Unicode. Only the Punycoded parts of the input will be converted, i.e.\n\t * it doesn't matter if you call it on a string that has already been\n\t * converted to Unicode.\n\t * @memberOf punycode\n\t * @param {String} input The Punycoded domain name or email address to\n\t * convert to Unicode.\n\t * @returns {String} The Unicode representation of the given Punycode\n\t * string.\n\t */\n\tfunction toUnicode(input) {\n\t\treturn mapDomain(input, function(string) {\n\t\t\treturn regexPunycode.test(string)\n\t\t\t\t? decode(string.slice(4).toLowerCase())\n\t\t\t\t: string;\n\t\t});\n\t}\n\n\t/**\n\t * Converts a Unicode string representing a domain name or an email address to\n\t * Punycode. Only the non-ASCII parts of the domain name will be converted,\n\t * i.e. it doesn't matter if you call it with a domain that's already in\n\t * ASCII.\n\t * @memberOf punycode\n\t * @param {String} input The domain name or email address to convert, as a\n\t * Unicode string.\n\t * @returns {String} The Punycode representation of the given domain name or\n\t * email address.\n\t */\n\tfunction toASCII(input) {\n\t\treturn mapDomain(input, function(string) {\n\t\t\treturn regexNonASCII.test(string)\n\t\t\t\t? 'xn--' + encode(string)\n\t\t\t\t: string;\n\t\t});\n\t}\n\n\t/*--------------------------------------------------------------------------*/\n\n\t/** Define the public API */\n\tpunycode = {\n\t\t/**\n\t\t * A string representing the current Punycode.js version number.\n\t\t * @memberOf punycode\n\t\t * @type String\n\t\t */\n\t\t'version': '1.4.1',\n\t\t/**\n\t\t * An object of methods to convert from JavaScript's internal character\n\t\t * representation (UCS-2) to Unicode code points, and back.\n\t\t * @see <https://mathiasbynens.be/notes/javascript-encoding>\n\t\t * @memberOf punycode\n\t\t * @type Object\n\t\t */\n\t\t'ucs2': {\n\t\t\t'decode': ucs2decode,\n\t\t\t'encode': ucs2encode\n\t\t},\n\t\t'decode': decode,\n\t\t'encode': encode,\n\t\t'toASCII': toASCII,\n\t\t'toUnicode': toUnicode\n\t};\n\n\t/** Expose `punycode` */\n\t// Some AMD build optimizers, like r.js, check for specific condition patterns\n\t// like the following:\n\tif (\n\t\ttypeof define == 'function' &&\n\t\ttypeof define.amd == 'object' &&\n\t\tdefine.amd\n\t) {\n\t\tdefine('punycode', function() {\n\t\t\treturn punycode;\n\t\t});\n\t} else if (freeExports && freeModule) {\n\t\tif (module.exports == freeExports) {\n\t\t\t// in Node.js, io.js, or RingoJS v0.8.0+\n\t\t\tfreeModule.exports = punycode;\n\t\t} else {\n\t\t\t// in Narwhal or RingoJS v0.7.0-\n\t\t\tfor (key in punycode) {\n\t\t\t\tpunycode.hasOwnProperty(key) && (freeExports[key] = punycode[key]);\n\t\t\t}\n\t\t}\n\t} else {\n\t\t// in Rhino or a web browser\n\t\troot.punycode = punycode;\n\t}\n\n}(this));\n","// markdown-it default options\n\n'use strict';\n\n\nmodule.exports = {\n  options: {\n    html:         false,        // Enable HTML tags in source\n    xhtmlOut:     false,        // Use '/' to close single tags (<br />)\n    breaks:       false,        // Convert '\\n' in paragraphs into <br>\n    langPrefix:   'language-',  // CSS language prefix for fenced blocks\n    linkify:      false,        // autoconvert URL-like texts to links\n\n    // Enable some language-neutral replacements + quotes beautification\n    typographer:  false,\n\n    // Double + single quotes replacement pairs, when typographer enabled,\n    // and smartquotes on. Could be either a String or an Array.\n    //\n    // For example, you can use '«»„“' for Russian, '„“‚‘' for German,\n    // and ['«\\xA0', '\\xA0»', '‹\\xA0', '\\xA0›'] for French (including nbsp).\n    quotes: '\\u201c\\u201d\\u2018\\u2019', /* “”‘’ */\n\n    // Highlighter function. Should return escaped HTML,\n    // or '' if the source string is not changed and should be escaped externaly.\n    // If result starts with <pre... internal wrapper is skipped.\n    //\n    // function (/*str, lang*/) { return ''; }\n    //\n    highlight: null,\n\n    maxNesting:   100            // Internal protection, recursion limit\n  },\n\n  components: {\n\n    core: {},\n    block: {},\n    inline: {}\n  }\n};\n","// \"Zero\" preset, with nothing enabled. Useful for manual configuring of simple\n// modes. For example, to parse bold/italic only.\n\n'use strict';\n\n\nmodule.exports = {\n  options: {\n    html:         false,        // Enable HTML tags in source\n    xhtmlOut:     false,        // Use '/' to close single tags (<br />)\n    breaks:       false,        // Convert '\\n' in paragraphs into <br>\n    langPrefix:   'language-',  // CSS language prefix for fenced blocks\n    linkify:      false,        // autoconvert URL-like texts to links\n\n    // Enable some language-neutral replacements + quotes beautification\n    typographer:  false,\n\n    // Double + single quotes replacement pairs, when typographer enabled,\n    // and smartquotes on. Could be either a String or an Array.\n    //\n    // For example, you can use '«»„“' for Russian, '„“‚‘' for German,\n    // and ['«\\xA0', '\\xA0»', '‹\\xA0', '\\xA0›'] for French (including nbsp).\n    quotes: '\\u201c\\u201d\\u2018\\u2019', /* “”‘’ */\n\n    // Highlighter function. Should return escaped HTML,\n    // or '' if the source string is not changed and should be escaped externaly.\n    // If result starts with <pre... internal wrapper is skipped.\n    //\n    // function (/*str, lang*/) { return ''; }\n    //\n    highlight: null,\n\n    maxNesting:   20            // Internal protection, recursion limit\n  },\n\n  components: {\n\n    core: {\n      rules: [\n        'normalize',\n        'block',\n        'inline'\n      ]\n    },\n\n    block: {\n      rules: [\n        'paragraph'\n      ]\n    },\n\n    inline: {\n      rules: [\n        'text'\n      ],\n      rules2: [\n        'balance_pairs',\n        'text_collapse'\n      ]\n    }\n  }\n};\n","// Commonmark default options\n\n'use strict';\n\n\nmodule.exports = {\n  options: {\n    html:         true,         // Enable HTML tags in source\n    xhtmlOut:     true,         // Use '/' to close single tags (<br />)\n    breaks:       false,        // Convert '\\n' in paragraphs into <br>\n    langPrefix:   'language-',  // CSS language prefix for fenced blocks\n    linkify:      false,        // autoconvert URL-like texts to links\n\n    // Enable some language-neutral replacements + quotes beautification\n    typographer:  false,\n\n    // Double + single quotes replacement pairs, when typographer enabled,\n    // and smartquotes on. Could be either a String or an Array.\n    //\n    // For example, you can use '«»„“' for Russian, '„“‚‘' for German,\n    // and ['«\\xA0', '\\xA0»', '‹\\xA0', '\\xA0›'] for French (including nbsp).\n    quotes: '\\u201c\\u201d\\u2018\\u2019', /* “”‘’ */\n\n    // Highlighter function. Should return escaped HTML,\n    // or '' if the source string is not changed and should be escaped externaly.\n    // If result starts with <pre... internal wrapper is skipped.\n    //\n    // function (/*str, lang*/) { return ''; }\n    //\n    highlight: null,\n\n    maxNesting:   20            // Internal protection, recursion limit\n  },\n\n  components: {\n\n    core: {\n      rules: [\n        'normalize',\n        'block',\n        'inline'\n      ]\n    },\n\n    block: {\n      rules: [\n        'blockquote',\n        'code',\n        'fence',\n        'heading',\n        'hr',\n        'html_block',\n        'lheading',\n        'list',\n        'reference',\n        'paragraph'\n      ]\n    },\n\n    inline: {\n      rules: [\n        'autolink',\n        'backticks',\n        'emphasis',\n        'entity',\n        'escape',\n        'html_inline',\n        'image',\n        'link',\n        'newline',\n        'text'\n      ],\n      rules2: [\n        'balance_pairs',\n        'emphasis',\n        'text_collapse'\n      ]\n    }\n  }\n};\n","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.normalizeWhitespace = normalizeWhitespace;\nexports.invalidCharacters = void 0;\n\n/**\n *  Copyright (c) 2019 GraphQL Contributors.\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// Unicode whitespace characters that break the interface.\nconst invalidCharacters = Array.from({\n  length: 11\n}, (x, i) => {\n  // \\u2000 -> \\u200a\n  return String.fromCharCode(0x2000 + i);\n}).concat(['\\u2028', '\\u2029', '\\u202f', '\\u00a0']);\nexports.invalidCharacters = invalidCharacters;\nconst sanitizeRegex = new RegExp('[' + invalidCharacters.join('') + ']', 'g');\n\nfunction normalizeWhitespace(line) {\n  return line.replace(sanitizeRegex, ' ');\n}","\"use strict\";\n\nvar _codemirror = _interopRequireDefault(require(\"codemirror\"));\n\nvar _graphqlLanguageServiceInterface = require(\"graphql-language-service-interface\");\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\n/**\n *  Copyright (c) 2019 GraphQL Contributors\n *  All rights reserved.\n *\n *  This source code is licensed under the BSD-style license found in the\n *  LICENSE file in the root directory of this source tree. An additional grant\n *  of patent rights can be found in the PATENTS file in the same directory.\n */\n\n/**\n * Registers a \"hint\" helper for CodeMirror.\n *\n * Using CodeMirror's \"hint\" addon: https://codemirror.net/demo/complete.html\n * Given an editor, this helper will take the token at the cursor and return a\n * list of suggested tokens.\n *\n * Options:\n *\n *   - schema: GraphQLSchema provides the hinter with positionally relevant info\n *\n * Additional Events:\n *\n *   - hasCompletion (codemirror, data, token) - signaled when the hinter has a\n *     new list of completion suggestions.\n *\n */\n_codemirror.default.registerHelper('hint', 'graphql', (editor, options) => {\n  const schema = options.schema;\n\n  if (!schema) {\n    return;\n  }\n\n  const cur = editor.getCursor();\n  const token = editor.getTokenAt(cur);\n  const rawResults = (0, _graphqlLanguageServiceInterface.getAutocompleteSuggestions)(schema, editor.getValue(), cur, token);\n  /**\n   * GraphQL language service responds to the autocompletion request with\n   * a different format:\n   * type CompletionItem = {\n   *   label: string,\n   *   kind?: number,\n   *   detail?: string,\n   *   documentation?: string,\n   *   // GraphQL Deprecation information\n   *   isDeprecated?: ?string,\n   *   deprecationReason?: ?string,\n   * };\n   *\n   * Switch to codemirror-compliant format before returning results.\n   */\n\n  const tokenStart = token.type !== null && /\"|\\w/.test(token.string[0]) ? token.start : token.end;\n  const results = {\n    list: rawResults.map(item => ({\n      text: item.label,\n      type: schema.getType(item.detail),\n      description: item.documentation,\n      isDeprecated: item.isDeprecated,\n      deprecationReason: item.deprecationReason\n    })),\n    from: {\n      line: cur.line,\n      column: tokenStart\n    },\n    to: {\n      line: cur.line,\n      column: token.end\n    }\n  };\n\n  if (results && results.list && results.list.length > 0) {\n    results.from = _codemirror.default.Pos(results.from.line, results.from.column);\n    results.to = _codemirror.default.Pos(results.to.line, results.to.column);\n\n    _codemirror.default.signal(editor, 'hasCompletion', editor, results, token);\n  }\n\n  return results;\n});","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar CharacterStream = (function () {\n    function CharacterStream(sourceText) {\n        var _this = this;\n        this.getStartOfToken = function () { return _this._start; };\n        this.getCurrentPosition = function () { return _this._pos; };\n        this.eol = function () { return _this._sourceText.length === _this._pos; };\n        this.sol = function () { return _this._pos === 0; };\n        this.peek = function () {\n            return _this._sourceText.charAt(_this._pos)\n                ? _this._sourceText.charAt(_this._pos)\n                : null;\n        };\n        this.next = function () {\n            var char = _this._sourceText.charAt(_this._pos);\n            _this._pos++;\n            return char;\n        };\n        this.eat = function (pattern) {\n            var isMatched = _this._testNextCharacter(pattern);\n            if (isMatched) {\n                _this._start = _this._pos;\n                _this._pos++;\n                return _this._sourceText.charAt(_this._pos - 1);\n            }\n            return undefined;\n        };\n        this.eatWhile = function (match) {\n            var isMatched = _this._testNextCharacter(match);\n            var didEat = false;\n            if (isMatched) {\n                didEat = isMatched;\n                _this._start = _this._pos;\n            }\n            while (isMatched) {\n                _this._pos++;\n                isMatched = _this._testNextCharacter(match);\n                didEat = true;\n            }\n            return didEat;\n        };\n        this.eatSpace = function () { return _this.eatWhile(/[\\s\\u00a0]/); };\n        this.skipToEnd = function () {\n            _this._pos = _this._sourceText.length;\n        };\n        this.skipTo = function (position) {\n            _this._pos = position;\n        };\n        this.match = function (pattern, consume, caseFold) {\n            if (consume === void 0) { consume = true; }\n            if (caseFold === void 0) { caseFold = false; }\n            var token = null;\n            var match = null;\n            if (typeof pattern === 'string') {\n                var regex = new RegExp(pattern, caseFold ? 'i' : 'g');\n                match = regex.test(_this._sourceText.substr(_this._pos, pattern.length));\n                token = pattern;\n            }\n            else if (pattern instanceof RegExp) {\n                match = _this._sourceText.slice(_this._pos).match(pattern);\n                token = match && match[0];\n            }\n            if (match != null) {\n                if (typeof pattern === 'string' ||\n                    (match instanceof Array &&\n                        _this._sourceText.startsWith(match[0], _this._pos))) {\n                    if (consume) {\n                        _this._start = _this._pos;\n                        if (token && token.length) {\n                            _this._pos += token.length;\n                        }\n                    }\n                    return match;\n                }\n            }\n            return false;\n        };\n        this.backUp = function (num) {\n            _this._pos -= num;\n        };\n        this.column = function () { return _this._pos; };\n        this.indentation = function () {\n            var match = _this._sourceText.match(/\\s*/);\n            var indent = 0;\n            if (match && match.length === 0) {\n                var whitespaces = match[0];\n                var pos = 0;\n                while (whitespaces.length > pos) {\n                    if (whitespaces.charCodeAt(pos) === 9) {\n                        indent += 2;\n                    }\n                    else {\n                        indent++;\n                    }\n                    pos++;\n                }\n            }\n            return indent;\n        };\n        this.current = function () { return _this._sourceText.slice(_this._start, _this._pos); };\n        this._start = 0;\n        this._pos = 0;\n        this._sourceText = sourceText;\n    }\n    CharacterStream.prototype._testNextCharacter = function (pattern) {\n        var character = this._sourceText.charAt(this._pos);\n        var isMatched = false;\n        if (typeof pattern === 'string') {\n            isMatched = character === pattern;\n        }\n        else {\n            isMatched =\n                pattern instanceof RegExp\n                    ? pattern.test(character)\n                    : pattern(character);\n        }\n        return isMatched;\n    };\n    return CharacterStream;\n}());\nexports.default = CharacterStream;\n//# sourceMappingURL=CharacterStream.js.map","\"use strict\";\nvar __assign = (this && this.__assign) || function () {\n    __assign = Object.assign || function(t) {\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\n            s = arguments[i];\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))\n                t[p] = s[p];\n        }\n        return t;\n    };\n    return __assign.apply(this, arguments);\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar Rules_1 = require(\"./Rules\");\nfunction onlineParser(options) {\n    if (options === void 0) { options = {\n        eatWhitespace: function (stream) { return stream.eatWhile(Rules_1.isIgnored); },\n        lexRules: Rules_1.LexRules,\n        parseRules: Rules_1.ParseRules,\n        editorConfig: {},\n    }; }\n    return {\n        startState: function () {\n            var initialState = {\n                level: 0,\n                step: 0,\n                name: null,\n                kind: null,\n                type: null,\n                rule: null,\n                needsSeperator: false,\n                prevState: null,\n            };\n            pushRule(options.parseRules, initialState, 'Document');\n            return initialState;\n        },\n        token: function (stream, state) {\n            return getToken(stream, state, options);\n        },\n    };\n}\nexports.default = onlineParser;\nfunction getToken(stream, state, options) {\n    var lexRules = options.lexRules, parseRules = options.parseRules, eatWhitespace = options.eatWhitespace, editorConfig = options.editorConfig;\n    if (state.rule && state.rule.length === 0) {\n        popRule(state);\n    }\n    else if (state.needsAdvance) {\n        state.needsAdvance = false;\n        advanceRule(state, true);\n    }\n    if (stream.sol()) {\n        var tabSize = (editorConfig && editorConfig.tabSize) || 2;\n        state.indentLevel = Math.floor(stream.indentation() / tabSize);\n    }\n    if (eatWhitespace(stream)) {\n        return 'ws';\n    }\n    var token = lex(lexRules, stream);\n    if (!token) {\n        var matchedSomething = stream.match(/\\S+/);\n        if (!matchedSomething) {\n            stream.match(/\\s/);\n        }\n        pushRule(SpecialParseRules, state, 'Invalid');\n        return 'invalidchar';\n    }\n    if (token.kind === 'Comment') {\n        pushRule(SpecialParseRules, state, 'Comment');\n        return 'comment';\n    }\n    var backupState = assign({}, state);\n    if (token.kind === 'Punctuation') {\n        if (/^[{([]/.test(token.value)) {\n            if (state.indentLevel !== undefined) {\n                state.levels = (state.levels || []).concat(state.indentLevel + 1);\n            }\n        }\n        else if (/^[})\\]]/.test(token.value)) {\n            var levels = (state.levels = (state.levels || []).slice(0, -1));\n            if (state.indentLevel) {\n                if (levels.length > 0 &&\n                    levels[levels.length - 1] < state.indentLevel) {\n                    state.indentLevel = levels[levels.length - 1];\n                }\n            }\n        }\n    }\n    while (state.rule) {\n        var expected = typeof state.rule === 'function'\n            ? state.step === 0\n                ? state.rule(token, stream)\n                : null\n            : state.rule[state.step];\n        if (state.needsSeperator) {\n            expected = expected && expected.separator;\n        }\n        if (expected) {\n            if (expected.ofRule) {\n                expected = expected.ofRule;\n            }\n            if (typeof expected === 'string') {\n                pushRule(parseRules, state, expected);\n                continue;\n            }\n            if (expected.match && expected.match(token)) {\n                if (expected.update) {\n                    expected.update(state, token);\n                }\n                if (token.kind === 'Punctuation') {\n                    advanceRule(state, true);\n                }\n                else {\n                    state.needsAdvance = true;\n                }\n                return expected.style;\n            }\n        }\n        unsuccessful(state);\n    }\n    assign(state, backupState);\n    pushRule(SpecialParseRules, state, 'Invalid');\n    return 'invalidchar';\n}\nfunction assign(to, from) {\n    var keys = Object.keys(from);\n    for (var i = 0; i < keys.length; i++) {\n        to[keys[i]] = from[keys[i]];\n    }\n    return to;\n}\nvar SpecialParseRules = {\n    Invalid: [],\n    Comment: [],\n};\nfunction pushRule(rules, state, ruleKind) {\n    if (!rules[ruleKind]) {\n        throw new TypeError('Unknown rule: ' + ruleKind);\n    }\n    state.prevState = __assign({}, state);\n    state.kind = ruleKind;\n    state.name = null;\n    state.type = null;\n    state.rule = rules[ruleKind];\n    state.step = 0;\n    state.needsSeperator = false;\n}\nfunction popRule(state) {\n    if (!state.prevState) {\n        return;\n    }\n    state.kind = state.prevState.kind;\n    state.name = state.prevState.name;\n    state.type = state.prevState.type;\n    state.rule = state.prevState.rule;\n    state.step = state.prevState.step;\n    state.needsSeperator = state.prevState.needsSeperator;\n    state.prevState = state.prevState.prevState;\n}\nfunction advanceRule(state, successful) {\n    if (isList(state) && state.rule) {\n        var step = state.rule[state.step];\n        if (step.separator) {\n            var separator = step.separator;\n            state.needsSeperator = !state.needsSeperator;\n            if (!state.needsSeperator && separator.ofRule) {\n                return;\n            }\n        }\n        if (successful) {\n            return;\n        }\n    }\n    state.needsSeperator = false;\n    state.step++;\n    while (state.rule &&\n        !(Array.isArray(state.rule) && state.step < state.rule.length)) {\n        popRule(state);\n        if (state.rule) {\n            if (isList(state)) {\n                if (state.rule && state.rule[state.step].separator) {\n                    state.needsSeperator = !state.needsSeperator;\n                }\n            }\n            else {\n                state.needsSeperator = false;\n                state.step++;\n            }\n        }\n    }\n}\nfunction isList(state) {\n    var step = Array.isArray(state.rule) &&\n        typeof state.rule[state.step] !== 'string' &&\n        state.rule[state.step];\n    return step && step.isList;\n}\nfunction unsuccessful(state) {\n    while (state.rule &&\n        !(Array.isArray(state.rule) && state.rule[state.step].ofRule)) {\n        popRule(state);\n    }\n    if (state.rule) {\n        advanceRule(state, false);\n    }\n}\nfunction lex(lexRules, stream) {\n    var kinds = Object.keys(lexRules);\n    for (var i = 0; i < kinds.length; i++) {\n        var match = stream.match(lexRules[kinds[i]]);\n        if (match && match instanceof Array) {\n            return { kind: kinds[i], value: match[0] };\n        }\n    }\n}\n//# sourceMappingURL=onlineParser.js.map","\"use strict\";\nvar __assign = (this && this.__assign) || function () {\n    __assign = Object.assign || function(t) {\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\n            s = arguments[i];\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))\n                t[p] = s[p];\n        }\n        return t;\n    };\n    return __assign.apply(this, arguments);\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar graphql_1 = require(\"graphql\");\nexports.AdditionalRuleKinds = {\n    ALIASED_FIELD: 'AliasedField',\n    ARGUMENTS: 'Arguments',\n    SHORT_QUERY: 'ShortQuery',\n    QUERY: 'Query',\n    MUTATION: 'Mutation',\n    SUBSCRIPTION: 'Subscription',\n    TYPE_CONDITION: 'TypeCondition',\n    INVALID: 'Invalid',\n    COMMENT: 'Comment',\n    SCHEMA_DEF: 'SchemaDef',\n    SCALAR_DEF: 'ScalarDef',\n    OBJECT_TYPE_DEF: 'ObjectTypeDef',\n    OBJECT_VALUE: 'ObjectValue',\n    LIST_VALUE: 'ListValue',\n    INTERFACE_DEF: 'InterfaceDef',\n    UNION_DEF: 'UnionDef',\n    ENUM_DEF: 'EnumDef',\n    ENUM_VALUE: 'EnumValue',\n    FIELD_DEF: 'FieldDef',\n    INPUT_DEF: 'InputDef',\n    INPUT_VALUE_DEF: 'InputValueDef',\n    ARGUMENTS_DEF: 'ArgumentsDef',\n    EXTEND_DEF: 'ExtendDef',\n    DIRECTIVE_DEF: 'DirectiveDef',\n};\nexports.RuleKinds = __assign(__assign({}, graphql_1.Kind), exports.AdditionalRuleKinds);\n//# sourceMappingURL=types.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar graphql_1 = require(\"graphql\");\nfunction getASTNodeAtPosition(query, ast, point) {\n    var offset = pointToOffset(query, point);\n    var nodeContainingPosition;\n    graphql_1.visit(ast, {\n        enter: function (node) {\n            if (node.kind !== 'Name' &&\n                node.loc &&\n                node.loc.start <= offset &&\n                offset <= node.loc.end) {\n                nodeContainingPosition = node;\n            }\n            else {\n                return false;\n            }\n        },\n        leave: function (node) {\n            if (node.loc && node.loc.start <= offset && offset <= node.loc.end) {\n                return false;\n            }\n        },\n    });\n    return nodeContainingPosition;\n}\nexports.getASTNodeAtPosition = getASTNodeAtPosition;\nfunction pointToOffset(text, point) {\n    var linesUntilPosition = text.split('\\n').slice(0, point.line);\n    return (point.character +\n        linesUntilPosition\n            .map(function (line) { return line.length + 1; })\n            .reduce(function (a, b) { return a + b; }, 0));\n}\nexports.pointToOffset = pointToOffset;\n//# sourceMappingURL=getASTNodeAtPosition.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar Range = (function () {\n    function Range(start, end) {\n        var _this = this;\n        this.containsPosition = function (position) {\n            if (_this.start.line === position.line) {\n                return _this.start.character <= position.character;\n            }\n            else if (_this.end.line === position.line) {\n                return _this.end.character >= position.character;\n            }\n            else {\n                return _this.start.line <= position.line && _this.end.line >= position.line;\n            }\n        };\n        this.start = start;\n        this.end = end;\n    }\n    Range.prototype.setStart = function (line, character) {\n        this.start = new Position(line, character);\n    };\n    Range.prototype.setEnd = function (line, character) {\n        this.end = new Position(line, character);\n    };\n    return Range;\n}());\nexports.Range = Range;\nvar Position = (function () {\n    function Position(line, character) {\n        var _this = this;\n        this.lessThanOrEqualTo = function (position) {\n            return _this.line < position.line ||\n                (_this.line === position.line && _this.character <= position.character);\n        };\n        this.line = line;\n        this.character = character;\n    }\n    Position.prototype.setLine = function (line) {\n        this.line = line;\n    };\n    Position.prototype.setCharacter = function (character) {\n        this.character = character;\n    };\n    return Position;\n}());\nexports.Position = Position;\nfunction offsetToPosition(text, loc) {\n    var EOL = '\\n';\n    var buf = text.slice(0, loc);\n    var lines = buf.split(EOL).length - 1;\n    var lastLineIndex = buf.lastIndexOf(EOL);\n    return new Position(lines, loc - lastLineIndex - 1);\n}\nexports.offsetToPosition = offsetToPosition;\nfunction locToRange(text, loc) {\n    var start = offsetToPosition(text, loc.start);\n    var end = offsetToPosition(text, loc.end);\n    return new Range(start, end);\n}\nexports.locToRange = locToRange;\n//# sourceMappingURL=Range.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar graphql_1 = require(\"graphql\");\nvar ExecutableDefinitions_1 = require(\"graphql/validation/rules/ExecutableDefinitions\");\nfunction validateWithCustomRules(schema, ast, customRules, isRelayCompatMode) {\n    var rules = graphql_1.specifiedRules.filter(function (rule) {\n        if (rule === graphql_1.NoUnusedFragmentsRule || rule === ExecutableDefinitions_1.ExecutableDefinitions) {\n            return false;\n        }\n        if (isRelayCompatMode && rule === graphql_1.KnownFragmentNamesRule) {\n            return false;\n        }\n        return true;\n    });\n    if (customRules) {\n        Array.prototype.push.apply(rules, customRules);\n    }\n    var errors = graphql_1.validate(schema, ast, rules);\n    return errors.filter(function (error) {\n        if (error.message.indexOf('Unknown directive') !== -1 && error.nodes) {\n            var node = error.nodes[0];\n            if (node && node.kind === graphql_1.Kind.DIRECTIVE) {\n                var name_1 = node.name.value;\n                if (name_1 === 'arguments' || name_1 === 'argumentDefinitions') {\n                    return false;\n                }\n            }\n        }\n        return true;\n    });\n}\nexports.validateWithCustomRules = validateWithCustomRules;\n//# sourceMappingURL=validateWithCustomRules.js.map","\"use strict\";\nvar __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n    return new (P || (P = Promise))(function (resolve, reject) {\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\n    });\n};\nvar __generator = (this && this.__generator) || function (thisArg, body) {\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\n    function verb(n) { return function (v) { return step([n, v]); }; }\n    function step(op) {\n        if (f) throw new TypeError(\"Generator is already executing.\");\n        while (_) try {\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\n            if (y = 0, t) op = [op[0] & 2, t.value];\n            switch (op[0]) {\n                case 0: case 1: t = op; break;\n                case 4: _.label++; return { value: op[1], done: false };\n                case 5: _.label++; y = op[1]; op = [0]; continue;\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\n                default:\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\n                    if (t[2]) _.ops.pop();\n                    _.trys.pop(); continue;\n            }\n            op = body.call(thisArg, _);\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\n    }\n};\nvar _a;\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar vscode_languageserver_types_1 = require(\"vscode-languageserver-types\");\nvar graphql_1 = require(\"graphql\");\nvar getAutocompleteSuggestions_1 = require(\"./getAutocompleteSuggestions\");\nvar getHoverInformation_1 = require(\"./getHoverInformation\");\nvar getDiagnostics_1 = require(\"./getDiagnostics\");\nvar getDefinition_1 = require(\"./getDefinition\");\nvar getOutline_1 = require(\"./getOutline\");\nvar graphql_language_service_utils_1 = require(\"graphql-language-service-utils\");\nvar FRAGMENT_DEFINITION = graphql_1.Kind.FRAGMENT_DEFINITION, OBJECT_TYPE_DEFINITION = graphql_1.Kind.OBJECT_TYPE_DEFINITION, INTERFACE_TYPE_DEFINITION = graphql_1.Kind.INTERFACE_TYPE_DEFINITION, ENUM_TYPE_DEFINITION = graphql_1.Kind.ENUM_TYPE_DEFINITION, UNION_TYPE_DEFINITION = graphql_1.Kind.UNION_TYPE_DEFINITION, SCALAR_TYPE_DEFINITION = graphql_1.Kind.SCALAR_TYPE_DEFINITION, INPUT_OBJECT_TYPE_DEFINITION = graphql_1.Kind.INPUT_OBJECT_TYPE_DEFINITION, SCALAR_TYPE_EXTENSION = graphql_1.Kind.SCALAR_TYPE_EXTENSION, OBJECT_TYPE_EXTENSION = graphql_1.Kind.OBJECT_TYPE_EXTENSION, INTERFACE_TYPE_EXTENSION = graphql_1.Kind.INTERFACE_TYPE_EXTENSION, UNION_TYPE_EXTENSION = graphql_1.Kind.UNION_TYPE_EXTENSION, ENUM_TYPE_EXTENSION = graphql_1.Kind.ENUM_TYPE_EXTENSION, INPUT_OBJECT_TYPE_EXTENSION = graphql_1.Kind.INPUT_OBJECT_TYPE_EXTENSION, DIRECTIVE_DEFINITION = graphql_1.Kind.DIRECTIVE_DEFINITION, FRAGMENT_SPREAD = graphql_1.Kind.FRAGMENT_SPREAD, OPERATION_DEFINITION = graphql_1.Kind.OPERATION_DEFINITION, NAMED_TYPE = graphql_1.Kind.NAMED_TYPE;\nvar KIND_TO_SYMBOL_KIND = (_a = {},\n    _a[graphql_1.Kind.FIELD] = vscode_languageserver_types_1.SymbolKind.Field,\n    _a[graphql_1.Kind.OPERATION_DEFINITION] = vscode_languageserver_types_1.SymbolKind.Class,\n    _a[graphql_1.Kind.FRAGMENT_DEFINITION] = vscode_languageserver_types_1.SymbolKind.Class,\n    _a[graphql_1.Kind.FRAGMENT_SPREAD] = vscode_languageserver_types_1.SymbolKind.Struct,\n    _a[graphql_1.Kind.OBJECT_TYPE_DEFINITION] = vscode_languageserver_types_1.SymbolKind.Class,\n    _a[graphql_1.Kind.ENUM_TYPE_DEFINITION] = vscode_languageserver_types_1.SymbolKind.Enum,\n    _a[graphql_1.Kind.ENUM_VALUE_DEFINITION] = vscode_languageserver_types_1.SymbolKind.EnumMember,\n    _a[graphql_1.Kind.INPUT_OBJECT_TYPE_DEFINITION] = vscode_languageserver_types_1.SymbolKind.Class,\n    _a[graphql_1.Kind.INPUT_VALUE_DEFINITION] = vscode_languageserver_types_1.SymbolKind.Field,\n    _a[graphql_1.Kind.FIELD_DEFINITION] = vscode_languageserver_types_1.SymbolKind.Field,\n    _a[graphql_1.Kind.INTERFACE_TYPE_DEFINITION] = vscode_languageserver_types_1.SymbolKind.Interface,\n    _a[graphql_1.Kind.DOCUMENT] = vscode_languageserver_types_1.SymbolKind.File,\n    _a.FieldWithArguments = vscode_languageserver_types_1.SymbolKind.Method,\n    _a);\nfunction getKind(tree) {\n    if (tree.kind === 'FieldDefinition' &&\n        tree.children &&\n        tree.children.length > 0) {\n        return KIND_TO_SYMBOL_KIND.FieldWithArguments;\n    }\n    return KIND_TO_SYMBOL_KIND[tree.kind];\n}\nvar GraphQLLanguageService = (function () {\n    function GraphQLLanguageService(cache) {\n        this._graphQLCache = cache;\n        this._graphQLConfig = cache.getGraphQLConfig();\n    }\n    GraphQLLanguageService.prototype.getConfigForURI = function (uri) {\n        var config = this._graphQLConfig.getProjectForFile(uri);\n        if (config) {\n            return config;\n        }\n        throw Error(\"No config found for uri: \" + uri);\n    };\n    GraphQLLanguageService.prototype.getDiagnostics = function (query, uri, isRelayCompatMode) {\n        return __awaiter(this, void 0, void 0, function () {\n            var queryHasExtensions, projectConfig, schemaPath, projectName, extensions, queryAST, range, source, fragmentDefinitions, fragmentDependencies, dependenciesSource, validationAst, customRules, customValidationRules, schema;\n            return __generator(this, function (_a) {\n                switch (_a.label) {\n                    case 0:\n                        queryHasExtensions = false;\n                        projectConfig = this.getConfigForURI(uri);\n                        if (!projectConfig) {\n                            return [2, []];\n                        }\n                        schemaPath = projectConfig.schema, projectName = projectConfig.name, extensions = projectConfig.extensions;\n                        try {\n                            queryAST = graphql_1.parse(query);\n                            if (!schemaPath || uri !== schemaPath) {\n                                queryHasExtensions = queryAST.definitions.some(function (definition) {\n                                    switch (definition.kind) {\n                                        case OBJECT_TYPE_DEFINITION:\n                                        case INTERFACE_TYPE_DEFINITION:\n                                        case ENUM_TYPE_DEFINITION:\n                                        case UNION_TYPE_DEFINITION:\n                                        case SCALAR_TYPE_DEFINITION:\n                                        case INPUT_OBJECT_TYPE_DEFINITION:\n                                        case SCALAR_TYPE_EXTENSION:\n                                        case OBJECT_TYPE_EXTENSION:\n                                        case INTERFACE_TYPE_EXTENSION:\n                                        case UNION_TYPE_EXTENSION:\n                                        case ENUM_TYPE_EXTENSION:\n                                        case INPUT_OBJECT_TYPE_EXTENSION:\n                                        case DIRECTIVE_DEFINITION:\n                                            return true;\n                                    }\n                                    return false;\n                                });\n                            }\n                        }\n                        catch (error) {\n                            range = getDiagnostics_1.getRange(error.locations[0], query);\n                            return [2, [\n                                    {\n                                        severity: getDiagnostics_1.DIAGNOSTIC_SEVERITY.Error,\n                                        message: error.message,\n                                        source: 'GraphQL: Syntax',\n                                        range: range,\n                                    },\n                                ]];\n                        }\n                        source = query;\n                        return [4, this._graphQLCache.getFragmentDefinitions(projectConfig)];\n                    case 1:\n                        fragmentDefinitions = _a.sent();\n                        return [4, this._graphQLCache.getFragmentDependencies(query, fragmentDefinitions)];\n                    case 2:\n                        fragmentDependencies = _a.sent();\n                        dependenciesSource = fragmentDependencies.reduce(function (prev, cur) { return prev + \" \" + graphql_1.print(cur.definition); }, '');\n                        source = source + \" \" + dependenciesSource;\n                        validationAst = null;\n                        try {\n                            validationAst = graphql_1.parse(source);\n                        }\n                        catch (error) {\n                            return [2, []];\n                        }\n                        customRules = null;\n                        customValidationRules = extensions.customValidationRules;\n                        if (customValidationRules) {\n                            customRules = customValidationRules(this._graphQLConfig);\n                        }\n                        return [4, this._graphQLCache.getSchema(projectName, queryHasExtensions)];\n                    case 3:\n                        schema = _a.sent();\n                        if (!schema) {\n                            return [2, []];\n                        }\n                        return [2, getDiagnostics_1.validateQuery(validationAst, schema, customRules, isRelayCompatMode)];\n                }\n            });\n        });\n    };\n    GraphQLLanguageService.prototype.getAutocompleteSuggestions = function (query, position, filePath) {\n        return __awaiter(this, void 0, void 0, function () {\n            var projectConfig, schema;\n            return __generator(this, function (_a) {\n                switch (_a.label) {\n                    case 0:\n                        projectConfig = this.getConfigForURI(filePath);\n                        return [4, this._graphQLCache.getSchema(projectConfig.name)];\n                    case 1:\n                        schema = _a.sent();\n                        if (schema) {\n                            return [2, getAutocompleteSuggestions_1.getAutocompleteSuggestions(schema, query, position)];\n                        }\n                        return [2, []];\n                }\n            });\n        });\n    };\n    GraphQLLanguageService.prototype.getHoverInformation = function (query, position, filePath) {\n        return __awaiter(this, void 0, void 0, function () {\n            var projectConfig, schema;\n            return __generator(this, function (_a) {\n                switch (_a.label) {\n                    case 0:\n                        projectConfig = this.getConfigForURI(filePath);\n                        return [4, this._graphQLCache.getSchema(projectConfig.name)];\n                    case 1:\n                        schema = _a.sent();\n                        if (schema) {\n                            return [2, getHoverInformation_1.getHoverInformation(schema, query, position)];\n                        }\n                        return [2, ''];\n                }\n            });\n        });\n    };\n    GraphQLLanguageService.prototype.getDefinition = function (query, position, filePath) {\n        return __awaiter(this, void 0, void 0, function () {\n            var projectConfig, ast, node;\n            return __generator(this, function (_a) {\n                projectConfig = this.getConfigForURI(filePath);\n                try {\n                    ast = graphql_1.parse(query);\n                }\n                catch (error) {\n                    return [2, null];\n                }\n                node = graphql_language_service_utils_1.getASTNodeAtPosition(query, ast, position);\n                if (node) {\n                    switch (node.kind) {\n                        case FRAGMENT_SPREAD:\n                            return [2, this._getDefinitionForFragmentSpread(query, ast, node, filePath, projectConfig)];\n                        case FRAGMENT_DEFINITION:\n                        case OPERATION_DEFINITION:\n                            return [2, getDefinition_1.getDefinitionQueryResultForDefinitionNode(filePath, query, node)];\n                        case NAMED_TYPE:\n                            return [2, this._getDefinitionForNamedType(query, ast, node, filePath, projectConfig)];\n                    }\n                }\n                return [2, null];\n            });\n        });\n    };\n    GraphQLLanguageService.prototype.getDocumentSymbols = function (document, filePath) {\n        return __awaiter(this, void 0, void 0, function () {\n            var outline, output, input, _loop_1, state_1;\n            return __generator(this, function (_a) {\n                switch (_a.label) {\n                    case 0: return [4, this.getOutline(document)];\n                    case 1:\n                        outline = _a.sent();\n                        if (!outline) {\n                            return [2, []];\n                        }\n                        output = [];\n                        input = outline.outlineTrees.map(function (tree) { return [null, tree]; });\n                        _loop_1 = function () {\n                            var res = input.pop();\n                            if (!res) {\n                                return { value: [] };\n                            }\n                            var parent_1 = res[0], tree = res[1];\n                            if (!tree) {\n                                return { value: [] };\n                            }\n                            output.push({\n                                name: tree.representativeName,\n                                kind: getKind(tree),\n                                location: {\n                                    uri: filePath,\n                                    range: {\n                                        start: tree.startPosition,\n                                        end: tree.endPosition,\n                                    },\n                                },\n                                containerName: parent_1 ? parent_1.representativeName : undefined,\n                            });\n                            input.push.apply(input, tree.children.map(function (child) { return [tree, child]; }));\n                        };\n                        while (input.length > 0) {\n                            state_1 = _loop_1();\n                            if (typeof state_1 === \"object\")\n                                return [2, state_1.value];\n                        }\n                        return [2, output];\n                }\n            });\n        });\n    };\n    GraphQLLanguageService.prototype._getDefinitionForNamedType = function (query, ast, node, filePath, projectConfig) {\n        return __awaiter(this, void 0, void 0, function () {\n            var objectTypeDefinitions, dependencies, localObjectTypeDefinitions, typeCastedDefs, localOperationDefinationInfos, result;\n            return __generator(this, function (_a) {\n                switch (_a.label) {\n                    case 0: return [4, this._graphQLCache.getObjectTypeDefinitions(projectConfig)];\n                    case 1:\n                        objectTypeDefinitions = _a.sent();\n                        return [4, this._graphQLCache.getObjectTypeDependenciesForAST(ast, objectTypeDefinitions)];\n                    case 2:\n                        dependencies = _a.sent();\n                        localObjectTypeDefinitions = ast.definitions.filter(function (definition) {\n                            return definition.kind === OBJECT_TYPE_DEFINITION ||\n                                definition.kind === INPUT_OBJECT_TYPE_DEFINITION ||\n                                definition.kind === ENUM_TYPE_DEFINITION ||\n                                definition.kind === SCALAR_TYPE_DEFINITION ||\n                                definition.kind === INTERFACE_TYPE_DEFINITION;\n                        });\n                        typeCastedDefs = localObjectTypeDefinitions;\n                        localOperationDefinationInfos = typeCastedDefs.map(function (definition) { return ({\n                            filePath: filePath,\n                            content: query,\n                            definition: definition,\n                        }); });\n                        return [4, getDefinition_1.getDefinitionQueryResultForNamedType(query, node, dependencies.concat(localOperationDefinationInfos))];\n                    case 3:\n                        result = _a.sent();\n                        return [2, result];\n                }\n            });\n        });\n    };\n    GraphQLLanguageService.prototype._getDefinitionForFragmentSpread = function (query, ast, node, filePath, projectConfig) {\n        return __awaiter(this, void 0, void 0, function () {\n            var fragmentDefinitions, dependencies, localFragDefinitions, typeCastedDefs, localFragInfos, result;\n            return __generator(this, function (_a) {\n                switch (_a.label) {\n                    case 0: return [4, this._graphQLCache.getFragmentDefinitions(projectConfig)];\n                    case 1:\n                        fragmentDefinitions = _a.sent();\n                        return [4, this._graphQLCache.getFragmentDependenciesForAST(ast, fragmentDefinitions)];\n                    case 2:\n                        dependencies = _a.sent();\n                        localFragDefinitions = ast.definitions.filter(function (definition) { return definition.kind === FRAGMENT_DEFINITION; });\n                        typeCastedDefs = localFragDefinitions;\n                        localFragInfos = typeCastedDefs.map(function (definition) { return ({\n                            filePath: filePath,\n                            content: query,\n                            definition: definition,\n                        }); });\n                        return [4, getDefinition_1.getDefinitionQueryResultForFragmentSpread(query, node, dependencies.concat(localFragInfos))];\n                    case 3:\n                        result = _a.sent();\n                        return [2, result];\n                }\n            });\n        });\n    };\n    GraphQLLanguageService.prototype.getOutline = function (documentText) {\n        return __awaiter(this, void 0, void 0, function () {\n            return __generator(this, function (_a) {\n                return [2, getOutline_1.getOutline(documentText)];\n            });\n        });\n    };\n    return GraphQLLanguageService;\n}());\nexports.GraphQLLanguageService = GraphQLLanguageService;\n//# sourceMappingURL=GraphQLLanguageService.js.map","\"use strict\";\n\nvar _codemirror = _interopRequireDefault(require(\"codemirror\"));\n\nvar _graphqlLanguageServiceInterface = require(\"graphql-language-service-interface\");\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\n/**\n *  Copyright (c) 2019 GraphQL Contributors\n *  All rights reserved.\n *\n *  This source code is licensed under the BSD-style license found in the\n *  LICENSE file in the root directory of this source tree. An additional grant\n *  of patent rights can be found in the PATENTS file in the same directory.\n */\nconst SEVERITY = ['error', 'warning', 'information', 'hint'];\nconst TYPE = {\n  'GraphQL: Validation': 'validation',\n  'GraphQL: Deprecation': 'deprecation',\n  'GraphQL: Syntax': 'syntax'\n};\n/**\n * Registers a \"lint\" helper for CodeMirror.\n *\n * Using CodeMirror's \"lint\" addon: https://codemirror.net/demo/lint.html\n * Given the text within an editor, this helper will take that text and return\n * a list of linter issues, derived from GraphQL's parse and validate steps.\n * Also, this uses `graphql-language-service-parser` to power the diagnostics\n * service.\n *\n * Options:\n *\n *   - schema: GraphQLSchema provides the linter with positionally relevant info\n *\n */\n\n_codemirror.default.registerHelper('lint', 'graphql', (text, options) => {\n  const schema = options.schema;\n  const rawResults = (0, _graphqlLanguageServiceInterface.getDiagnostics)(text, schema);\n  const results = rawResults.map(error => ({\n    message: error.message,\n    severity: SEVERITY[error.severity - 1],\n    type: TYPE[error.source],\n    from: _codemirror.default.Pos(error.range.start.line, error.range.start.character),\n    to: _codemirror.default.Pos(error.range.end.line, error.range.end.character)\n  }));\n  return results;\n});","\"use strict\";\n\nvar _graphql = require(\"graphql\");\n\nvar _codemirror = _interopRequireDefault(require(\"codemirror\"));\n\nvar _getTypeInfo = _interopRequireDefault(require(\"./utils/getTypeInfo\"));\n\nvar _SchemaReference = require(\"./utils/SchemaReference\");\n\nrequire(\"./utils/info-addon\");\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\n/**\n *  Copyright (c) 2019 GraphQL Contributors\n *  All rights reserved.\n *\n *  This source code is licensed under the BSD-style license found in the\n *  LICENSE file in the root directory of this source tree. An additional grant\n *  of patent rights can be found in the PATENTS file in the same directory.\n */\n\n/**\n * Registers GraphQL \"info\" tooltips for CodeMirror.\n *\n * When hovering over a token, this presents a tooltip explaining it.\n *\n * Options:\n *\n *   - schema: GraphQLSchema provides positionally relevant info.\n *   - hoverTime: The number of ms to wait before showing info. (Default 500)\n *   - renderDescription: Convert a description to some HTML, Useful since\n *                        descriptions are often Markdown formatted.\n *   - onClick: A function called when a named thing is clicked.\n *\n */\n_codemirror.default.registerHelper('info', 'graphql', (token, options) => {\n  if (!options.schema || !token.state) {\n    return;\n  }\n\n  const state = token.state;\n  const kind = state.kind;\n  const step = state.step;\n  const typeInfo = (0, _getTypeInfo.default)(options.schema, token.state); // Given a Schema and a Token, produce the contents of an info tooltip.\n  // To do this, create a div element that we will render \"into\" and then pass\n  // it to various rendering functions.\n\n  if (kind === 'Field' && step === 0 && typeInfo.fieldDef || kind === 'AliasedField' && step === 2 && typeInfo.fieldDef) {\n    const into = document.createElement('div');\n    renderField(into, typeInfo, options);\n    renderDescription(into, options, typeInfo.fieldDef);\n    return into;\n  } else if (kind === 'Directive' && step === 1 && typeInfo.directiveDef) {\n    const into = document.createElement('div');\n    renderDirective(into, typeInfo, options);\n    renderDescription(into, options, typeInfo.directiveDef);\n    return into;\n  } else if (kind === 'Argument' && step === 0 && typeInfo.argDef) {\n    const into = document.createElement('div');\n    renderArg(into, typeInfo, options);\n    renderDescription(into, options, typeInfo.argDef);\n    return into;\n  } else if (kind === 'EnumValue' && typeInfo.enumValue && typeInfo.enumValue.description) {\n    const into = document.createElement('div');\n    renderEnumValue(into, typeInfo, options);\n    renderDescription(into, options, typeInfo.enumValue);\n    return into;\n  } else if (kind === 'NamedType' && typeInfo.type && typeInfo.type.description) {\n    const into = document.createElement('div');\n    renderType(into, typeInfo, options, typeInfo.type);\n    renderDescription(into, options, typeInfo.type);\n    return into;\n  }\n});\n\nfunction renderField(into, typeInfo, options) {\n  renderQualifiedField(into, typeInfo, options);\n  renderTypeAnnotation(into, typeInfo, options, typeInfo.type);\n}\n\nfunction renderQualifiedField(into, typeInfo, options) {\n  const fieldName = typeInfo.fieldDef.name;\n\n  if (fieldName.slice(0, 2) !== '__') {\n    renderType(into, typeInfo, options, typeInfo.parentType);\n    text(into, '.');\n  }\n\n  text(into, fieldName, 'field-name', options, (0, _SchemaReference.getFieldReference)(typeInfo));\n}\n\nfunction renderDirective(into, typeInfo, options) {\n  const name = '@' + typeInfo.directiveDef.name;\n  text(into, name, 'directive-name', options, (0, _SchemaReference.getDirectiveReference)(typeInfo));\n}\n\nfunction renderArg(into, typeInfo, options) {\n  if (typeInfo.directiveDef) {\n    renderDirective(into, typeInfo, options);\n  } else if (typeInfo.fieldDef) {\n    renderQualifiedField(into, typeInfo, options);\n  }\n\n  const name = typeInfo.argDef.name;\n  text(into, '(');\n  text(into, name, 'arg-name', options, (0, _SchemaReference.getArgumentReference)(typeInfo));\n  renderTypeAnnotation(into, typeInfo, options, typeInfo.inputType);\n  text(into, ')');\n}\n\nfunction renderTypeAnnotation(into, typeInfo, options, t) {\n  text(into, ': ');\n  renderType(into, typeInfo, options, t);\n}\n\nfunction renderEnumValue(into, typeInfo, options) {\n  const name = typeInfo.enumValue.name;\n  renderType(into, typeInfo, options, typeInfo.inputType);\n  text(into, '.');\n  text(into, name, 'enum-value', options, (0, _SchemaReference.getEnumValueReference)(typeInfo));\n}\n\nfunction renderType(into, typeInfo, options, t) {\n  if (t instanceof _graphql.GraphQLNonNull) {\n    renderType(into, typeInfo, options, t.ofType);\n    text(into, '!');\n  } else if (t instanceof _graphql.GraphQLList) {\n    text(into, '[');\n    renderType(into, typeInfo, options, t.ofType);\n    text(into, ']');\n  } else {\n    text(into, t.name, 'type-name', options, (0, _SchemaReference.getTypeReference)(typeInfo, t));\n  }\n}\n\nfunction renderDescription(into, options, def) {\n  const description = def.description;\n\n  if (description) {\n    const descriptionDiv = document.createElement('div');\n    descriptionDiv.className = 'info-description';\n\n    if (options.renderDescription) {\n      descriptionDiv.innerHTML = options.renderDescription(description);\n    } else {\n      descriptionDiv.appendChild(document.createTextNode(description));\n    }\n\n    into.appendChild(descriptionDiv);\n  }\n\n  renderDeprecation(into, options, def);\n}\n\nfunction renderDeprecation(into, options, def) {\n  const reason = def.deprecationReason;\n\n  if (reason) {\n    const deprecationDiv = document.createElement('div');\n    deprecationDiv.className = 'info-deprecation';\n\n    if (options.renderDescription) {\n      deprecationDiv.innerHTML = options.renderDescription(reason);\n    } else {\n      deprecationDiv.appendChild(document.createTextNode(reason));\n    }\n\n    const label = document.createElement('span');\n    label.className = 'info-deprecation-label';\n    label.appendChild(document.createTextNode('Deprecated: '));\n    deprecationDiv.insertBefore(label, deprecationDiv.firstChild);\n    into.appendChild(deprecationDiv);\n  }\n}\n\nfunction text(into, content, className, options = {\n  onClick: null\n}, ref) {\n  if (className) {\n    const onClick = options.onClick;\n    let node;\n\n    if (onClick) {\n      node = document.createElement('a'); // Providing a href forces proper a tag behavior, though we don't actually\n      // want clicking the node to navigate anywhere.\n\n      node.href = 'javascript:void 0'; // eslint-disable-line no-script-url\n\n      node.addEventListener('click', e => {\n        onClick(ref, e);\n      });\n    } else {\n      node = document.createElement('span');\n    }\n\n    node.className = className;\n    node.appendChild(document.createTextNode(content));\n    into.appendChild(node);\n  } else {\n    into.appendChild(document.createTextNode(content));\n  }\n}","\"use strict\";\n\nvar _codemirror = _interopRequireDefault(require(\"codemirror\"));\n\nvar _getTypeInfo = _interopRequireDefault(require(\"./utils/getTypeInfo\"));\n\nvar _SchemaReference = require(\"./utils/SchemaReference\");\n\nrequire(\"./utils/jump-addon\");\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\n/**\n *  Copyright (c) 2019 GraphQL Contributors\n *  All rights reserved.\n *\n *  This source code is licensed under the BSD-style license found in the\n *  LICENSE file in the root directory of this source tree. An additional grant\n *  of patent rights can be found in the PATENTS file in the same directory.\n *\n * \n *\n */\n\n/**\n * Registers GraphQL \"jump\" links for CodeMirror.\n *\n * When command-hovering over a token, this converts it to a link, which when\n * pressed will call the provided onClick handler.\n *\n * Options:\n *\n *   - schema: GraphQLSchema provides positionally relevant info.\n *   - onClick: A function called when a named thing is clicked.\n *\n */\n_codemirror.default.registerHelper('jump', 'graphql', (token, options) => {\n  if (!options.schema || !options.onClick || !token.state) {\n    return;\n  } // Given a Schema and a Token, produce a \"SchemaReference\" which refers to\n  // the particular artifact from the schema (such as a type, field, argument,\n  // or directive) that token references.\n\n\n  const state = token.state;\n  const kind = state.kind;\n  const step = state.step;\n  const typeInfo = (0, _getTypeInfo.default)(options.schema, state);\n\n  if (kind === 'Field' && step === 0 && typeInfo.fieldDef || kind === 'AliasedField' && step === 2 && typeInfo.fieldDef) {\n    return (0, _SchemaReference.getFieldReference)(typeInfo);\n  } else if (kind === 'Directive' && step === 1 && typeInfo.directiveDef) {\n    return (0, _SchemaReference.getDirectiveReference)(typeInfo);\n  } else if (kind === 'Argument' && step === 0 && typeInfo.argDef) {\n    return (0, _SchemaReference.getArgumentReference)(typeInfo);\n  } else if (kind === 'EnumValue' && typeInfo.enumValue) {\n    return (0, _SchemaReference.getEnumValueReference)(typeInfo);\n  } else if (kind === 'NamedType' && typeInfo.type) {\n    return (0, _SchemaReference.getTypeReference)(typeInfo);\n  }\n});","\"use strict\";\n\nvar _codemirror = _interopRequireDefault(require(\"codemirror\"));\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\n/**\n *  Copyright (c) 2019 GraphQL Contributors\n *  All rights reserved.\n *\n *  This source code is licensed under the BSD-style license found in the\n *  LICENSE file in the root directory of this source tree. An additional grant\n *  of patent rights can be found in the PATENTS file in the same directory.\n */\n_codemirror.default.defineOption('jump', false, (cm, options, old) => {\n  if (old && old !== _codemirror.default.Init) {\n    const oldOnMouseOver = cm.state.jump.onMouseOver;\n\n    _codemirror.default.off(cm.getWrapperElement(), 'mouseover', oldOnMouseOver);\n\n    const oldOnMouseOut = cm.state.jump.onMouseOut;\n\n    _codemirror.default.off(cm.getWrapperElement(), 'mouseout', oldOnMouseOut);\n\n    _codemirror.default.off(document, 'keydown', cm.state.jump.onKeyDown);\n\n    delete cm.state.jump;\n  }\n\n  if (options) {\n    const state = cm.state.jump = {\n      options,\n      onMouseOver: onMouseOver.bind(null, cm),\n      onMouseOut: onMouseOut.bind(null, cm),\n      onKeyDown: onKeyDown.bind(null, cm)\n    };\n\n    _codemirror.default.on(cm.getWrapperElement(), 'mouseover', state.onMouseOver);\n\n    _codemirror.default.on(cm.getWrapperElement(), 'mouseout', state.onMouseOut);\n\n    _codemirror.default.on(document, 'keydown', state.onKeyDown);\n  }\n});\n\nfunction onMouseOver(cm, event) {\n  const target = event.target || event.srcElement;\n\n  if (target.nodeName !== 'SPAN') {\n    return;\n  }\n\n  const box = target.getBoundingClientRect();\n  const cursor = {\n    left: (box.left + box.right) / 2,\n    top: (box.top + box.bottom) / 2\n  };\n  cm.state.jump.cursor = cursor;\n\n  if (cm.state.jump.isHoldingModifier) {\n    enableJumpMode(cm);\n  }\n}\n\nfunction onMouseOut(cm) {\n  if (!cm.state.jump.isHoldingModifier && cm.state.jump.cursor) {\n    cm.state.jump.cursor = null;\n    return;\n  }\n\n  if (cm.state.jump.isHoldingModifier && cm.state.jump.marker) {\n    disableJumpMode(cm);\n  }\n}\n\nfunction onKeyDown(cm, event) {\n  if (cm.state.jump.isHoldingModifier || !isJumpModifier(event.key)) {\n    return;\n  }\n\n  cm.state.jump.isHoldingModifier = true;\n\n  if (cm.state.jump.cursor) {\n    enableJumpMode(cm);\n  }\n\n  const onKeyUp = upEvent => {\n    if (upEvent.code !== event.code) {\n      return;\n    }\n\n    cm.state.jump.isHoldingModifier = false;\n\n    if (cm.state.jump.marker) {\n      disableJumpMode(cm);\n    }\n\n    _codemirror.default.off(document, 'keyup', onKeyUp);\n\n    _codemirror.default.off(document, 'click', onClick);\n\n    cm.off('mousedown', onMouseDown);\n  };\n\n  const onClick = clickEvent => {\n    const destination = cm.state.jump.destination;\n\n    if (destination) {\n      cm.state.jump.options.onClick(destination, clickEvent);\n    }\n  };\n\n  const onMouseDown = (_, downEvent) => {\n    if (cm.state.jump.destination) {\n      downEvent.codemirrorIgnore = true;\n    }\n  };\n\n  _codemirror.default.on(document, 'keyup', onKeyUp);\n\n  _codemirror.default.on(document, 'click', onClick);\n\n  cm.on('mousedown', onMouseDown);\n}\n\nconst isMac = typeof navigator !== 'undefined' && navigator && navigator.appVersion.indexOf('Mac') !== -1;\n\nfunction isJumpModifier(key) {\n  return key === (isMac ? 'Meta' : 'Control');\n}\n\nfunction enableJumpMode(cm) {\n  if (cm.state.jump.marker) {\n    return;\n  }\n\n  const cursor = cm.state.jump.cursor;\n  const pos = cm.coordsChar(cursor);\n  const token = cm.getTokenAt(pos, true);\n  const options = cm.state.jump.options;\n  const getDestination = options.getDestination || cm.getHelper(pos, 'jump');\n\n  if (getDestination) {\n    const destination = getDestination(token, options, cm);\n\n    if (destination) {\n      const marker = cm.markText({\n        line: pos.line,\n        ch: token.start\n      }, {\n        line: pos.line,\n        ch: token.end\n      }, {\n        className: 'CodeMirror-jump-token'\n      });\n      cm.state.jump.marker = marker;\n      cm.state.jump.destination = destination;\n    }\n  }\n}\n\nfunction disableJumpMode(cm) {\n  const marker = cm.state.jump.marker;\n  cm.state.jump.marker = null;\n  cm.state.jump.destination = null;\n  marker.clear();\n}","\"use strict\";\n\nvar _codemirror = _interopRequireDefault(require(\"codemirror\"));\n\nvar _graphqlLanguageServiceParser = require(\"graphql-language-service-parser\");\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\n/**\n *  Copyright (c) 2019 GraphQL Contributors\n *  All rights reserved.\n *\n *  This source code is licensed under the BSD-style license found in the\n *  LICENSE file in the root directory of this source tree. An additional grant\n *  of patent rights can be found in the PATENTS file in the same directory.\n */\n\n/**\n * The GraphQL mode is defined as a tokenizer along with a list of rules, each\n * of which is either a function or an array.\n *\n *   * Function: Provided a token and the stream, returns an expected next step.\n *   * Array: A list of steps to take in order.\n *\n * A step is either another rule, or a terminal description of a token. If it\n * is a rule, that rule is pushed onto the stack and the parsing continues from\n * that point.\n *\n * If it is a terminal description, the token is checked against it using a\n * `match` function. If the match is successful, the token is colored and the\n * rule is stepped forward. If the match is unsuccessful, the remainder of the\n * rule is skipped and the previous rule is advanced.\n *\n * This parsing algorithm allows for incremental online parsing within various\n * levels of the syntax tree and results in a structured `state` linked-list\n * which contains the relevant information to produce valuable typeaheads.\n */\n_codemirror.default.defineMode('graphql', config => {\n  const parser = (0, _graphqlLanguageServiceParser.onlineParser)({\n    eatWhitespace: stream => stream.eatWhile(_graphqlLanguageServiceParser.isIgnored),\n    lexRules: _graphqlLanguageServiceParser.LexRules,\n    parseRules: _graphqlLanguageServiceParser.ParseRules,\n    editorConfig: {\n      tabSize: config.tabSize\n    }\n  });\n  return {\n    config,\n    startState: parser.startState,\n    token: parser.token,\n    indent,\n    electricInput: /^\\s*[})\\]]/,\n    fold: 'brace',\n    lineComment: '#',\n    closeBrackets: {\n      pairs: '()[]{}\"\"',\n      explode: '()[]{}'\n    }\n  };\n});\n\nfunction indent(state, textAfter) {\n  const levels = state.levels; // If there is no stack of levels, use the current level.\n  // Otherwise, use the top level, pre-emptively dedenting for close braces.\n\n  const level = !levels || levels.length === 0 ? state.indentLevel : levels[levels.length - 1] - (this.electricInput.test(textAfter) ? 1 : 0);\n  return level * this.config.indentUnit;\n}","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.VariableEditor = void 0;\n\nvar _react = _interopRequireDefault(require(\"react\"));\n\nvar _propTypes = _interopRequireDefault(require(\"prop-types\"));\n\nvar _onHasCompletion = _interopRequireDefault(require(\"../utility/onHasCompletion\"));\n\nvar _commonKeys = _interopRequireDefault(require(\"../utility/commonKeys\"));\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\n/**\n * VariableEditor\n *\n * An instance of CodeMirror for editing variables defined in QueryEditor.\n *\n * Props:\n *\n *   - variableToType: A mapping of variable name to GraphQLType.\n *   - value: The text of the editor.\n *   - onEdit: A function called when the editor changes, given the edited text.\n *   - readOnly: Turns the editor to read-only mode.\n *\n */\nclass VariableEditor extends _react.default.Component {\n  constructor(props) {\n    super(); // Keep a cached version of the value, this cache will be updated when the\n    // editor is updated, which can later be used to protect the editor from\n    // unnecessary updates during the update lifecycle.\n\n    _defineProperty(this, \"_onKeyUp\", (cm, event) => {\n      const code = event.keyCode;\n\n      if (code >= 65 && code <= 90 || // letters\n      !event.shiftKey && code >= 48 && code <= 57 || // numbers\n      event.shiftKey && code === 189 || // underscore\n      event.shiftKey && code === 222 // \"\n      ) {\n          this.editor.execCommand('autocomplete');\n        }\n    });\n\n    _defineProperty(this, \"_onEdit\", () => {\n      if (!this.ignoreChangeEvent) {\n        this.cachedValue = this.editor.getValue();\n\n        if (this.props.onEdit) {\n          this.props.onEdit(this.cachedValue);\n        }\n      }\n    });\n\n    _defineProperty(this, \"_onHasCompletion\", (cm, data) => {\n      (0, _onHasCompletion.default)(cm, data, this.props.onHintInformationRender);\n    });\n\n    this.cachedValue = props.value || '';\n  }\n\n  componentDidMount() {\n    // Lazily require to ensure requiring GraphiQL outside of a Browser context\n    // does not produce an error.\n    const CodeMirror = require('codemirror');\n\n    require('codemirror/addon/hint/show-hint');\n\n    require('codemirror/addon/edit/matchbrackets');\n\n    require('codemirror/addon/edit/closebrackets');\n\n    require('codemirror/addon/fold/brace-fold');\n\n    require('codemirror/addon/fold/foldgutter');\n\n    require('codemirror/addon/lint/lint');\n\n    require('codemirror/addon/search/searchcursor');\n\n    require('codemirror/addon/search/jump-to-line');\n\n    require('codemirror/addon/dialog/dialog');\n\n    require('codemirror/keymap/sublime');\n\n    require('codemirror-graphql/variables/hint');\n\n    require('codemirror-graphql/variables/lint');\n\n    require('codemirror-graphql/variables/mode');\n\n    this.editor = CodeMirror(this._node, {\n      value: this.props.value || '',\n      lineNumbers: true,\n      tabSize: 2,\n      mode: 'graphql-variables',\n      theme: this.props.editorTheme || 'graphiql',\n      keyMap: 'sublime',\n      autoCloseBrackets: true,\n      matchBrackets: true,\n      showCursorWhenSelecting: true,\n      readOnly: this.props.readOnly ? 'nocursor' : false,\n      foldGutter: {\n        minFoldSize: 4\n      },\n      lint: {\n        variableToType: this.props.variableToType\n      },\n      hintOptions: {\n        variableToType: this.props.variableToType,\n        closeOnUnfocus: false,\n        completeSingle: false,\n        container: this._node\n      },\n      gutters: ['CodeMirror-linenumbers', 'CodeMirror-foldgutter'],\n      extraKeys: {\n        'Cmd-Space': () => this.editor.showHint({\n          completeSingle: false,\n          container: this._node\n        }),\n        'Ctrl-Space': () => this.editor.showHint({\n          completeSingle: false,\n          container: this._node\n        }),\n        'Alt-Space': () => this.editor.showHint({\n          completeSingle: false,\n          container: this._node\n        }),\n        'Shift-Space': () => this.editor.showHint({\n          completeSingle: false,\n          container: this._node\n        }),\n        'Cmd-Enter': () => {\n          if (this.props.onRunQuery) {\n            this.props.onRunQuery();\n          }\n        },\n        'Ctrl-Enter': () => {\n          if (this.props.onRunQuery) {\n            this.props.onRunQuery();\n          }\n        },\n        'Shift-Ctrl-P': () => {\n          if (this.props.onPrettifyQuery) {\n            this.props.onPrettifyQuery();\n          }\n        },\n        'Shift-Ctrl-M': () => {\n          if (this.props.onMergeQuery) {\n            this.props.onMergeQuery();\n          }\n        },\n        ..._commonKeys.default\n      }\n    });\n    this.editor.on('change', this._onEdit);\n    this.editor.on('keyup', this._onKeyUp);\n    this.editor.on('hasCompletion', this._onHasCompletion);\n  }\n\n  componentDidUpdate(prevProps) {\n    const CodeMirror = require('codemirror'); // Ensure the changes caused by this update are not interpretted as\n    // user-input changes which could otherwise result in an infinite\n    // event loop.\n\n\n    this.ignoreChangeEvent = true;\n\n    if (this.props.variableToType !== prevProps.variableToType) {\n      this.editor.options.lint.variableToType = this.props.variableToType;\n      this.editor.options.hintOptions.variableToType = this.props.variableToType;\n      CodeMirror.signal(this.editor, 'change', this.editor);\n    }\n\n    if (this.props.value !== prevProps.value && this.props.value !== this.cachedValue) {\n      const thisValue = this.props.value || '';\n      this.cachedValue = thisValue;\n      this.editor.setValue(thisValue);\n    }\n\n    this.ignoreChangeEvent = false;\n  }\n\n  componentWillUnmount() {\n    this.editor.off('change', this._onEdit);\n    this.editor.off('keyup', this._onKeyUp);\n    this.editor.off('hasCompletion', this._onHasCompletion);\n    this.editor = null;\n  }\n\n  render() {\n    return _react.default.createElement(\"div\", {\n      className: \"codemirrorWrap\",\n      ref: node => {\n        this._node = node;\n      }\n    });\n  }\n  /**\n   * Public API for retrieving the CodeMirror instance from this\n   * React component.\n   */\n\n\n  getCodeMirror() {\n    return this.editor;\n  }\n  /**\n   * Public API for retrieving the DOM client height for this component.\n   */\n\n\n  getClientHeight() {\n    return this._node && this._node.clientHeight;\n  }\n\n}\n\nexports.VariableEditor = VariableEditor;\n\n_defineProperty(VariableEditor, \"propTypes\", {\n  variableToType: _propTypes.default.object,\n  value: _propTypes.default.string,\n  onEdit: _propTypes.default.func,\n  readOnly: _propTypes.default.bool,\n  onHintInformationRender: _propTypes.default.func,\n  onPrettifyQuery: _propTypes.default.func,\n  onMergeQuery: _propTypes.default.func,\n  onRunQuery: _propTypes.default.func,\n  editorTheme: _propTypes.default.string\n});","\"use strict\";\n\nvar _codemirror = _interopRequireDefault(require(\"codemirror\"));\n\nvar _graphql = require(\"graphql\");\n\nvar _forEachState = _interopRequireDefault(require(\"../utils/forEachState\"));\n\nvar _hintList = _interopRequireDefault(require(\"../utils/hintList\"));\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\n/**\n *  Copyright (c) 2019 GraphQL Contributors\n *  All rights reserved.\n *\n *  This source code is licensed under the BSD-style license found in the\n *  LICENSE file in the root directory of this source tree. An additional grant\n *  of patent rights can be found in the PATENTS file in the same directory.\n */\n\n/**\n * Registers a \"hint\" helper for CodeMirror.\n *\n * Using CodeMirror's \"hint\" addon: https://codemirror.net/demo/complete.html\n * Given an editor, this helper will take the token at the cursor and return a\n * list of suggested tokens.\n *\n * Options:\n *\n *   - variableToType: { [variable: string]: GraphQLInputType }\n *\n * Additional Events:\n *\n *   - hasCompletion (codemirror, data, token) - signaled when the hinter has a\n *     new list of completion suggestions.\n *\n */\n_codemirror.default.registerHelper('hint', 'graphql-variables', (editor, options) => {\n  const cur = editor.getCursor();\n  const token = editor.getTokenAt(cur);\n  const results = getVariablesHint(cur, token, options);\n\n  if (results && results.list && results.list.length > 0) {\n    results.from = _codemirror.default.Pos(results.from.line, results.from.column);\n    results.to = _codemirror.default.Pos(results.to.line, results.to.column);\n\n    _codemirror.default.signal(editor, 'hasCompletion', editor, results, token);\n  }\n\n  return results;\n});\n\nfunction getVariablesHint(cur, token, options) {\n  // If currently parsing an invalid state, attempt to hint to the prior state.\n  const state = token.state.kind === 'Invalid' ? token.state.prevState : token.state;\n  const kind = state.kind;\n  const step = state.step; // Variables can only be an object literal.\n\n  if (kind === 'Document' && step === 0) {\n    return (0, _hintList.default)(cur, token, [{\n      text: '{'\n    }]);\n  }\n\n  const variableToType = options.variableToType;\n\n  if (!variableToType) {\n    return;\n  }\n\n  const typeInfo = getTypeInfo(variableToType, token.state); // Top level should typeahead possible variables.\n\n  if (kind === 'Document' || kind === 'Variable' && step === 0) {\n    const variableNames = Object.keys(variableToType);\n    return (0, _hintList.default)(cur, token, variableNames.map(name => ({\n      text: `\"${name}\": `,\n      type: variableToType[name]\n    })));\n  } // Input Object fields\n\n\n  if (kind === 'ObjectValue' || kind === 'ObjectField' && step === 0) {\n    if (typeInfo.fields) {\n      const inputFields = Object.keys(typeInfo.fields).map(fieldName => typeInfo.fields[fieldName]);\n      return (0, _hintList.default)(cur, token, inputFields.map(field => ({\n        text: `\"${field.name}\": `,\n        type: field.type,\n        description: field.description\n      })));\n    }\n  } // Input values.\n\n\n  if (kind === 'StringValue' || kind === 'NumberValue' || kind === 'BooleanValue' || kind === 'NullValue' || kind === 'ListValue' && step === 1 || kind === 'ObjectField' && step === 2 || kind === 'Variable' && step === 2) {\n    const namedInputType = (0, _graphql.getNamedType)(typeInfo.type);\n\n    if (namedInputType instanceof _graphql.GraphQLInputObjectType) {\n      return (0, _hintList.default)(cur, token, [{\n        text: '{'\n      }]);\n    } else if (namedInputType instanceof _graphql.GraphQLEnumType) {\n      const valueMap = namedInputType.getValues();\n      const values = Object.keys(valueMap).map(name => valueMap[name]);\n      return (0, _hintList.default)(cur, token, values.map(value => ({\n        text: `\"${value.name}\"`,\n        type: namedInputType,\n        description: value.description\n      })));\n    } else if (namedInputType === _graphql.GraphQLBoolean) {\n      return (0, _hintList.default)(cur, token, [{\n        text: 'true',\n        type: _graphql.GraphQLBoolean,\n        description: 'Not false.'\n      }, {\n        text: 'false',\n        type: _graphql.GraphQLBoolean,\n        description: 'Not true.'\n      }]);\n    }\n  }\n} // Utility for collecting rich type information given any token's state\n// from the graphql-variables-mode parser.\n\n\nfunction getTypeInfo(variableToType, tokenState) {\n  const info = {\n    type: null,\n    fields: null\n  };\n  (0, _forEachState.default)(tokenState, state => {\n    if (state.kind === 'Variable') {\n      info.type = variableToType[state.name];\n    } else if (state.kind === 'ListValue') {\n      const nullableType = (0, _graphql.getNullableType)(info.type);\n      info.type = nullableType instanceof _graphql.GraphQLList ? nullableType.ofType : null;\n    } else if (state.kind === 'ObjectValue') {\n      const objectType = (0, _graphql.getNamedType)(info.type);\n      info.fields = objectType instanceof _graphql.GraphQLInputObjectType ? objectType.getFields() : null;\n    } else if (state.kind === 'ObjectField') {\n      const objectField = state.name && info.fields ? info.fields[state.name] : null;\n      info.type = objectField && objectField.type;\n    }\n  });\n  return info;\n}","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.default = hintList;\n\n/**\n *  Copyright (c) 2019 GraphQL Contributors\n *  All rights reserved.\n *\n *  This source code is licensed under the BSD-style license found in the\n *  LICENSE file in the root directory of this source tree. An additional grant\n *  of patent rights can be found in the PATENTS file in the same directory.\n */\n// Create the expected hint response given a possible list and a token\nfunction hintList(cursor, token, list) {\n  const hints = filterAndSortList(list, normalizeText(token.string));\n\n  if (!hints) {\n    return;\n  }\n\n  const tokenStart = token.type !== null && /\"|\\w/.test(token.string[0]) ? token.start : token.end;\n  return {\n    list: hints,\n    from: {\n      line: cursor.line,\n      column: tokenStart\n    },\n    to: {\n      line: cursor.line,\n      column: token.end\n    }\n  };\n} // Given a list of hint entries and currently typed text, sort and filter to\n// provide a concise list.\n\n\nfunction filterAndSortList(list, text) {\n  if (!text) {\n    return filterNonEmpty(list, entry => !entry.isDeprecated);\n  }\n\n  const byProximity = list.map(entry => ({\n    proximity: getProximity(normalizeText(entry.text), text),\n    entry\n  }));\n  const conciseMatches = filterNonEmpty(filterNonEmpty(byProximity, pair => pair.proximity <= 2), pair => !pair.entry.isDeprecated);\n  const sortedMatches = conciseMatches.sort((a, b) => (a.entry.isDeprecated ? 1 : 0) - (b.entry.isDeprecated ? 1 : 0) || a.proximity - b.proximity || a.entry.text.length - b.entry.text.length);\n  return sortedMatches.map(pair => pair.entry);\n} // Filters the array by the predicate, unless it results in an empty array,\n// in which case return the original array.\n\n\nfunction filterNonEmpty(array, predicate) {\n  const filtered = array.filter(predicate);\n  return filtered.length === 0 ? array : filtered;\n}\n\nfunction normalizeText(text) {\n  return text.toLowerCase().replace(/\\W/g, '');\n} // Determine a numeric proximity for a suggestion based on current text.\n\n\nfunction getProximity(suggestion, text) {\n  // start with lexical distance\n  let proximity = lexicalDistance(text, suggestion);\n\n  if (suggestion.length > text.length) {\n    // do not penalize long suggestions.\n    proximity -= suggestion.length - text.length - 1; // penalize suggestions not starting with this phrase\n\n    proximity += suggestion.indexOf(text) === 0 ? 0 : 0.5;\n  }\n\n  return proximity;\n}\n/**\n * Computes the lexical distance between strings A and B.\n *\n * The \"distance\" between two strings is given by counting the minimum number\n * of edits needed to transform string A into string B. An edit can be an\n * insertion, deletion, or substitution of a single character, or a swap of two\n * adjacent characters.\n *\n * This distance can be useful for detecting typos in input or sorting\n *\n * @param {string} a\n * @param {string} b\n * @return {int} distance in number of edits\n */\n\n\nfunction lexicalDistance(a, b) {\n  let i;\n  let j;\n  const d = [];\n  const aLength = a.length;\n  const bLength = b.length;\n\n  for (i = 0; i <= aLength; i++) {\n    d[i] = [i];\n  }\n\n  for (j = 1; j <= bLength; j++) {\n    d[0][j] = j;\n  }\n\n  for (i = 1; i <= aLength; i++) {\n    for (j = 1; j <= bLength; j++) {\n      const cost = a[i - 1] === b[j - 1] ? 0 : 1;\n      d[i][j] = Math.min(d[i - 1][j] + 1, d[i][j - 1] + 1, d[i - 1][j - 1] + cost);\n\n      if (i > 1 && j > 1 && a[i - 1] === b[j - 2] && a[i - 2] === b[j - 1]) {\n        d[i][j] = Math.min(d[i][j], d[i - 2][j - 2] + cost);\n      }\n    }\n  }\n\n  return d[aLength][bLength];\n}","\"use strict\";\n\nvar _codemirror = _interopRequireDefault(require(\"codemirror\"));\n\nvar _graphql = require(\"graphql\");\n\nvar _jsonParse = _interopRequireDefault(require(\"../utils/jsonParse\"));\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\n/**\n *  Copyright (c) 2019 GraphQL Contributors\n *  All rights reserved.\n *\n *  This source code is licensed under the BSD-style license found in the\n *  LICENSE file in the root directory of this source tree. An additional grant\n *  of patent rights can be found in the PATENTS file in the same directory.\n */\n\n/**\n * Registers a \"lint\" helper for CodeMirror.\n *\n * Using CodeMirror's \"lint\" addon: https://codemirror.net/demo/lint.html\n * Given the text within an editor, this helper will take that text and return\n * a list of linter issues ensuring that correct variables were provided.\n *\n * Options:\n *\n *   - variableToType: { [variable: string]: GraphQLInputType }\n *\n */\n_codemirror.default.registerHelper('lint', 'graphql-variables', (text, options, editor) => {\n  // If there's no text, do nothing.\n  if (!text) {\n    return [];\n  } // First, linter needs to determine if there are any parsing errors.\n\n\n  let ast;\n\n  try {\n    ast = (0, _jsonParse.default)(text);\n  } catch (syntaxError) {\n    if (syntaxError.stack) {\n      throw syntaxError;\n    }\n\n    return [lintError(editor, syntaxError, syntaxError.message)];\n  } // If there are not yet known variables, do nothing.\n\n\n  const variableToType = options.variableToType;\n\n  if (!variableToType) {\n    return [];\n  } // Then highlight any issues with the provided variables.\n\n\n  return validateVariables(editor, variableToType, ast);\n}); // Given a variableToType object, a source text, and a JSON AST, produces a\n// list of CodeMirror annotations for any variable validation errors.\n\n\nfunction validateVariables(editor, variableToType, variablesAST) {\n  const errors = [];\n  variablesAST.members.forEach(member => {\n    const variableName = member.key.value;\n    const type = variableToType[variableName];\n\n    if (!type) {\n      errors.push(lintError(editor, member.key, `Variable \"$${variableName}\" does not appear in any GraphQL query.`));\n    } else {\n      validateValue(type, member.value).forEach(([node, message]) => {\n        errors.push(lintError(editor, node, message));\n      });\n    }\n  });\n  return errors;\n} // Returns a list of validation errors in the form Array<[Node, String]>.\n\n\nfunction validateValue(type, valueAST) {\n  // Validate non-nullable values.\n  if (type instanceof _graphql.GraphQLNonNull) {\n    if (valueAST.kind === 'Null') {\n      return [[valueAST, `Type \"${type}\" is non-nullable and cannot be null.`]];\n    }\n\n    return validateValue(type.ofType, valueAST);\n  }\n\n  if (valueAST.kind === 'Null') {\n    return [];\n  } // Validate lists of values, accepting a non-list as a list of one.\n\n\n  if (type instanceof _graphql.GraphQLList) {\n    const itemType = type.ofType;\n\n    if (valueAST.kind === 'Array') {\n      return mapCat(valueAST.values, item => validateValue(itemType, item));\n    }\n\n    return validateValue(itemType, valueAST);\n  } // Validate input objects.\n\n\n  if (type instanceof _graphql.GraphQLInputObjectType) {\n    if (valueAST.kind !== 'Object') {\n      return [[valueAST, `Type \"${type}\" must be an Object.`]];\n    } // Validate each field in the input object.\n\n\n    const providedFields = Object.create(null);\n    const fieldErrors = mapCat(valueAST.members, member => {\n      const fieldName = member.key.value;\n      providedFields[fieldName] = true;\n      const inputField = type.getFields()[fieldName];\n\n      if (!inputField) {\n        return [[member.key, `Type \"${type}\" does not have a field \"${fieldName}\".`]];\n      }\n\n      const fieldType = inputField ? inputField.type : undefined;\n      return validateValue(fieldType, member.value);\n    }); // Look for missing non-nullable fields.\n\n    Object.keys(type.getFields()).forEach(fieldName => {\n      if (!providedFields[fieldName]) {\n        const fieldType = type.getFields()[fieldName].type;\n\n        if (fieldType instanceof _graphql.GraphQLNonNull) {\n          fieldErrors.push([valueAST, `Object of type \"${type}\" is missing required field \"${fieldName}\".`]);\n        }\n      }\n    });\n    return fieldErrors;\n  } // Validate common scalars.\n\n\n  if (type.name === 'Boolean' && valueAST.kind !== 'Boolean' || type.name === 'String' && valueAST.kind !== 'String' || type.name === 'ID' && valueAST.kind !== 'Number' && valueAST.kind !== 'String' || type.name === 'Float' && valueAST.kind !== 'Number' || type.name === 'Int' && ( // eslint-disable-next-line no-bitwise\n  valueAST.kind !== 'Number' || (valueAST.value | 0) !== valueAST.value)) {\n    return [[valueAST, `Expected value of type \"${type}\".`]];\n  } // Validate enums and custom scalars.\n\n\n  if (type instanceof _graphql.GraphQLEnumType || type instanceof _graphql.GraphQLScalarType) {\n    if (valueAST.kind !== 'String' && valueAST.kind !== 'Number' && valueAST.kind !== 'Boolean' && valueAST.kind !== 'Null' || isNullish(type.parseValue(valueAST.value))) {\n      return [[valueAST, `Expected value of type \"${type}\".`]];\n    }\n  }\n\n  return [];\n} // Give a parent text, an AST node with location, and a message, produces a\n// CodeMirror annotation object.\n\n\nfunction lintError(editor, node, message) {\n  return {\n    message,\n    severity: 'error',\n    type: 'validation',\n    from: editor.posFromIndex(node.start),\n    to: editor.posFromIndex(node.end)\n  };\n}\n\nfunction isNullish(value) {\n  // eslint-disable-next-line no-self-compare\n  return value === null || value === undefined || value !== value;\n}\n\nfunction mapCat(array, mapper) {\n  return Array.prototype.concat.apply([], array.map(mapper));\n}","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.default = jsonParse;\n\n/**\n *  Copyright (c) 2019 GraphQL Contributors\n *  All rights reserved.\n *\n *  This source code is licensed under the BSD-style license found in the\n *  LICENSE file in the root directory of this source tree. An additional grant\n *  of patent rights can be found in the PATENTS file in the same directory.\n */\n\n/**\n * This JSON parser simply walks the input, generating an AST. Use this in lieu\n * of JSON.parse if you need character offset parse errors and an AST parse tree\n * with location information.\n *\n * If an error is encountered, a SyntaxError will be thrown, with properties:\n *\n *   - message: string\n *   - start: int - the start inclusive offset of the syntax error\n *   - end: int - the end exclusive offset of the syntax error\n *\n */\nfunction jsonParse(str) {\n  string = str;\n  strLen = str.length;\n  start = end = lastEnd = -1;\n  ch();\n  lex();\n  const ast = parseObj();\n  expect('EOF');\n  return ast;\n}\n\nlet string;\nlet strLen;\nlet start;\nlet end;\nlet lastEnd;\nlet code;\nlet kind;\n\nfunction parseObj() {\n  const nodeStart = start;\n  const members = [];\n  expect('{');\n\n  if (!skip('}')) {\n    do {\n      members.push(parseMember());\n    } while (skip(','));\n\n    expect('}');\n  }\n\n  return {\n    kind: 'Object',\n    start: nodeStart,\n    end: lastEnd,\n    members\n  };\n}\n\nfunction parseMember() {\n  const nodeStart = start;\n  const key = kind === 'String' ? curToken() : null;\n  expect('String');\n  expect(':');\n  const value = parseVal();\n  return {\n    kind: 'Member',\n    start: nodeStart,\n    end: lastEnd,\n    key,\n    value\n  };\n}\n\nfunction parseArr() {\n  const nodeStart = start;\n  const values = [];\n  expect('[');\n\n  if (!skip(']')) {\n    do {\n      values.push(parseVal());\n    } while (skip(','));\n\n    expect(']');\n  }\n\n  return {\n    kind: 'Array',\n    start: nodeStart,\n    end: lastEnd,\n    values\n  };\n}\n\nfunction parseVal() {\n  switch (kind) {\n    case '[':\n      return parseArr();\n\n    case '{':\n      return parseObj();\n\n    case 'String':\n    case 'Number':\n    case 'Boolean':\n    case 'Null':\n      const token = curToken();\n      lex();\n      return token;\n  }\n\n  return expect('Value');\n}\n\nfunction curToken() {\n  return {\n    kind,\n    start,\n    end,\n    value: JSON.parse(string.slice(start, end))\n  };\n}\n\nfunction expect(str) {\n  if (kind === str) {\n    lex();\n    return;\n  }\n\n  let found;\n\n  if (kind === 'EOF') {\n    found = '[end of file]';\n  } else if (end - start > 1) {\n    found = '`' + string.slice(start, end) + '`';\n  } else {\n    const match = string.slice(start).match(/^.+?\\b/);\n    found = '`' + (match ? match[0] : string[start]) + '`';\n  }\n\n  throw syntaxError(`Expected ${str} but found ${found}.`);\n}\n\nfunction syntaxError(message) {\n  return {\n    message,\n    start,\n    end\n  };\n}\n\nfunction skip(k) {\n  if (kind === k) {\n    lex();\n    return true;\n  }\n}\n\nfunction ch() {\n  if (end < strLen) {\n    end++;\n    code = end === strLen ? 0 : string.charCodeAt(end);\n  }\n}\n\nfunction lex() {\n  lastEnd = end;\n\n  while (code === 9 || code === 10 || code === 13 || code === 32) {\n    ch();\n  }\n\n  if (code === 0) {\n    kind = 'EOF';\n    return;\n  }\n\n  start = end;\n\n  switch (code) {\n    // \"\n    case 34:\n      kind = 'String';\n      return readString();\n    // -, 0-9\n\n    case 45:\n    case 48:\n    case 49:\n    case 50:\n    case 51:\n    case 52:\n    case 53:\n    case 54:\n    case 55:\n    case 56:\n    case 57:\n      kind = 'Number';\n      return readNumber();\n    // f\n\n    case 102:\n      if (string.slice(start, start + 5) !== 'false') {\n        break;\n      }\n\n      end += 4;\n      ch();\n      kind = 'Boolean';\n      return;\n    // n\n\n    case 110:\n      if (string.slice(start, start + 4) !== 'null') {\n        break;\n      }\n\n      end += 3;\n      ch();\n      kind = 'Null';\n      return;\n    // t\n\n    case 116:\n      if (string.slice(start, start + 4) !== 'true') {\n        break;\n      }\n\n      end += 3;\n      ch();\n      kind = 'Boolean';\n      return;\n  }\n\n  kind = string[start];\n  ch();\n}\n\nfunction readString() {\n  ch();\n\n  while (code !== 34 && code > 31) {\n    if (code === 92) {\n      // \\\n      ch();\n\n      switch (code) {\n        case 34: // \"\n\n        case 47: // /\n\n        case 92: // \\\n\n        case 98: // b\n\n        case 102: // f\n\n        case 110: // n\n\n        case 114: // r\n\n        case 116:\n          // t\n          ch();\n          break;\n\n        case 117:\n          // u\n          ch();\n          readHex();\n          readHex();\n          readHex();\n          readHex();\n          break;\n\n        default:\n          throw syntaxError('Bad character escape sequence.');\n      }\n    } else if (end === strLen) {\n      throw syntaxError('Unterminated string.');\n    } else {\n      ch();\n    }\n  }\n\n  if (code === 34) {\n    ch();\n    return;\n  }\n\n  throw syntaxError('Unterminated string.');\n}\n\nfunction readHex() {\n  if (code >= 48 && code <= 57 || // 0-9\n  code >= 65 && code <= 70 || // A-F\n  code >= 97 && code <= 102 // a-f\n  ) {\n      return ch();\n    }\n\n  throw syntaxError('Expected hexadecimal digit.');\n}\n\nfunction readNumber() {\n  if (code === 45) {\n    // -\n    ch();\n  }\n\n  if (code === 48) {\n    // 0\n    ch();\n  } else {\n    readDigits();\n  }\n\n  if (code === 46) {\n    // .\n    ch();\n    readDigits();\n  }\n\n  if (code === 69 || code === 101) {\n    // E e\n    ch();\n\n    if (code === 43 || code === 45) {\n      // + -\n      ch();\n    }\n\n    readDigits();\n  }\n}\n\nfunction readDigits() {\n  if (code < 48 || code > 57) {\n    // 0 - 9\n    throw syntaxError('Expected decimal digit.');\n  }\n\n  do {\n    ch();\n  } while (code >= 48 && code <= 57); // 0 - 9\n\n}","\"use strict\";\n\nvar _codemirror = _interopRequireDefault(require(\"codemirror\"));\n\nvar _graphqlLanguageServiceParser = require(\"graphql-language-service-parser\");\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\n/**\n *  Copyright (c) 2019 GraphQL Contributors\n *  All rights reserved.\n *\n *  This source code is licensed under the BSD-style license found in the\n *  LICENSE file in the root directory of this source tree. An additional grant\n *  of patent rights can be found in the PATENTS file in the same directory.\n */\n\n/**\n * This mode defines JSON, but provides a data-laden parser state to enable\n * better code intelligence.\n */\n_codemirror.default.defineMode('graphql-variables', config => {\n  const parser = (0, _graphqlLanguageServiceParser.onlineParser)({\n    eatWhitespace: stream => stream.eatSpace(),\n    lexRules: LexRules,\n    parseRules: ParseRules,\n    editorConfig: {\n      tabSize: config.tabSize\n    }\n  });\n  return {\n    config,\n    startState: parser.startState,\n    token: parser.token,\n    indent,\n    electricInput: /^\\s*[}\\]]/,\n    fold: 'brace',\n    closeBrackets: {\n      pairs: '[]{}\"\"',\n      explode: '[]{}'\n    }\n  };\n});\n\nfunction indent(state, textAfter) {\n  const levels = state.levels; // If there is no stack of levels, use the current level.\n  // Otherwise, use the top level, pre-emptively dedenting for close braces.\n\n  const level = !levels || levels.length === 0 ? state.indentLevel : levels[levels.length - 1] - (this.electricInput.test(textAfter) ? 1 : 0);\n  return level * this.config.indentUnit;\n}\n/**\n * The lexer rules. These are exactly as described by the spec.\n */\n\n\nconst LexRules = {\n  // All Punctuation used in JSON.\n  Punctuation: /^\\[|]|\\{|\\}|:|,/,\n  // JSON Number.\n  Number: /^-?(?:0|(?:[1-9][0-9]*))(?:\\.[0-9]*)?(?:[eE][+-]?[0-9]+)?/,\n  // JSON String.\n  String: /^\"(?:[^\"\\\\]|\\\\(?:\"|\\/|\\\\|b|f|n|r|t|u[0-9a-fA-F]{4}))*\"?/,\n  // JSON literal keywords.\n  Keyword: /^true|false|null/\n};\n/**\n * The parser rules for JSON.\n */\n\nconst ParseRules = {\n  Document: [(0, _graphqlLanguageServiceParser.p)('{'), (0, _graphqlLanguageServiceParser.list)('Variable', (0, _graphqlLanguageServiceParser.opt)((0, _graphqlLanguageServiceParser.p)(','))), (0, _graphqlLanguageServiceParser.p)('}')],\n  Variable: [namedKey('variable'), (0, _graphqlLanguageServiceParser.p)(':'), 'Value'],\n\n  Value(token) {\n    switch (token.kind) {\n      case 'Number':\n        return 'NumberValue';\n\n      case 'String':\n        return 'StringValue';\n\n      case 'Punctuation':\n        switch (token.value) {\n          case '[':\n            return 'ListValue';\n\n          case '{':\n            return 'ObjectValue';\n        }\n\n        return null;\n\n      case 'Keyword':\n        switch (token.value) {\n          case 'true':\n          case 'false':\n            return 'BooleanValue';\n\n          case 'null':\n            return 'NullValue';\n        }\n\n        return null;\n    }\n  },\n\n  NumberValue: [(0, _graphqlLanguageServiceParser.t)('Number', 'number')],\n  StringValue: [(0, _graphqlLanguageServiceParser.t)('String', 'string')],\n  BooleanValue: [(0, _graphqlLanguageServiceParser.t)('Keyword', 'builtin')],\n  NullValue: [(0, _graphqlLanguageServiceParser.t)('Keyword', 'keyword')],\n  ListValue: [(0, _graphqlLanguageServiceParser.p)('['), (0, _graphqlLanguageServiceParser.list)('Value', (0, _graphqlLanguageServiceParser.opt)((0, _graphqlLanguageServiceParser.p)(','))), (0, _graphqlLanguageServiceParser.p)(']')],\n  ObjectValue: [(0, _graphqlLanguageServiceParser.p)('{'), (0, _graphqlLanguageServiceParser.list)('ObjectField', (0, _graphqlLanguageServiceParser.opt)((0, _graphqlLanguageServiceParser.p)(','))), (0, _graphqlLanguageServiceParser.p)('}')],\n  ObjectField: [namedKey('attribute'), (0, _graphqlLanguageServiceParser.p)(':'), 'Value']\n}; // A namedKey Token which will decorate the state with a `name`\n\nfunction namedKey(style) {\n  return {\n    style,\n    match: token => token.kind === 'String',\n\n    update(state, token) {\n      state.name = token.value.slice(1, -1); // Remove quotes.\n    }\n\n  };\n}","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.ResultViewer = void 0;\n\nvar _react = _interopRequireDefault(require(\"react\"));\n\nvar _reactDom = _interopRequireDefault(require(\"react-dom\"));\n\nvar _propTypes = _interopRequireDefault(require(\"prop-types\"));\n\nvar _commonKeys = _interopRequireDefault(require(\"../utility/commonKeys\"));\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\n/**\n * ResultViewer\n *\n * Maintains an instance of CodeMirror for viewing a GraphQL response.\n *\n * Props:\n *\n *   - value: The text of the editor.\n *\n */\nclass ResultViewer extends _react.default.Component {\n  constructor() {\n    super();\n  }\n\n  componentDidMount() {\n    // Lazily require to ensure requiring GraphiQL outside of a Browser context\n    // does not produce an error.\n    const CodeMirror = require('codemirror');\n\n    require('codemirror/addon/fold/foldgutter');\n\n    require('codemirror/addon/fold/brace-fold');\n\n    require('codemirror/addon/dialog/dialog');\n\n    require('codemirror/addon/search/search');\n\n    require('codemirror/addon/search/searchcursor');\n\n    require('codemirror/addon/search/jump-to-line');\n\n    require('codemirror/keymap/sublime');\n\n    require('codemirror-graphql/results/mode');\n\n    const Tooltip = this.props.ResultsTooltip;\n    const ImagePreview = this.props.ImagePreview;\n\n    if (Tooltip || ImagePreview) {\n      require('codemirror-graphql/utils/info-addon');\n\n      const tooltipDiv = document.createElement('div');\n      CodeMirror.registerHelper('info', 'graphql-results', (token, options, cm, pos) => {\n        const infoElements = [];\n\n        if (Tooltip) {\n          infoElements.push(_react.default.createElement(Tooltip, {\n            pos: pos\n          }));\n        }\n\n        if (ImagePreview && typeof ImagePreview.shouldRender === 'function' && ImagePreview.shouldRender(token)) {\n          infoElements.push(_react.default.createElement(ImagePreview, {\n            token: token\n          }));\n        }\n\n        if (!infoElements.length) {\n          _reactDom.default.unmountComponentAtNode(tooltipDiv);\n\n          return null;\n        }\n\n        _reactDom.default.render(_react.default.createElement(\"div\", null, infoElements), tooltipDiv);\n\n        return tooltipDiv;\n      });\n    }\n\n    this.viewer = CodeMirror(this._node, {\n      lineWrapping: true,\n      value: this.props.value || '',\n      readOnly: true,\n      theme: this.props.editorTheme || 'graphiql',\n      mode: 'graphql-results',\n      keyMap: 'sublime',\n      foldGutter: {\n        minFoldSize: 4\n      },\n      gutters: ['CodeMirror-foldgutter'],\n      info: Boolean(this.props.ResultsTooltip || this.props.ImagePreview),\n      extraKeys: _commonKeys.default\n    });\n  }\n\n  shouldComponentUpdate(nextProps) {\n    return this.props.value !== nextProps.value;\n  }\n\n  componentDidUpdate() {\n    this.viewer.setValue(this.props.value || '');\n  }\n\n  componentWillUnmount() {\n    this.viewer = null;\n  }\n\n  render() {\n    return _react.default.createElement(\"section\", {\n      className: \"result-window\",\n      \"aria-label\": \"Result Window\",\n      \"aria-live\": \"polite\",\n      \"aria-atomic\": \"true\",\n      ref: node => {\n        this._node = node;\n      }\n    });\n  }\n  /**\n   * Public API for retrieving the CodeMirror instance from this\n   * React component.\n   */\n\n\n  getCodeMirror() {\n    return this.viewer;\n  }\n  /**\n   * Public API for retrieving the DOM client height for this component.\n   */\n\n\n  getClientHeight() {\n    return this._node && this._node.clientHeight;\n  }\n\n}\n\nexports.ResultViewer = ResultViewer;\n\n_defineProperty(ResultViewer, \"propTypes\", {\n  value: _propTypes.default.string,\n  editorTheme: _propTypes.default.string,\n  ResultsTooltip: _propTypes.default.any,\n  ImagePreview: _propTypes.default.any\n});","\"use strict\";\n\nvar _codemirror = _interopRequireDefault(require(\"codemirror\"));\n\nvar _graphqlLanguageServiceParser = require(\"graphql-language-service-parser\");\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\n/**\n *  Copyright (c) 2019 GraphQL Contributors\n *  All rights reserved.\n *\n *  This source code is licensed under the BSD-style license found in the\n *  LICENSE file in the root directory of this source tree. An additional grant\n *  of patent rights can be found in the PATENTS file in the same directory.\n */\n\n/**\n * This mode defines JSON, but provides a data-laden parser state to enable\n * better code intelligence.\n */\n_codemirror.default.defineMode('graphql-results', config => {\n  const parser = (0, _graphqlLanguageServiceParser.onlineParser)({\n    eatWhitespace: stream => stream.eatSpace(),\n    lexRules: LexRules,\n    parseRules: ParseRules,\n    editorConfig: {\n      tabSize: config.tabSize\n    }\n  });\n  return {\n    config,\n    startState: parser.startState,\n    token: parser.token,\n    indent,\n    electricInput: /^\\s*[}\\]]/,\n    fold: 'brace',\n    closeBrackets: {\n      pairs: '[]{}\"\"',\n      explode: '[]{}'\n    }\n  };\n});\n\nfunction indent(state, textAfter) {\n  const levels = state.levels; // If there is no stack of levels, use the current level.\n  // Otherwise, use the top level, pre-emptively dedenting for close braces.\n\n  const level = !levels || levels.length === 0 ? state.indentLevel : levels[levels.length - 1] - (this.electricInput.test(textAfter) ? 1 : 0);\n  return level * this.config.indentUnit;\n}\n/**\n * The lexer rules. These are exactly as described by the spec.\n */\n\n\nconst LexRules = {\n  // All Punctuation used in JSON.\n  Punctuation: /^\\[|]|\\{|\\}|:|,/,\n  // JSON Number.\n  Number: /^-?(?:0|(?:[1-9][0-9]*))(?:\\.[0-9]*)?(?:[eE][+-]?[0-9]+)?/,\n  // JSON String.\n  String: /^\"(?:[^\"\\\\]|\\\\(?:\"|\\/|\\\\|b|f|n|r|t|u[0-9a-fA-F]{4}))*\"?/,\n  // JSON literal keywords.\n  Keyword: /^true|false|null/\n};\n/**\n * The parser rules for JSON.\n */\n\nconst ParseRules = {\n  Document: [(0, _graphqlLanguageServiceParser.p)('{'), (0, _graphqlLanguageServiceParser.list)('Entry', (0, _graphqlLanguageServiceParser.p)(',')), (0, _graphqlLanguageServiceParser.p)('}')],\n  Entry: [(0, _graphqlLanguageServiceParser.t)('String', 'def'), (0, _graphqlLanguageServiceParser.p)(':'), 'Value'],\n\n  Value(token) {\n    switch (token.kind) {\n      case 'Number':\n        return 'NumberValue';\n\n      case 'String':\n        return 'StringValue';\n\n      case 'Punctuation':\n        switch (token.value) {\n          case '[':\n            return 'ListValue';\n\n          case '{':\n            return 'ObjectValue';\n        }\n\n        return null;\n\n      case 'Keyword':\n        switch (token.value) {\n          case 'true':\n          case 'false':\n            return 'BooleanValue';\n\n          case 'null':\n            return 'NullValue';\n        }\n\n        return null;\n    }\n  },\n\n  NumberValue: [(0, _graphqlLanguageServiceParser.t)('Number', 'number')],\n  StringValue: [(0, _graphqlLanguageServiceParser.t)('String', 'string')],\n  BooleanValue: [(0, _graphqlLanguageServiceParser.t)('Keyword', 'builtin')],\n  NullValue: [(0, _graphqlLanguageServiceParser.t)('Keyword', 'keyword')],\n  ListValue: [(0, _graphqlLanguageServiceParser.p)('['), (0, _graphqlLanguageServiceParser.list)('Value', (0, _graphqlLanguageServiceParser.p)(',')), (0, _graphqlLanguageServiceParser.p)(']')],\n  ObjectValue: [(0, _graphqlLanguageServiceParser.p)('{'), (0, _graphqlLanguageServiceParser.list)('ObjectField', (0, _graphqlLanguageServiceParser.p)(',')), (0, _graphqlLanguageServiceParser.p)('}')],\n  ObjectField: [(0, _graphqlLanguageServiceParser.t)('String', 'property'), (0, _graphqlLanguageServiceParser.p)(':'), 'Value']\n};","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.DocExplorer = void 0;\n\nvar _react = _interopRequireDefault(require(\"react\"));\n\nvar _propTypes = _interopRequireDefault(require(\"prop-types\"));\n\nvar _graphql = require(\"graphql\");\n\nvar _FieldDoc = _interopRequireDefault(require(\"./DocExplorer/FieldDoc\"));\n\nvar _SchemaDoc = _interopRequireDefault(require(\"./DocExplorer/SchemaDoc\"));\n\nvar _SearchBox = _interopRequireDefault(require(\"./DocExplorer/SearchBox\"));\n\nvar _SearchResults = _interopRequireDefault(require(\"./DocExplorer/SearchResults\"));\n\nvar _TypeDoc = _interopRequireDefault(require(\"./DocExplorer/TypeDoc\"));\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\nconst initialNav = {\n  name: 'Schema',\n  title: 'Documentation Explorer'\n};\n/**\n * DocExplorer\n *\n * Shows documentations for GraphQL definitions from the schema.\n *\n * Props:\n *\n *   - schema: A required GraphQLSchema instance that provides GraphQL document\n *     definitions.\n *\n * Children:\n *\n *   - Any provided children will be positioned in the right-hand-side of the\n *     top bar. Typically this will be a \"close\" button for temporary explorer.\n *\n */\n\nclass DocExplorer extends _react.default.Component {\n  constructor() {\n    super();\n\n    _defineProperty(this, \"handleNavBackClick\", () => {\n      if (this.state.navStack.length > 1) {\n        this.setState({\n          navStack: this.state.navStack.slice(0, -1)\n        });\n      }\n    });\n\n    _defineProperty(this, \"handleClickTypeOrField\", typeOrField => {\n      this.showDoc(typeOrField);\n    });\n\n    _defineProperty(this, \"handleSearch\", value => {\n      this.showSearch(value);\n    });\n\n    this.state = {\n      navStack: [initialNav]\n    };\n  }\n\n  shouldComponentUpdate(nextProps, nextState) {\n    return this.props.schema !== nextProps.schema || this.state.navStack !== nextState.navStack;\n  }\n\n  render() {\n    const schema = this.props.schema;\n    const navStack = this.state.navStack;\n    const navItem = navStack[navStack.length - 1];\n    let content;\n\n    if (schema === undefined) {\n      // Schema is undefined when it is being loaded via introspection.\n      content = _react.default.createElement(\"div\", {\n        className: \"spinner-container\"\n      }, _react.default.createElement(\"div\", {\n        className: \"spinner\"\n      }));\n    } else if (!schema) {\n      // Schema is null when it explicitly does not exist, typically due to\n      // an error during introspection.\n      content = _react.default.createElement(\"div\", {\n        className: \"error-container\"\n      }, 'No Schema Available');\n    } else if (navItem.search) {\n      content = _react.default.createElement(_SearchResults.default, {\n        searchValue: navItem.search,\n        withinType: navItem.def,\n        schema: schema,\n        onClickType: this.handleClickTypeOrField,\n        onClickField: this.handleClickTypeOrField\n      });\n    } else if (navStack.length === 1) {\n      content = _react.default.createElement(_SchemaDoc.default, {\n        schema: schema,\n        onClickType: this.handleClickTypeOrField\n      });\n    } else if ((0, _graphql.isType)(navItem.def)) {\n      content = _react.default.createElement(_TypeDoc.default, {\n        schema: schema,\n        type: navItem.def,\n        onClickType: this.handleClickTypeOrField,\n        onClickField: this.handleClickTypeOrField\n      });\n    } else {\n      content = _react.default.createElement(_FieldDoc.default, {\n        field: navItem.def,\n        onClickType: this.handleClickTypeOrField\n      });\n    }\n\n    const shouldSearchBoxAppear = navStack.length === 1 || (0, _graphql.isType)(navItem.def) && navItem.def.getFields;\n    let prevName;\n\n    if (navStack.length > 1) {\n      prevName = navStack[navStack.length - 2].name;\n    }\n\n    return _react.default.createElement(\"section\", {\n      className: \"doc-explorer\",\n      key: navItem.name,\n      \"aria-label\": \"Documentation Explorer\"\n    }, _react.default.createElement(\"div\", {\n      className: \"doc-explorer-title-bar\"\n    }, prevName && _react.default.createElement(\"button\", {\n      className: \"doc-explorer-back\",\n      onClick: this.handleNavBackClick,\n      \"aria-label\": `Go back to ${prevName}`\n    }, prevName), _react.default.createElement(\"div\", {\n      className: \"doc-explorer-title\"\n    }, navItem.title || navItem.name), _react.default.createElement(\"div\", {\n      className: \"doc-explorer-rhs\"\n    }, this.props.children)), _react.default.createElement(\"div\", {\n      className: \"doc-explorer-contents\"\n    }, shouldSearchBoxAppear && _react.default.createElement(_SearchBox.default, {\n      value: navItem.search,\n      placeholder: `Search ${navItem.name}...`,\n      onSearch: this.handleSearch\n    }), content));\n  } // Public API\n\n\n  showDoc(typeOrField) {\n    const navStack = this.state.navStack;\n    const topNav = navStack[navStack.length - 1];\n\n    if (topNav.def !== typeOrField) {\n      this.setState({\n        navStack: navStack.concat([{\n          name: typeOrField.name,\n          def: typeOrField\n        }])\n      });\n    }\n  } // Public API\n\n\n  showDocForReference(reference) {\n    if (reference.kind === 'Type') {\n      this.showDoc(reference.type);\n    } else if (reference.kind === 'Field') {\n      this.showDoc(reference.field);\n    } else if (reference.kind === 'Argument' && reference.field) {\n      this.showDoc(reference.field);\n    } else if (reference.kind === 'EnumValue' && reference.type) {\n      this.showDoc(reference.type);\n    }\n  } // Public API\n\n\n  showSearch(search) {\n    const navStack = this.state.navStack.slice();\n    const topNav = navStack[navStack.length - 1];\n    navStack[navStack.length - 1] = { ...topNav,\n      search\n    };\n    this.setState({\n      navStack\n    });\n  }\n\n  reset() {\n    this.setState({\n      navStack: [initialNav]\n    });\n  }\n\n}\n\nexports.DocExplorer = DocExplorer;\n\n_defineProperty(DocExplorer, \"propTypes\", {\n  schema: _propTypes.default.instanceOf(_graphql.GraphQLSchema)\n});","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.default = void 0;\n\nvar _react = _interopRequireDefault(require(\"react\"));\n\nvar _propTypes = _interopRequireDefault(require(\"prop-types\"));\n\nvar _Argument = _interopRequireDefault(require(\"./Argument\"));\n\nvar _MarkdownContent = _interopRequireDefault(require(\"./MarkdownContent\"));\n\nvar _TypeLink = _interopRequireDefault(require(\"./TypeLink\"));\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\nclass FieldDoc extends _react.default.Component {\n  shouldComponentUpdate(nextProps) {\n    return this.props.field !== nextProps.field;\n  }\n\n  render() {\n    const field = this.props.field;\n    let argsDef;\n\n    if (field.args && field.args.length > 0) {\n      argsDef = _react.default.createElement(\"div\", {\n        className: \"doc-category\"\n      }, _react.default.createElement(\"div\", {\n        className: \"doc-category-title\"\n      }, 'arguments'), field.args.map(arg => _react.default.createElement(\"div\", {\n        key: arg.name,\n        className: \"doc-category-item\"\n      }, _react.default.createElement(\"div\", null, _react.default.createElement(_Argument.default, {\n        arg: arg,\n        onClickType: this.props.onClickType\n      })), _react.default.createElement(_MarkdownContent.default, {\n        className: \"doc-value-description\",\n        markdown: arg.description\n      }))));\n    }\n\n    return _react.default.createElement(\"div\", null, _react.default.createElement(_MarkdownContent.default, {\n      className: \"doc-type-description\",\n      markdown: field.description || 'No Description'\n    }), field.deprecationReason && _react.default.createElement(_MarkdownContent.default, {\n      className: \"doc-deprecation\",\n      markdown: field.deprecationReason\n    }), _react.default.createElement(\"div\", {\n      className: \"doc-category\"\n    }, _react.default.createElement(\"div\", {\n      className: \"doc-category-title\"\n    }, 'type'), _react.default.createElement(_TypeLink.default, {\n      type: field.type,\n      onClick: this.props.onClickType\n    })), argsDef);\n  }\n\n}\n\nexports.default = FieldDoc;\n\n_defineProperty(FieldDoc, \"propTypes\", {\n  field: _propTypes.default.object,\n  onClickType: _propTypes.default.func\n});","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.default = void 0;\n\nvar _react = _interopRequireDefault(require(\"react\"));\n\nvar _propTypes = _interopRequireDefault(require(\"prop-types\"));\n\nvar _TypeLink = _interopRequireDefault(require(\"./TypeLink\"));\n\nvar _MarkdownContent = _interopRequireDefault(require(\"./MarkdownContent\"));\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\n// Render the top level Schema\nclass SchemaDoc extends _react.default.Component {\n  shouldComponentUpdate(nextProps) {\n    return this.props.schema !== nextProps.schema;\n  }\n\n  render() {\n    const schema = this.props.schema;\n    const queryType = schema.getQueryType();\n    const mutationType = schema.getMutationType && schema.getMutationType();\n    const subscriptionType = schema.getSubscriptionType && schema.getSubscriptionType();\n    return _react.default.createElement(\"div\", null, _react.default.createElement(_MarkdownContent.default, {\n      className: \"doc-type-description\",\n      markdown: 'A GraphQL schema provides a root type for each kind of operation.'\n    }), _react.default.createElement(\"div\", {\n      className: \"doc-category\"\n    }, _react.default.createElement(\"div\", {\n      className: \"doc-category-title\"\n    }, 'root types'), _react.default.createElement(\"div\", {\n      className: \"doc-category-item\"\n    }, _react.default.createElement(\"span\", {\n      className: \"keyword\"\n    }, 'query'), ': ', _react.default.createElement(_TypeLink.default, {\n      type: queryType,\n      onClick: this.props.onClickType\n    })), mutationType && _react.default.createElement(\"div\", {\n      className: \"doc-category-item\"\n    }, _react.default.createElement(\"span\", {\n      className: \"keyword\"\n    }, 'mutation'), ': ', _react.default.createElement(_TypeLink.default, {\n      type: mutationType,\n      onClick: this.props.onClickType\n    })), subscriptionType && _react.default.createElement(\"div\", {\n      className: \"doc-category-item\"\n    }, _react.default.createElement(\"span\", {\n      className: \"keyword\"\n    }, 'subscription'), ': ', _react.default.createElement(_TypeLink.default, {\n      type: subscriptionType,\n      onClick: this.props.onClickType\n    }))));\n  }\n\n}\n\nexports.default = SchemaDoc;\n\n_defineProperty(SchemaDoc, \"propTypes\", {\n  schema: _propTypes.default.object,\n  onClickType: _propTypes.default.func\n});","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.default = void 0;\n\nvar _react = _interopRequireDefault(require(\"react\"));\n\nvar _propTypes = _interopRequireDefault(require(\"prop-types\"));\n\nvar _debounce = _interopRequireDefault(require(\"../../utility/debounce\"));\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\nclass SearchBox extends _react.default.Component {\n  constructor(props) {\n    super(props);\n\n    _defineProperty(this, \"handleChange\", event => {\n      const value = event.target.value;\n      this.setState({\n        value\n      });\n      this.debouncedOnSearch(value);\n    });\n\n    _defineProperty(this, \"handleClear\", () => {\n      this.setState({\n        value: ''\n      });\n      this.props.onSearch('');\n    });\n\n    this.state = {\n      value: props.value || ''\n    };\n    this.debouncedOnSearch = (0, _debounce.default)(200, this.props.onSearch);\n  }\n\n  render() {\n    return _react.default.createElement(\"label\", {\n      className: \"search-box\"\n    }, _react.default.createElement(\"div\", {\n      className: \"search-box-icon\",\n      \"aria-hidden\": \"true\"\n    }, '\\u26b2'), _react.default.createElement(\"input\", {\n      value: this.state.value,\n      onChange: this.handleChange,\n      type: \"text\",\n      placeholder: this.props.placeholder,\n      \"aria-label\": this.props.placeholder\n    }), this.state.value && _react.default.createElement(\"button\", {\n      className: \"search-box-clear\",\n      onClick: this.handleClear,\n      \"aria-label\": \"Clear search input\"\n    }, '\\u2715'));\n  }\n\n}\n\nexports.default = SearchBox;\n\n_defineProperty(SearchBox, \"propTypes\", {\n  value: _propTypes.default.string,\n  placeholder: _propTypes.default.string,\n  onSearch: _propTypes.default.func\n});","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.default = void 0;\n\nvar _react = _interopRequireDefault(require(\"react\"));\n\nvar _propTypes = _interopRequireDefault(require(\"prop-types\"));\n\nvar _Argument = _interopRequireDefault(require(\"./Argument\"));\n\nvar _TypeLink = _interopRequireDefault(require(\"./TypeLink\"));\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\nclass SearchResults extends _react.default.Component {\n  shouldComponentUpdate(nextProps) {\n    return this.props.schema !== nextProps.schema || this.props.searchValue !== nextProps.searchValue;\n  }\n\n  render() {\n    const searchValue = this.props.searchValue;\n    const withinType = this.props.withinType;\n    const schema = this.props.schema;\n    const onClickType = this.props.onClickType;\n    const onClickField = this.props.onClickField;\n    const matchedWithin = [];\n    const matchedTypes = [];\n    const matchedFields = [];\n    const typeMap = schema.getTypeMap();\n    let typeNames = Object.keys(typeMap); // Move the within type name to be the first searched.\n\n    if (withinType) {\n      typeNames = typeNames.filter(n => n !== withinType.name);\n      typeNames.unshift(withinType.name);\n    }\n\n    for (const typeName of typeNames) {\n      if (matchedWithin.length + matchedTypes.length + matchedFields.length >= 100) {\n        break;\n      }\n\n      const type = typeMap[typeName];\n\n      if (withinType !== type && isMatch(typeName, searchValue)) {\n        matchedTypes.push(_react.default.createElement(\"div\", {\n          className: \"doc-category-item\",\n          key: typeName\n        }, _react.default.createElement(_TypeLink.default, {\n          type: type,\n          onClick: onClickType\n        })));\n      }\n\n      if (type.getFields) {\n        const fields = type.getFields();\n        Object.keys(fields).forEach(fieldName => {\n          const field = fields[fieldName];\n          let matchingArgs;\n\n          if (!isMatch(fieldName, searchValue)) {\n            if (field.args && field.args.length) {\n              matchingArgs = field.args.filter(arg => isMatch(arg.name, searchValue));\n\n              if (matchingArgs.length === 0) {\n                return;\n              }\n            } else {\n              return;\n            }\n          }\n\n          const match = _react.default.createElement(\"div\", {\n            className: \"doc-category-item\",\n            key: typeName + '.' + fieldName\n          }, withinType !== type && [_react.default.createElement(_TypeLink.default, {\n            key: \"type\",\n            type: type,\n            onClick: onClickType\n          }), '.'], _react.default.createElement(\"a\", {\n            className: \"field-name\",\n            onClick: event => onClickField(field, type, event)\n          }, field.name), matchingArgs && ['(', _react.default.createElement(\"span\", {\n            key: \"args\"\n          }, matchingArgs.map(arg => _react.default.createElement(_Argument.default, {\n            key: arg.name,\n            arg: arg,\n            onClickType: onClickType,\n            showDefaultValue: false\n          }))), ')']);\n\n          if (withinType === type) {\n            matchedWithin.push(match);\n          } else {\n            matchedFields.push(match);\n          }\n        });\n      }\n    }\n\n    if (matchedWithin.length + matchedTypes.length + matchedFields.length === 0) {\n      return _react.default.createElement(\"span\", {\n        className: \"doc-alert-text\"\n      }, 'No results found.');\n    }\n\n    if (withinType && matchedTypes.length + matchedFields.length > 0) {\n      return _react.default.createElement(\"div\", null, matchedWithin, _react.default.createElement(\"div\", {\n        className: \"doc-category\"\n      }, _react.default.createElement(\"div\", {\n        className: \"doc-category-title\"\n      }, 'other results'), matchedTypes, matchedFields));\n    }\n\n    return _react.default.createElement(\"div\", null, matchedWithin, matchedTypes, matchedFields);\n  }\n\n}\n\nexports.default = SearchResults;\n\n_defineProperty(SearchResults, \"propTypes\", {\n  schema: _propTypes.default.object,\n  withinType: _propTypes.default.object,\n  searchValue: _propTypes.default.string,\n  onClickType: _propTypes.default.func,\n  onClickField: _propTypes.default.func\n});\n\nfunction isMatch(sourceText, searchValue) {\n  try {\n    const escaped = searchValue.replace(/[^_0-9A-Za-z]/g, ch => '\\\\' + ch);\n    return sourceText.search(new RegExp(escaped, 'i')) !== -1;\n  } catch (e) {\n    return sourceText.toLowerCase().indexOf(searchValue.toLowerCase()) !== -1;\n  }\n}","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.default = void 0;\n\nvar _react = _interopRequireDefault(require(\"react\"));\n\nvar _propTypes = _interopRequireDefault(require(\"prop-types\"));\n\nvar _graphql = require(\"graphql\");\n\nvar _Argument = _interopRequireDefault(require(\"./Argument\"));\n\nvar _MarkdownContent = _interopRequireDefault(require(\"./MarkdownContent\"));\n\nvar _TypeLink = _interopRequireDefault(require(\"./TypeLink\"));\n\nvar _DefaultValue = _interopRequireDefault(require(\"./DefaultValue\"));\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\nclass TypeDoc extends _react.default.Component {\n  constructor(props) {\n    super(props);\n\n    _defineProperty(this, \"handleShowDeprecated\", () => this.setState({\n      showDeprecated: true\n    }));\n\n    this.state = {\n      showDeprecated: false\n    };\n  }\n\n  shouldComponentUpdate(nextProps, nextState) {\n    return this.props.type !== nextProps.type || this.props.schema !== nextProps.schema || this.state.showDeprecated !== nextState.showDeprecated;\n  }\n\n  render() {\n    const schema = this.props.schema;\n    const type = this.props.type;\n    const onClickType = this.props.onClickType;\n    const onClickField = this.props.onClickField;\n    let typesTitle;\n    let types;\n\n    if (type instanceof _graphql.GraphQLUnionType) {\n      typesTitle = 'possible types';\n      types = schema.getPossibleTypes(type);\n    } else if (type instanceof _graphql.GraphQLInterfaceType) {\n      typesTitle = 'implementations';\n      types = schema.getPossibleTypes(type);\n    } else if (type instanceof _graphql.GraphQLObjectType) {\n      typesTitle = 'implements';\n      types = type.getInterfaces();\n    }\n\n    let typesDef;\n\n    if (types && types.length > 0) {\n      typesDef = _react.default.createElement(\"div\", {\n        className: \"doc-category\"\n      }, _react.default.createElement(\"div\", {\n        className: \"doc-category-title\"\n      }, typesTitle), types.map(subtype => _react.default.createElement(\"div\", {\n        key: subtype.name,\n        className: \"doc-category-item\"\n      }, _react.default.createElement(_TypeLink.default, {\n        type: subtype,\n        onClick: onClickType\n      }))));\n    } // InputObject and Object\n\n\n    let fieldsDef;\n    let deprecatedFieldsDef;\n\n    if (type.getFields) {\n      const fieldMap = type.getFields();\n      const fields = Object.keys(fieldMap).map(name => fieldMap[name]);\n      fieldsDef = _react.default.createElement(\"div\", {\n        className: \"doc-category\"\n      }, _react.default.createElement(\"div\", {\n        className: \"doc-category-title\"\n      }, 'fields'), fields.filter(field => !field.isDeprecated).map(field => _react.default.createElement(Field, {\n        key: field.name,\n        type: type,\n        field: field,\n        onClickType: onClickType,\n        onClickField: onClickField\n      })));\n      const deprecatedFields = fields.filter(field => field.isDeprecated);\n\n      if (deprecatedFields.length > 0) {\n        deprecatedFieldsDef = _react.default.createElement(\"div\", {\n          className: \"doc-category\"\n        }, _react.default.createElement(\"div\", {\n          className: \"doc-category-title\"\n        }, 'deprecated fields'), !this.state.showDeprecated ? _react.default.createElement(\"button\", {\n          className: \"show-btn\",\n          onClick: this.handleShowDeprecated\n        }, 'Show deprecated fields...') : deprecatedFields.map(field => _react.default.createElement(Field, {\n          key: field.name,\n          type: type,\n          field: field,\n          onClickType: onClickType,\n          onClickField: onClickField\n        })));\n      }\n    }\n\n    let valuesDef;\n    let deprecatedValuesDef;\n\n    if (type instanceof _graphql.GraphQLEnumType) {\n      const values = type.getValues();\n      valuesDef = _react.default.createElement(\"div\", {\n        className: \"doc-category\"\n      }, _react.default.createElement(\"div\", {\n        className: \"doc-category-title\"\n      }, 'values'), values.filter(value => !value.isDeprecated).map(value => _react.default.createElement(EnumValue, {\n        key: value.name,\n        value: value\n      })));\n      const deprecatedValues = values.filter(value => value.isDeprecated);\n\n      if (deprecatedValues.length > 0) {\n        deprecatedValuesDef = _react.default.createElement(\"div\", {\n          className: \"doc-category\"\n        }, _react.default.createElement(\"div\", {\n          className: \"doc-category-title\"\n        }, 'deprecated values'), !this.state.showDeprecated ? _react.default.createElement(\"button\", {\n          className: \"show-btn\",\n          onClick: this.handleShowDeprecated\n        }, 'Show deprecated values...') : deprecatedValues.map(value => _react.default.createElement(EnumValue, {\n          key: value.name,\n          value: value\n        })));\n      }\n    }\n\n    return _react.default.createElement(\"div\", null, _react.default.createElement(_MarkdownContent.default, {\n      className: \"doc-type-description\",\n      markdown: type.description || 'No Description'\n    }), type instanceof _graphql.GraphQLObjectType && typesDef, fieldsDef, deprecatedFieldsDef, valuesDef, deprecatedValuesDef, !(type instanceof _graphql.GraphQLObjectType) && typesDef);\n  }\n\n}\n\nexports.default = TypeDoc;\n\n_defineProperty(TypeDoc, \"propTypes\", {\n  schema: _propTypes.default.instanceOf(_graphql.GraphQLSchema),\n  type: _propTypes.default.object,\n  onClickType: _propTypes.default.func,\n  onClickField: _propTypes.default.func\n});\n\nfunction Field({\n  type,\n  field,\n  onClickType,\n  onClickField\n}) {\n  return _react.default.createElement(\"div\", {\n    className: \"doc-category-item\"\n  }, _react.default.createElement(\"a\", {\n    className: \"field-name\",\n    onClick: event => onClickField(field, type, event)\n  }, field.name), field.args && field.args.length > 0 && ['(', _react.default.createElement(\"span\", {\n    key: \"args\"\n  }, field.args.map(arg => _react.default.createElement(_Argument.default, {\n    key: arg.name,\n    arg: arg,\n    onClickType: onClickType\n  }))), ')'], ': ', _react.default.createElement(_TypeLink.default, {\n    type: field.type,\n    onClick: onClickType\n  }), _react.default.createElement(_DefaultValue.default, {\n    field: field\n  }), field.description && _react.default.createElement(_MarkdownContent.default, {\n    className: \"field-short-description\",\n    markdown: field.description\n  }), field.deprecationReason && _react.default.createElement(_MarkdownContent.default, {\n    className: \"doc-deprecation\",\n    markdown: field.deprecationReason\n  }));\n}\n\nField.propTypes = {\n  type: _propTypes.default.object,\n  field: _propTypes.default.object,\n  onClickType: _propTypes.default.func,\n  onClickField: _propTypes.default.func\n};\n\nfunction EnumValue({\n  value\n}) {\n  return _react.default.createElement(\"div\", {\n    className: \"doc-category-item\"\n  }, _react.default.createElement(\"div\", {\n    className: \"enum-value\"\n  }, value.name), _react.default.createElement(_MarkdownContent.default, {\n    className: \"doc-value-description\",\n    markdown: value.description\n  }), value.deprecationReason && _react.default.createElement(_MarkdownContent.default, {\n    className: \"doc-deprecation\",\n    markdown: value.deprecationReason\n  }));\n}\n\nEnumValue.propTypes = {\n  value: _propTypes.default.object\n};","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.QueryHistory = void 0;\n\nvar _graphql = require(\"graphql\");\n\nvar _react = _interopRequireDefault(require(\"react\"));\n\nvar _propTypes = _interopRequireDefault(require(\"prop-types\"));\n\nvar _QueryStore = _interopRequireDefault(require(\"../utility/QueryStore\"));\n\nvar _HistoryQuery = _interopRequireDefault(require(\"./HistoryQuery\"));\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\nconst MAX_QUERY_SIZE = 100000;\nconst MAX_HISTORY_LENGTH = 20;\n\nconst shouldSaveQuery = (nextProps, current, lastQuerySaved) => {\n  if (nextProps.queryID === current.queryID) {\n    return false;\n  }\n\n  try {\n    (0, _graphql.parse)(nextProps.query);\n  } catch (e) {\n    return false;\n  } // Don't try to save giant queries\n\n\n  if (nextProps.query.length > MAX_QUERY_SIZE) {\n    return false;\n  }\n\n  if (!lastQuerySaved) {\n    return true;\n  }\n\n  if (JSON.stringify(nextProps.query) === JSON.stringify(lastQuerySaved.query)) {\n    if (JSON.stringify(nextProps.variables) === JSON.stringify(lastQuerySaved.variables)) {\n      return false;\n    }\n\n    if (!nextProps.variables && !lastQuerySaved.variables) {\n      return false;\n    }\n  }\n\n  return true;\n};\n\nclass QueryHistory extends _react.default.Component {\n  constructor(props) {\n    super(props);\n\n    _defineProperty(this, \"toggleFavorite\", (query, variables, operationName, label, favorite) => {\n      const item = {\n        query,\n        variables,\n        operationName,\n        label\n      };\n\n      if (!this.favoriteStore.contains(item)) {\n        item.favorite = true;\n        this.favoriteStore.push(item);\n      } else if (favorite) {\n        item.favorite = false;\n        this.favoriteStore.delete(item);\n      }\n\n      this.setState({\n        queries: [...this.historyStore.items, ...this.favoriteStore.items]\n      });\n    });\n\n    _defineProperty(this, \"editLabel\", (query, variables, operationName, label, favorite) => {\n      const item = {\n        query,\n        variables,\n        operationName,\n        label\n      };\n\n      if (favorite) {\n        this.favoriteStore.edit({ ...item,\n          favorite\n        });\n      } else {\n        this.historyStore.edit(item);\n      }\n\n      this.setState({\n        queries: [...this.historyStore.items, ...this.favoriteStore.items]\n      });\n    });\n\n    this.historyStore = new _QueryStore.default('queries', props.storage, MAX_HISTORY_LENGTH); // favorites are not automatically deleted, so there's no need for a max length\n\n    this.favoriteStore = new _QueryStore.default('favorites', props.storage, null);\n    const historyQueries = this.historyStore.fetchAll();\n    const favoriteQueries = this.favoriteStore.fetchAll();\n    const queries = historyQueries.concat(favoriteQueries);\n    this.state = {\n      queries\n    };\n  }\n\n  componentWillReceiveProps(nextProps) {\n    if (shouldSaveQuery(nextProps, this.props, this.historyStore.fetchRecent())) {\n      const item = {\n        query: nextProps.query,\n        variables: nextProps.variables,\n        operationName: nextProps.operationName\n      };\n      this.historyStore.push(item);\n      const historyQueries = this.historyStore.items;\n      const favoriteQueries = this.favoriteStore.items;\n      const queries = historyQueries.concat(favoriteQueries);\n      this.setState({\n        queries\n      });\n    }\n  }\n\n  render() {\n    const queries = this.state.queries.slice().reverse();\n    const queryNodes = queries.map((query, i) => {\n      return _react.default.createElement(_HistoryQuery.default, _extends({\n        handleEditLabel: this.editLabel,\n        handleToggleFavorite: this.toggleFavorite,\n        key: `${i}:${query.label || query.query}`,\n        onSelect: this.props.onSelectQuery\n      }, query));\n    });\n    return _react.default.createElement(\"section\", {\n      \"aria-label\": \"History\"\n    }, _react.default.createElement(\"div\", {\n      className: \"history-title-bar\"\n    }, _react.default.createElement(\"div\", {\n      className: \"history-title\"\n    }, 'History'), _react.default.createElement(\"div\", {\n      className: \"doc-explorer-rhs\"\n    }, this.props.children)), _react.default.createElement(\"ul\", {\n      className: \"history-contents\"\n    }, queryNodes));\n  }\n\n}\n\nexports.QueryHistory = QueryHistory;\n\n_defineProperty(QueryHistory, \"propTypes\", {\n  query: _propTypes.default.string,\n  variables: _propTypes.default.string,\n  operationName: _propTypes.default.string,\n  queryID: _propTypes.default.number,\n  onSelectQuery: _propTypes.default.func,\n  storage: _propTypes.default.object\n});","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.default = void 0;\n\n/**\n *  Copyright (c) 2019 GraphQL Contributors.\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 */\nclass QueryStore {\n  constructor(key, storage, maxSize = null) {\n    this.key = key;\n    this.storage = storage;\n    this.maxSize = maxSize;\n    this.items = this.fetchAll();\n  }\n\n  get length() {\n    return this.items.length;\n  }\n\n  contains(item) {\n    return this.items.some(x => x.query === item.query && x.variables === item.variables && x.operationName === item.operationName);\n  }\n\n  edit(item) {\n    const itemIndex = this.items.findIndex(x => x.query === item.query && x.variables === item.variables && x.operationName === item.operationName);\n\n    if (itemIndex !== -1) {\n      this.items.splice(itemIndex, 1, item);\n      this.save();\n    }\n  }\n\n  delete(item) {\n    const itemIndex = this.items.findIndex(x => x.query === item.query && x.variables === item.variables && x.operationName === item.operationName);\n\n    if (itemIndex !== -1) {\n      this.items.splice(itemIndex, 1);\n      this.save();\n    }\n  }\n\n  fetchRecent() {\n    return this.items[this.items.length - 1];\n  }\n\n  fetchAll() {\n    const raw = this.storage.get(this.key);\n\n    if (raw) {\n      return JSON.parse(raw)[this.key];\n    }\n\n    return [];\n  }\n\n  push(item) {\n    const items = [...this.items, item];\n\n    if (this.maxSize && items.length > this.maxSize) {\n      items.shift();\n    }\n\n    for (let attempts = 0; attempts < 5; attempts++) {\n      const response = this.storage.set(this.key, JSON.stringify({\n        [this.key]: items\n      }));\n      ;\n\n      if (!response || !response.error) {\n        this.items = items;\n      } else if (response.isQuotaError && this.maxSize) {\n        // Only try to delete last items on LRU stores\n        items.shift();\n      } else {\n        return; // We don't know what happened in this case, so just bailing out\n      }\n    }\n  }\n\n  save() {\n    this.storage.set(this.key, JSON.stringify({\n      [this.key]: this.items\n    }));\n  }\n\n}\n\nexports.default = QueryStore;","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.default = void 0;\n\nvar _react = _interopRequireDefault(require(\"react\"));\n\nvar _propTypes = _interopRequireDefault(require(\"prop-types\"));\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\nclass HistoryQuery extends _react.default.Component {\n  constructor(props) {\n    super(props);\n\n    _defineProperty(this, \"editField\", null);\n\n    this.state = {\n      editable: false\n    };\n  }\n\n  render() {\n    const displayName = this.props.label || this.props.operationName || this.props.query.split('\\n').filter(line => line.indexOf('#') !== 0).join('');\n    const starIcon = this.props.favorite ? '\\u2605' : '\\u2606';\n    return _react.default.createElement(\"li\", {\n      className: this.state.editable ? 'editable' : undefined\n    }, this.state.editable ? _react.default.createElement(\"input\", {\n      type: \"text\",\n      defaultValue: this.props.label,\n      ref: c => this.editField = c,\n      onBlur: this.handleFieldBlur.bind(this),\n      onKeyDown: this.handleFieldKeyDown.bind(this),\n      placeholder: \"Type a label\"\n    }) : _react.default.createElement(\"button\", {\n      className: \"history-label\",\n      onClick: this.handleClick.bind(this)\n    }, displayName), _react.default.createElement(\"button\", {\n      onClick: this.handleEditClick.bind(this),\n      \"aria-label\": \"Edit label\"\n    }, '\\u270e'), _react.default.createElement(\"button\", {\n      className: this.props.favorite ? 'favorited' : undefined,\n      onClick: this.handleStarClick.bind(this),\n      \"aria-label\": this.props.favorite ? 'Remove favorite' : 'Add favorite'\n    }, starIcon));\n  }\n\n  handleClick() {\n    this.props.onSelect(this.props.query, this.props.variables, this.props.operationName, this.props.label);\n  }\n\n  handleStarClick(e) {\n    e.stopPropagation();\n    this.props.handleToggleFavorite(this.props.query, this.props.variables, this.props.operationName, this.props.label, this.props.favorite);\n  }\n\n  handleFieldBlur(e) {\n    e.stopPropagation();\n    this.setState({\n      editable: false\n    });\n    this.props.handleEditLabel(this.props.query, this.props.variables, this.props.operationName, e.target.value, this.props.favorite);\n  }\n\n  handleFieldKeyDown(e) {\n    if (e.keyCode === 13) {\n      e.stopPropagation();\n      this.setState({\n        editable: false\n      });\n      this.props.handleEditLabel(this.props.query, this.props.variables, this.props.operationName, e.target.value, this.props.favorite);\n    }\n  }\n\n  handleEditClick(e) {\n    e.stopPropagation();\n    this.setState({\n      editable: true\n    }, () => {\n      if (this.editField) {\n        this.editField.focus();\n      }\n    });\n  }\n\n}\n\nexports.default = HistoryQuery;\n\n_defineProperty(HistoryQuery, \"propTypes\", {\n  favorite: _propTypes.default.bool,\n  favoriteSize: _propTypes.default.number,\n  handleEditLabel: _propTypes.default.func,\n  handleToggleFavorite: _propTypes.default.func,\n  operationName: _propTypes.default.string,\n  onSelect: _propTypes.default.func,\n  query: _propTypes.default.string,\n  variables: _propTypes.default.string,\n  label: _propTypes.default.string\n});","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.default = void 0;\n\n/**\n *  Copyright (c) 2019 GraphQL Contributors.\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/**\n * When a containing DOM node's height has been altered, trigger a resize of\n * the related CodeMirror instance so that it is always correctly sized.\n */\nclass CodeMirrorSizer {\n  constructor() {\n    this.sizes = [];\n  }\n\n  updateSizes(components) {\n    components.forEach((component, i) => {\n      const size = component.getClientHeight();\n\n      if (i <= this.sizes.length && size !== this.sizes[i]) {\n        component.getCodeMirror().setSize();\n      }\n\n      this.sizes[i] = size;\n    });\n  }\n\n}\n\nexports.default = CodeMirrorSizer;","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.default = void 0;\n\n/**\n *  Copyright (c) 2019 GraphQL Contributors.\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 */\nfunction isQuotaError(storage, e) {\n  return e instanceof DOMException && ( // everything except Firefox\n  e.code === 22 || // Firefox\n  e.code === 1014 || // test name field too, because code might not be present\n  // everything except Firefox\n  e.name === 'QuotaExceededError' || // Firefox\n  e.name === 'NS_ERROR_DOM_QUOTA_REACHED') && // acknowledge QuotaExceededError only if there's something already stored\n  storage.length !== 0;\n}\n\nclass StorageAPI {\n  constructor(storage) {\n    this.storage = storage || (typeof window !== 'undefined' ? window.localStorage : null);\n  }\n\n  get(name) {\n    if (this.storage) {\n      const value = this.storage.getItem('graphiql:' + name); // Clean up any inadvertently saved null/undefined values.\n\n      if (value === 'null' || value === 'undefined') {\n        this.storage.removeItem('graphiql:' + name);\n        return null;\n      }\n\n      return value;\n    }\n\n    return null;\n  }\n\n  set(name, value) {\n    let quotaError = false;\n    let error = null;\n\n    if (this.storage) {\n      const key = `graphiql:${name}`;\n\n      if (value) {\n        try {\n          this.storage.setItem(key, value);\n        } catch (e) {\n          error = e;\n          quotaError = isQuotaError(this.storage, e);\n        }\n      } else {\n        // Clean up by removing the item if there's no value to set\n        this.storage.removeItem(key);\n      }\n    }\n\n    return {\n      isQuotaError: quotaError,\n      error\n    };\n  }\n\n}\n\nexports.default = StorageAPI;","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.default = getQueryFacts;\nexports.collectVariables = collectVariables;\n\nvar _graphql = require(\"graphql\");\n\n/**\n *  Copyright (c) 2019 GraphQL Contributors.\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/**\n * Provided previous \"queryFacts\", a GraphQL schema, and a query document\n * string, return a set of facts about that query useful for GraphiQL features.\n *\n * If the query cannot be parsed, returns undefined.\n */\nfunction getQueryFacts(schema, documentStr) {\n  if (!documentStr) {\n    return;\n  }\n\n  let documentAST;\n\n  try {\n    documentAST = (0, _graphql.parse)(documentStr);\n  } catch (e) {\n    return;\n  }\n\n  const variableToType = schema ? collectVariables(schema, documentAST) : null; // Collect operations by their names.\n\n  const operations = [];\n  documentAST.definitions.forEach(def => {\n    if (def.kind === 'OperationDefinition') {\n      operations.push(def);\n    }\n  });\n  return {\n    variableToType,\n    operations\n  };\n}\n/**\n * Provided a schema and a document, produces a `variableToType` Object.\n */\n\n\nfunction collectVariables(schema, documentAST) {\n  const variableToType = Object.create(null);\n  documentAST.definitions.forEach(definition => {\n    if (definition.kind === 'OperationDefinition') {\n      const variableDefinitions = definition.variableDefinitions;\n\n      if (variableDefinitions) {\n        variableDefinitions.forEach(({\n          variable,\n          type\n        }) => {\n          const inputType = (0, _graphql.typeFromAST)(schema, type);\n\n          if (inputType) {\n            variableToType[variable.name.value] = inputType;\n          }\n        });\n      }\n    }\n  });\n  return variableToType;\n}","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.default = getSelectedOperationName;\n\n/**\n *  Copyright (c) 2019 GraphQL Contributors.\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/**\n * Provided optional previous operations and selected name, and a next list of\n * operations, determine what the next selected operation should be.\n */\nfunction getSelectedOperationName(prevOperations, prevSelectedOperationName, operations) {\n  // If there are not enough operations to bother with, return nothing.\n  if (!operations || operations.length < 1) {\n    return;\n  } // If a previous selection still exists, continue to use it.\n\n\n  const names = operations.map(op => op.name && op.name.value);\n\n  if (prevSelectedOperationName && names.indexOf(prevSelectedOperationName) !== -1) {\n    return prevSelectedOperationName;\n  } // If a previous selection was the Nth operation, use the same Nth.\n\n\n  if (prevSelectedOperationName && prevOperations) {\n    const prevNames = prevOperations.map(op => op.name && op.name.value);\n    const prevIndex = prevNames.indexOf(prevSelectedOperationName);\n\n    if (prevIndex !== -1 && prevIndex < names.length) {\n      return names[prevIndex];\n    }\n  } // Use the first operation.\n\n\n  return names[0];\n}","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.default = find;\n\n/**\n *  Copyright (c) 2019 GraphQL Contributors.\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 *\n */\nfunction find(list, predicate) {\n  for (let i = 0; i < list.length; i++) {\n    if (predicate(list[i])) {\n      return list[i];\n    }\n  }\n}","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.fillLeafs = fillLeafs;\n\nvar _graphql = require(\"graphql\");\n\n/**\n *  Copyright (c) 2019 GraphQL Contributors.\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/**\n * Given a document string which may not be valid due to terminal fields not\n * representing leaf values (Spec Section: \"Leaf Field Selections\"), and a\n * function which provides reasonable default field names for a given type,\n * this function will attempt to produce a schema which is valid after filling\n * in selection sets for the invalid fields.\n *\n * Note that there is no guarantee that the result will be a valid query, this\n * utility represents a \"best effort\" which may be useful within IDE tools.\n */\nfunction fillLeafs(schema, docString, getDefaultFieldNames) {\n  const insertions = [];\n\n  if (!schema) {\n    return {\n      insertions,\n      result: docString\n    };\n  }\n\n  let ast;\n\n  try {\n    ast = (0, _graphql.parse)(docString);\n  } catch (error) {\n    return {\n      insertions,\n      result: docString\n    };\n  }\n\n  const fieldNameFn = getDefaultFieldNames || defaultGetDefaultFieldNames;\n  const typeInfo = new _graphql.TypeInfo(schema);\n  (0, _graphql.visit)(ast, {\n    leave(node) {\n      typeInfo.leave(node);\n    },\n\n    enter(node) {\n      typeInfo.enter(node);\n\n      if (node.kind === 'Field' && !node.selectionSet) {\n        const fieldType = typeInfo.getType();\n        const selectionSet = buildSelectionSet(fieldType, fieldNameFn);\n\n        if (selectionSet) {\n          const indent = getIndentation(docString, node.loc.start);\n          insertions.push({\n            index: node.loc.end,\n            string: ' ' + (0, _graphql.print)(selectionSet).replace(/\\n/g, '\\n' + indent)\n          });\n        }\n      }\n    }\n\n  }); // Apply the insertions, but also return the insertions metadata.\n\n  return {\n    insertions,\n    result: withInsertions(docString, insertions)\n  };\n} // The default function to use for producing the default fields from a type.\n// This function first looks for some common patterns, and falls back to\n// including all leaf-type fields.\n\n\nfunction defaultGetDefaultFieldNames(type) {\n  // If this type cannot access fields, then return an empty set.\n  if (!type.getFields) {\n    return [];\n  }\n\n  const fields = type.getFields(); // Is there an `id` field?\n\n  if (fields['id']) {\n    return ['id'];\n  } // Is there an `edges` field?\n\n\n  if (fields['edges']) {\n    return ['edges'];\n  } // Is there an `node` field?\n\n\n  if (fields['node']) {\n    return ['node'];\n  } // Include all leaf-type fields.\n\n\n  const leafFieldNames = [];\n  Object.keys(fields).forEach(fieldName => {\n    if ((0, _graphql.isLeafType)(fields[fieldName].type)) {\n      leafFieldNames.push(fieldName);\n    }\n  });\n  return leafFieldNames;\n} // Given a GraphQL type, and a function which produces field names, recursively\n// generate a SelectionSet which includes default fields.\n\n\nfunction buildSelectionSet(type, getDefaultFieldNames) {\n  // Unwrap any non-null or list types.\n  const namedType = (0, _graphql.getNamedType)(type); // Unknown types and leaf types do not have selection sets.\n\n  if (!type || (0, _graphql.isLeafType)(type)) {\n    return;\n  } // Get an array of field names to use.\n\n\n  const fieldNames = getDefaultFieldNames(namedType); // If there are no field names to use, return no selection set.\n\n  if (!Array.isArray(fieldNames) || fieldNames.length === 0) {\n    return;\n  } // Build a selection set of each field, calling buildSelectionSet recursively.\n\n\n  return {\n    kind: 'SelectionSet',\n    selections: fieldNames.map(fieldName => {\n      const fieldDef = namedType.getFields()[fieldName];\n      const fieldType = fieldDef ? fieldDef.type : null;\n      return {\n        kind: 'Field',\n        name: {\n          kind: 'Name',\n          value: fieldName\n        },\n        selectionSet: buildSelectionSet(fieldType, getDefaultFieldNames)\n      };\n    })\n  };\n} // Given an initial string, and a list of \"insertion\" { index, string } objects,\n// return a new string with these insertions applied.\n\n\nfunction withInsertions(initial, insertions) {\n  if (insertions.length === 0) {\n    return initial;\n  }\n\n  let edited = '';\n  let prevIndex = 0;\n  insertions.forEach(({\n    index,\n    string\n  }) => {\n    edited += initial.slice(prevIndex, index) + string;\n    prevIndex = index;\n  });\n  edited += initial.slice(prevIndex);\n  return edited;\n} // Given a string and an index, look backwards to find the string of whitespace\n// following the next previous line break.\n\n\nfunction getIndentation(str, index) {\n  let indentStart = index;\n  let indentEnd = index;\n\n  while (indentStart) {\n    const c = str.charCodeAt(indentStart - 1); // line break\n\n    if (c === 10 || c === 13 || c === 0x2028 || c === 0x2029) {\n      break;\n    }\n\n    indentStart--; // not white space\n\n    if (c !== 9 && c !== 11 && c !== 12 && c !== 32 && c !== 160) {\n      indentEnd = indentStart;\n    }\n  }\n\n  return str.substring(indentStart, indentEnd);\n}","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.getLeft = getLeft;\nexports.getTop = getTop;\n\n/**\n *  Copyright (c) 2019 GraphQL Contributors.\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/**\n * Utility functions to get a pixel distance from left/top of the window.\n */\nfunction getLeft(initialElem) {\n  let pt = 0;\n  let elem = initialElem;\n\n  while (elem.offsetParent) {\n    pt += elem.offsetLeft;\n    elem = elem.offsetParent;\n  }\n\n  return pt;\n}\n\nfunction getTop(initialElem) {\n  let pt = 0;\n  let elem = initialElem;\n\n  while (elem.offsetParent) {\n    pt += elem.offsetTop;\n    elem = elem.offsetParent;\n  }\n\n  return pt;\n}","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.mergeAst = mergeAst;\n\nvar _kinds = require(\"graphql/language/kinds\");\n\n/**\n *  Copyright (c) 2019 GraphQL Contributors.\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 */\nfunction resolveDefinition(fragments, obj) {\n  let definition = obj;\n\n  if (definition.kind === _kinds.Kind.FRAGMENT_SPREAD) {\n    definition = fragments[definition.name.value];\n  }\n\n  if (definition.selectionSet) {\n    definition.selectionSet.selections = definition.selectionSet.selections.filter((selection, idx, self) => selection.kind !== _kinds.Kind.FRAGMENT_SPREAD || idx === self.findIndex(_selection => _selection.kind === _kinds.Kind.FRAGMENT_SPREAD && selection.name.value === _selection.name.value)).map(selection => resolveDefinition(fragments, selection));\n  }\n\n  return definition;\n}\n\nfunction mergeAst(queryAst) {\n  const fragments = {};\n  queryAst.definitions.filter(elem => {\n    return elem.kind === _kinds.Kind.FRAGMENT_DEFINITION;\n  }).forEach(frag => {\n    const copyFragment = { ...frag\n    };\n    copyFragment.kind = _kinds.Kind.INLINE_FRAGMENT;\n    fragments[frag.name.value] = copyFragment;\n  });\n  const copyAst = { ...queryAst\n  };\n  copyAst.definitions = queryAst.definitions.filter(elem => {\n    return elem.kind !== _kinds.Kind.FRAGMENT_DEFINITION;\n  }).map(op => resolveDefinition(fragments, op));\n  return copyAst;\n}","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nObject.defineProperty(exports, \"introspectionQuery\", {\n  enumerable: true,\n  get: function () {\n    return _graphql.introspectionQuery;\n  }\n});\nexports.introspectionQuerySansSubscriptions = exports.introspectionQueryName = void 0;\n\nvar _graphql = require(\"graphql\");\n\n/**\n *  Copyright (c) 2019 GraphQL Contributors.\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 */\nconst introspectionQueryName = (0, _graphql.getOperationAST)((0, _graphql.parse)(_graphql.introspectionQuery)).name.value; // Some GraphQL services do not support subscriptions and fail an introspection\n// query which includes the `subscriptionType` field as the stock introspection\n// query does. This backup query removes that field.\n\nexports.introspectionQueryName = introspectionQueryName;\nconst introspectionQuerySansSubscriptions = `\n  query ${introspectionQueryName} {\n    __schema {\n      queryType { name }\n      mutationType { name }\n      types {\n        ...FullType\n      }\n      directives {\n        name\n        description\n        locations\n        args {\n          ...InputValue\n        }\n      }\n    }\n  }\n\n  fragment FullType on __Type {\n    kind\n    name\n    description\n    fields(includeDeprecated: true) {\n      name\n      description\n      args {\n        ...InputValue\n      }\n      type {\n        ...TypeRef\n      }\n      isDeprecated\n      deprecationReason\n    }\n    inputFields {\n      ...InputValue\n    }\n    interfaces {\n      ...TypeRef\n    }\n    enumValues(includeDeprecated: true) {\n      name\n      description\n      isDeprecated\n      deprecationReason\n    }\n    possibleTypes {\n      ...TypeRef\n    }\n  }\n\n  fragment InputValue on __InputValue {\n    name\n    description\n    type { ...TypeRef }\n    defaultValue\n  }\n\n  fragment TypeRef on __Type {\n    kind\n    name\n    ofType {\n      kind\n      name\n      ofType {\n        kind\n        name\n        ofType {\n          kind\n          name\n          ofType {\n            kind\n            name\n            ofType {\n              kind\n              name\n              ofType {\n                kind\n                name\n                ofType {\n                  kind\n                  name\n                }\n              }\n            }\n          }\n        }\n      }\n    }\n  }\n`;\nexports.introspectionQuerySansSubscriptions = introspectionQuerySansSubscriptions;"],"sourceRoot":""}